qdrawutil.h File Reference

#include <QtCore/qnamespace.h>
#include <QtCore/qstring.h>
#include <QtCore/qmargins.h>
#include <QtGui/qpixmap.h>

Go to the source code of this file.

Classes
class	QTileRules
	Holds the rules used to draw a pixmap or image split into nine segments, similar to [CSS3 border-images](http://www. More...

Functions
Q_GUI_EXPORT void	qDrawBorderPixmap (QPainter *painter, const QRect &targetRect, const QMargins &targetMargins, const QPixmap &pixmap, const QRect &sourceRect, const QMargins &sourceMargins, const QTileRules &rules=QTileRules())
void	qDrawBorderPixmap (QPainter *painter, const QRect &target, const QMargins &margins, const QPixmap &pixmap)
Q_GUI_EXPORT void	qDrawPlainRect (QPainter *p, int x, int y, int w, int h, const QColor &, int lineWidth=1, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawPlainRect (QPainter *p, const QRect &r, const QColor &, int lineWidth=1, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawShadeLine (QPainter *p, int x1, int y1, int x2, int y2, const QPalette &pal, bool sunken=true, int lineWidth=1, int midLineWidth=0)
Q_GUI_EXPORT void	qDrawShadeLine (QPainter *p, const QPoint &p1, const QPoint &p2, const QPalette &pal, bool sunken=true, int lineWidth=1, int midLineWidth=0)
Q_GUI_EXPORT void	qDrawShadePanel (QPainter *p, int x, int y, int w, int h, const QPalette &pal, bool sunken=false, int lineWidth=1, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawShadePanel (QPainter *p, const QRect &r, const QPalette &pal, bool sunken=false, int lineWidth=1, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawShadeRect (QPainter *p, int x, int y, int w, int h, const QPalette &pal, bool sunken=false, int lineWidth=1, int midLineWidth=0, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawShadeRect (QPainter *p, const QRect &r, const QPalette &pal, bool sunken=false, int lineWidth=1, int midLineWidth=0, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawWinButton (QPainter *p, int x, int y, int w, int h, const QPalette &pal, bool sunken=false, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawWinButton (QPainter *p, const QRect &r, const QPalette &pal, bool sunken=false, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawWinPanel (QPainter *p, int x, int y, int w, int h, const QPalette &pal, bool sunken=false, const QBrush *fill=0)
Q_GUI_EXPORT void	qDrawWinPanel (QPainter *p, const QRect &r, const QPalette &pal, bool sunken=false, const QBrush *fill=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Draws the Windows-style panel at the rectangle specified by rect using the given painter with a line width of 2 pixels. More...

Function Documentation

qDrawBorderPixmap() [1/2]

Q_GUI_EXPORT void qDrawBorderPixmap	(	QPainter *	painter,
		const QRect &	targetRect,
		const QMargins &	targetMargins,
		const QPixmap &	pixmap,
		const QRect &	sourceRect,
		const QMargins &	sourceMargins,
		const QTileRules &	rules = QTileRules()
	)

Referenced by qDrawBorderPixmap().

qDrawBorderPixmap() [2/2]

void qDrawBorderPixmap ( QPainter *  painter, const QRect &  target, const QMargins &  margins, const QPixmap &  pixmap  )

inline

Definition at line 183 of file qdrawutil.h.

{
    qDrawBorderPixmap(painter, target, margins, pixmap, pixmap.rect(), margins);
}

qDrawPlainRect() [1/2]

Q_GUI_EXPORT void qDrawPlainRect	(	QPainter *	p,
		int	x,
		int	y,
		int	w,
		int	h,
		const QColor &	,
		int	lineWidth = 1,
		const QBrush *	fill = 0
	)

Definition at line 511 of file qdrawutil.cpp.

Referenced by QWindowsMobileStyle::drawComplexControl(), QCommonStyle::drawControl(), QWindowsCEStyle::drawControl(), QWindowsMobileStyle::drawControl(), QWindowsCEStyle::drawPrimitive(), QCommonStyle::drawPrimitive(), QWindowsMobileStyle::drawPrimitive(), QMotifStyle::drawPrimitive(), and qDrawPlainRect().

{
    if (w == 0 || h == 0)
        return;
    if (!(w > 0 && h > 0 && lineWidth >= 0)) {
        qWarning("qDrawPlainRect: Invalid parameters");
    }
    QPen   oldPen   = p->pen();
    QBrush oldBrush = p->brush();
    p->setPen(c);
    p->setBrush(Qt::NoBrush);
    for (int i=0; i<lineWidth; i++)
        p->drawRect(x+i, y+i, w-i*2 - 1, h-i*2 - 1);
    if (fill) {                                // fill with fill color
        p->setPen(Qt::NoPen);
        p->setBrush(*fill);
        p->drawRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2);
    }
    p->setPen(oldPen);
    p->setBrush(oldBrush);
}

qDrawPlainRect() [2/2]

Q_GUI_EXPORT void qDrawPlainRect	(	QPainter *	p,
		const QRect &	r,
		const QColor &	,
		int	lineWidth = 1,
		const QBrush *	fill = 0
	)

Definition at line 726 of file qdrawutil.cpp.

{
    qDrawPlainRect(p, r.x(), r.y(), r.width(), r.height(), c,
                    lineWidth, fill);
}

qDrawShadeLine() [1/2]

Q_GUI_EXPORT void qDrawShadeLine	(	QPainter *	p,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		const QPalette &	pal,
		bool	sunken = true,
		int	lineWidth = 1,
		int	midLineWidth = 0
	)

Definition at line 93 of file qdrawutil.cpp.

Referenced by QMotifStyle::drawComplexControl(), QCommonStyle::drawControl(), QCommonStyle::drawPrimitive(), QMotifStyle::drawPrimitive(), and qDrawShadeLine().

{
    if (!(p && lineWidth >= 0 && midLineWidth >= 0))        {
        qWarning("qDrawShadeLine: Invalid parameters");
        return;
    }
    int tlw = lineWidth*2 + midLineWidth;        // total line width
    QPen oldPen = p->pen();                        // save pen
    if (sunken)
        p->setPen(pal.color(QPalette::Dark));
    else
        p->setPen(pal.light().color());
    QPolygon a;
    int i;
    if (y1 == y2) {                                // horizontal line
        int y = y1 - tlw/2;
        if (x1 > x2) {                        // swap x1 and x2
            int t = x1;
            x1 = x2;
            x2 = t;
        }
        x2--;
        for (i=0; i<lineWidth; i++) {                // draw top shadow
            a.setPoints(3, x1+i, y+tlw-1-i,
                         x1+i, y+i,
                         x2-i, y+i);
            p->drawPolyline(a);
        }
        if (midLineWidth > 0) {
            p->setPen(pal.mid().color());
            for (i=0; i<midLineWidth; i++)        // draw lines in the middle
                p->drawLine(x1+lineWidth, y+lineWidth+i,
                             x2-lineWidth, y+lineWidth+i);
        }
        if (sunken)
            p->setPen(pal.light().color());
        else
            p->setPen(pal.dark().color());
        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
            a.setPoints(3, x1+i, y+tlw-i-1,
                         x2-i, y+tlw-i-1,
                         x2-i, y+i+1);
            p->drawPolyline(a);
        }
    }
    else if (x1 == x2) {                        // vertical line
        int x = x1 - tlw/2;
        if (y1 > y2) {                        // swap y1 and y2
            int t = y1;
            y1 = y2;
            y2 = t;
        }
        y2--;
        for (i=0; i<lineWidth; i++) {                // draw left shadow
            a.setPoints(3, x+i, y2,
                         x+i, y1+i,
                         x+tlw-1, y1+i);
            p->drawPolyline(a);
        }
        if (midLineWidth > 0) {
            p->setPen(pal.mid().color());
            for (i=0; i<midLineWidth; i++)        // draw lines in the middle
                p->drawLine(x+lineWidth+i, y1+lineWidth, x+lineWidth+i, y2);
        }
        if (sunken)
            p->setPen(pal.light().color());
        else
            p->setPen(pal.dark().color());
        for (i=0; i<lineWidth; i++) {                // draw right shadow
            a.setPoints(3, x+lineWidth, y2-i,
                         x+tlw-i-1, y2-i,
                         x+tlw-i-1, y1+lineWidth);
            p->drawPolyline(a);
        }
    }
    p->setPen(oldPen);
}

qDrawShadeLine() [2/2]

Q_GUI_EXPORT void qDrawShadeLine	(	QPainter *	p,
		const QPoint &	p1,
		const QPoint &	p2,
		const QPalette &	pal,
		bool	sunken = true,
		int	lineWidth = 1,
		int	midLineWidth = 0
	)

Definition at line 568 of file qdrawutil.cpp.

{
    qDrawShadeLine(p, p1.x(), p1.y(), p2.x(), p2.y(), pal, sunken,
                    lineWidth, midLineWidth);
}

qDrawShadePanel() [1/2]

Q_GUI_EXPORT void qDrawShadePanel	(	QPainter *	p,
		int	x,
		int	y,
		int	w,
		int	h,
		const QPalette &	pal,
		bool	sunken = false,
		int	lineWidth = 1,
		const QBrush *	fill = 0
	)

Definition at line 303 of file qdrawutil.cpp.

Referenced by QMotifStyle::drawComplexControl(), QCommonStyle::drawControl(), QWindowsCEStyle::drawControl(), QCDEStyle::drawControl(), QWindowsStyle::drawControl(), QMotifStyle::drawControl(), QStyleSheetStyle::drawControl(), QCommonStyle::drawPrimitive(), QWindowsMobileStyle::drawPrimitive(), QCDEStyle::drawPrimitive(), QWindowsStyle::drawPrimitive(), QMotifStyle::drawPrimitive(), QDecorationDefault::paint(), QColorLuminancePicker::paintEvent(), and qDrawShadePanel().

{
    if (w == 0 || h == 0)
        return;
    if (!(w > 0 && h > 0 && lineWidth >= 0)) {
        qWarning("qDrawShadePanel: Invalid parameters");
    }
    QColor shade = pal.dark().color();
    QColor light = pal.light().color();
    if (fill) {
        if (fill->color() == shade)
            shade = pal.shadow().color();
        if (fill->color() == light)
            light = pal.midlight().color();
    }
    QPen oldPen = p->pen();                        // save pen
    QVector<QLineF> lines;
    lines.reserve(2*lineWidth);

    if (sunken)
        p->setPen(shade);
    else
        p->setPen(light);
    int x1, y1, x2, y2;
    int i;
    x1 = x;
    y1 = y2 = y;
    x2 = x+w-2;
    for (i=0; i<lineWidth; i++) {                // top shadow
        lines << QLineF(x1, y1++, x2--, y2++);
    }
    x2 = x1;
    y1 = y+h-2;
    for (i=0; i<lineWidth; i++) {                // left shado
        lines << QLineF(x1++, y1, x2++, y2--);
    }
    p->drawLines(lines);
    lines.clear();
    if (sunken)
        p->setPen(light);
    else
        p->setPen(shade);
    x1 = x;
    y1 = y2 = y+h-1;
    x2 = x+w-1;
    for (i=0; i<lineWidth; i++) {                // bottom shadow
        lines << QLineF(x1++, y1--, x2, y2--);
    }
    x1 = x2;
    y1 = y;
    y2 = y+h-lineWidth-1;
    for (i=0; i<lineWidth; i++) {                // right shadow
        lines << QLineF(x1--, y1++, x2--, y2);
    }
    p->drawLines(lines);
    if (fill)                                // fill with fill color
        p->fillRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2, *fill);
    p->setPen(oldPen);                        // restore pen
}

qDrawShadePanel() [2/2]

Q_GUI_EXPORT void qDrawShadePanel	(	QPainter *	p,
		const QRect &	r,
		const QPalette &	pal,
		bool	sunken = false,
		int	lineWidth = 1,
		const QBrush *	fill = 0
	)

Definition at line 640 of file qdrawutil.cpp.

{
    qDrawShadePanel(p, r.x(), r.y(), r.width(), r.height(), pal, sunken,
                     lineWidth, fill);
}

qDrawShadeRect() [1/2]

Q_GUI_EXPORT void qDrawShadeRect	(	QPainter *	p,
		int	x,
		int	y,
		int	w,
		int	h,
		const QPalette &	pal,
		bool	sunken = false,
		int	lineWidth = 1,
		int	midLineWidth = 0,
		const QBrush *	fill = 0
	)

Definition at line 204 of file qdrawutil.cpp.

Referenced by QCommonStyle::drawControl(), QWindowsStyle::drawControl(), QWindowsCEStyle::drawPrimitive(), QCommonStyle::drawPrimitive(), QWindowsStyle::drawPrimitive(), and qDrawShadeRect().

{
    if (w == 0 || h == 0)
        return;
    if (! (w > 0 && h > 0 && lineWidth >= 0 && midLineWidth >= 0)) {
        qWarning("qDrawShadeRect: Invalid parameters");
        return;
    }
    QPen oldPen = p->pen();
    if (sunken)
        p->setPen(pal.dark().color());
    else
        p->setPen(pal.light().color());
    int x1=x, y1=y, x2=x+w-1, y2=y+h-1;

    if (lineWidth == 1 && midLineWidth == 0) {// standard shade rectangle
        p->drawRect(x1, y1, w-2, h-2);
        if (sunken)
            p->setPen(pal.light().color());
        else
            p->setPen(pal.dark().color());
        QLineF lines[4] = { QLineF(x1+1, y1+1, x2-2, y1+1),
                            QLineF(x1+1, y1+2, x1+1, y2-2),
                            QLineF(x1, y2, x2, y2),
                            QLineF(x2,y1, x2,y2-1) };
        p->drawLines(lines, 4);              // draw bottom/right lines
    } else {                                        // more complicated
        int m = lineWidth+midLineWidth;
        int i, j=0, k=m;
        for (i=0; i<lineWidth; i++) {                // draw top shadow
            QLineF lines[4] = { QLineF(x1+i, y2-i, x1+i, y1+i),
                                QLineF(x1+i, y1+i, x2-i, y1+i),
                                QLineF(x1+k, y2-k, x2-k, y2-k),
                                QLineF(x2-k, y2-k, x2-k, y1+k) };
            p->drawLines(lines, 4);
            k++;
        }
        p->setPen(pal.mid().color());
        j = lineWidth*2;
        for (i=0; i<midLineWidth; i++) {        // draw lines in the middle
            p->drawRect(x1+lineWidth+i, y1+lineWidth+i, w-j-1, h-j-1);
            j += 2;
        }
        if (sunken)
            p->setPen(pal.light().color());
        else
            p->setPen(pal.dark().color());
        k = m;
        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
            QLineF lines[4] = { QLineF(x1+1+i, y2-i, x2-i, y2-i),
                                QLineF(x2-i, y2-i, x2-i, y1+i+1),
                                QLineF(x1+k, y2-k, x1+k, y1+k),
                                QLineF(x1+k, y1+k, x2-k, y1+k) };
            p->drawLines(lines, 4);
            k++;
        }
    }
    if (fill) {
        QBrush oldBrush = p->brush();
        int tlw = lineWidth + midLineWidth;
        p->setPen(Qt::NoPen);
        p->setBrush(*fill);
        p->drawRect(x+tlw, y+tlw, w-2*tlw, h-2*tlw);
        p->setBrush(oldBrush);
    }
    p->setPen(oldPen);                        // restore pen
}

qDrawShadeRect() [2/2]

Q_GUI_EXPORT void qDrawShadeRect	(	QPainter *	p,
		const QRect &	r,
		const QPalette &	pal,
		bool	sunken = false,
		int	lineWidth = 1,
		int	midLineWidth = 0,
		const QBrush *	fill = 0
	)

Definition at line 605 of file qdrawutil.cpp.

{
    qDrawShadeRect(p, r.x(), r.y(), r.width(), r.height(), pal, sunken,
                    lineWidth, midLineWidth, fill);
}

qDrawWinButton() [1/2]

Q_GUI_EXPORT void qDrawWinButton	(	QPainter *	p,
		int	x,
		int	y,
		int	w,
		int	h,
		const QPalette &	pal,
		bool	sunken = false,
		const QBrush *	fill = 0
	)

Definition at line 435 of file qdrawutil.cpp.

Referenced by QWindowsStyle::drawComplexControl(), QWindowsStyle::drawControl(), QWindowsMobileStyle::drawPrimitive(), QWindowsStyle::drawPrimitive(), and qDrawWinButton().

{
    if (sunken)
        qDrawWinShades(p, x, y, w, h,
                       pal.shadow().color(), pal.light().color(), pal.dark().color(),
                       pal.button().color(), fill);
    else
        qDrawWinShades(p, x, y, w, h,
                       pal.light().color(), pal.shadow().color(), pal.button().color(),
                       pal.dark().color(), fill);
}

qDrawWinButton() [2/2]

Q_GUI_EXPORT void qDrawWinButton	(	QPainter *	p,
		const QRect &	r,
		const QPalette &	pal,
		bool	sunken = false,
		const QBrush *	fill = 0
	)

Definition at line 669 of file qdrawutil.cpp.

{
    qDrawWinButton(p, r.x(), r.y(), r.width(), r.height(), pal, sunken, fill);
}

qDrawWinPanel() [1/2]

Q_GUI_EXPORT void qDrawWinPanel	(	QPainter *	p,
		int	x,
		int	y,
		int	w,
		int	h,
		const QPalette &	pal,
		bool	sunken = false,
		const QBrush *	fill = 0
	)

Definition at line 475 of file qdrawutil.cpp.

Referenced by QCommonStyle::drawComplexControl(), QWindowsStyle::drawComplexControl(), QCommonStyle::drawControl(), QCommonStyle::drawPrimitive(), QWindowsStyle::drawPrimitive(), QDecorationDefault::paint(), QDecorationWindows::paintButton(), QDecorationDefault::paintButton(), and qDrawWinPanel().

{
    if (sunken)
        qDrawWinShades(p, x, y, w, h,
                        pal.dark().color(), pal.light().color(), pal.shadow().color(),
                       pal.midlight().color(), fill);
    else
        qDrawWinShades(p, x, y, w, h,
                       pal.light().color(), pal.shadow().color(), pal.midlight().color(),
                       pal.dark().color(), fill);
}

qDrawWinPanel() [2/2]

Q_GUI_EXPORT void qDrawWinPanel	(	QPainter *	p,
		const QRect &	r,
		const QPalette &	pal,
		bool	sunken,
		const QBrush *	fill
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Draws the Windows-style panel at the rectangle specified by rect using the given painter with a line width of 2 pixels.

The button's interior is filled with the fill brush unless fill is 0.

The given palette specifies the shading colors. The panel appears sunken if sunken is true, otherwise raised.

Warning

This function does not look at QWidget::style() or QApplication::style(). Use the drawing functions in QStyle to make widgets that follow the current GUI style.

Alternatively you can use a QFrame widget and apply the QFrame::setFrameStyle() function to display a shaded panel:

QFrame frame:
frame.setFrameStyle(QFrame::WinPanel | QFrame::Raised);

See also

qDrawShadePanel(), qDrawWinButton(), QStyle

Definition at line 699 of file qdrawutil.cpp.

{
    qDrawWinPanel(p, r.x(), r.y(), r.width(), r.height(), pal, sunken, fill);
}