From bd0f3345a938b35ce6a12f6150373b0955b8dd12 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 10 Jul 2011 15:24:15 -0500 Subject: Add Qt3 development HEAD version --- doc/html/qpainter.html | 1626 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1626 insertions(+) create mode 100644 doc/html/qpainter.html (limited to 'doc/html/qpainter.html') diff --git a/doc/html/qpainter.html b/doc/html/qpainter.html new file mode 100644 index 0000000..13d117d --- /dev/null +++ b/doc/html/qpainter.html @@ -0,0 +1,1626 @@ + + + + + +QPainter Class + + + + + + + +
+ +Home + | +All Classes + | +Main Classes + | +Annotated + | +Grouped Classes + | +Functions +

QPainter Class Reference

+ +

The QPainter class does low-level painting e.g. on widgets. +More... +

#include <qpainter.h> +

Inherits Qt. +

Inherited by QDirectPainter. +

List of all member functions. +

Public Members

+ +

Static Public Members

+ +

Related Functions

+ +

Detailed Description

+ + +The QPainter class does low-level painting e.g. on widgets. +

+ + +

The painter provides highly optimized functions to do most of the +drawing GUI programs require. QPainter can draw everything from +simple lines to complex shapes like pies and chords. It can also +draw aligned text and pixmaps. Normally, it draws in a "natural" +coordinate system, but it can also do view and world +transformation. +

The typical use of a painter is: +

+

Mostly, all this is done inside a paint event. (In fact, 99% of +all QPainter use is in a reimplementation of +QWidget::paintEvent(), and the painter is heavily optimized for +such use.) Here's one very simple example: +

+    void SimpleExampleWidget::paintEvent()
+    {
+        QPainter paint( this );
+        paint.setPen( Qt::blue );
+        paint.drawText( rect(), AlignCenter, "The Text" );
+    }
+
+ +

Usage is simple, and there are many settings you can use: +

+

Note that some of these settings mirror settings in some paint +devices, e.g. QWidget::font(). QPainter::begin() (or the QPainter +constructor) copies these attributes from the paint device. +Calling, for example, QWidget::setFont() doesn't take effect until +the next time a painter begins painting on it. +

save() saves all of these settings on an internal stack, restore() +pops them back. +

The core functionality of QPainter is drawing, and there are +functions to draw most primitives: drawPoint(), drawPoints(), +drawLine(), drawRect(), drawWinFocusRect(), drawRoundRect(), +drawEllipse(), drawArc(), drawPie(), drawChord(), +drawLineSegments(), drawPolyline(), drawPolygon(), +drawConvexPolygon() and drawCubicBezier(). All of these functions +take integer coordinates; there are no floating-point versions +since we want drawing to be as fast as possible. +

There are functions to draw pixmaps/images, namely drawPixmap(), +drawImage() and drawTiledPixmap(). drawPixmap() and drawImage() +produce the same result, except that drawPixmap() is faster +on-screen and drawImage() faster and sometimes better on QPrinter +and QPicture. +

Text drawing is done using drawText(), and when you need +fine-grained positioning, boundingRect() tells you where a given +drawText() command would draw. +

There is a drawPicture() function that draws the contents of an +entire QPicture using this painter. drawPicture() is the only +function that disregards all the painter's settings: the QPicture +has its own settings. +

Normally, the QPainter operates on the device's own coordinate +system (usually pixels), but QPainter has good support for +coordinate transformation. See The Coordinate + System for a more general overview and a simple example. +

The most common functions used are scale(), rotate(), translate() +and shear(), all of which operate on the worldMatrix(). +setWorldMatrix() can replace or add to the currently set +worldMatrix(). +

setViewport() sets the rectangle on which QPainter operates. The +default is the entire device, which is usually fine, except on +printers. setWindow() sets the coordinate system, that is, the +rectangle that maps to viewport(). What's drawn inside the +window() ends up being inside the viewport(). The window's +default is the same as the viewport, and if you don't use the +transformations, they are optimized away, gaining another little +bit of speed. +

After all the coordinate transformation is done, QPainter can clip +the drawing to an arbitrary rectangle or region. hasClipping() is +TRUE if QPainter clips, and clipRegion() returns the clip region. +You can set it using either setClipRegion() or setClipRect(). +Note that the clipping can be slow. It's all system-dependent, +but as a rule of thumb, you can assume that drawing speed is +inversely proportional to the number of rectangles in the clip +region. +

After QPainter's clipping, the paint device may also clip. For +example, most widgets clip away the pixels used by child widgets, +and most printers clip away an area near the edges of the paper. +This additional clipping is not reflected by the return value of +clipRegion() or hasClipping(). +

QPainter also includes some less-used functions that are very +useful on those occasions when they're needed. +

isActive() indicates whether the painter is active. begin() (and +the most usual constructor) makes it active. end() (and the +destructor) deactivates it. If the painter is active, device() +returns the paint device on which the painter paints. +

Sometimes it is desirable to make someone else paint on an unusual +QPaintDevice. QPainter supports a static function to do this, +redirect(). We recommend not using it, but for some hacks it's +perfect. +

setTabStops() and setTabArray() can change where the tab stops +are, but these are very seldomly used. +

Warning: Note that QPainter does not attempt to work around +coordinate limitations in the underlying window system. Some +platforms may behave incorrectly with coordinates as small as ++/-4000. + +

See also QPaintDevice, QWidget, QPixmap, QPrinter, QPicture, Application Walkthrough, Coordinate System Overview, Graphics Classes, and Image Processing Classes. + +

Member Type Documentation

+

QPainter::CoordinateMode

+ +

See also clipRegion(). + +

QPainter::TextDirection

+ +

See also drawText(). + +

Member Function Documentation

+

QPainter::QPainter () +

+Constructs a painter. +

Notice that all painter settings (setPen, setBrush etc.) are reset +to default values when begin() is called. +

See also begin() and end(). + +

QPainter::QPainter ( const QPaintDevice * pd, bool unclipped = FALSE ) +

+Constructs a painter that begins painting the paint device pd +immediately. Depending on the underlying graphic system the +painter will paint over children of the paintdevice if unclipped is TRUE. +

This constructor is convenient for short-lived painters, e.g. in a +paint event and should be used +only once. The constructor calls begin() for you and the QPainter +destructor automatically calls end(). +

Here's an example using begin() and end(): +

+        void MyWidget::paintEvent( QPaintEvent * )
+        {
+            QPainter p;
+            p.begin( this );
+            p.drawLine( ... );  // drawing code
+            p.end();
+        }
+
+ +

The same example using this constructor: +

+        void MyWidget::paintEvent( QPaintEvent * )
+        {
+            QPainter p( this );
+            p.drawLine( ... );  // drawing code
+        }
+
+ +

Since the constructor cannot provide feedback when the initialization +of the painter failed you should rather use begin() and end() to paint +on external devices, e.g. printers. +

See also begin() and end(). + +

QPainter::QPainter ( const QPaintDevice * pd, const QWidget * copyAttributes, bool unclipped = FALSE ) +

+Constructs a painter that begins painting the paint device pd +immediately, with the default arguments taken from copyAttributes. The painter will paint over children of the paint +device if unclipped is TRUE (although this is not supported on +all platforms). +

See also begin(). + +

QPainter::~QPainter () +

+Destroys the painter. + +

const QColor & QPainter::backgroundColor () const +

+ +

Returns the current background color. +

See also setBackgroundColor() and QColor. + +

BGMode QPainter::backgroundMode () const +

+ +

Returns the current background mode. +

See also setBackgroundMode() and BGMode. + +

bool QPainter::begin ( const QPaintDevice * pd, bool unclipped = FALSE ) +

+Begins painting the paint device pd and returns TRUE if +successful; otherwise returns FALSE. If unclipped is TRUE, the +painting will not be clipped at the paint device's boundaries, +(although this is not supported by all platforms). +

The errors that can occur are serious problems, such as these: +

+        p->begin( 0 ); // impossible - paint device cannot be 0
+
+        QPixmap pm( 0, 0 );
+        p->begin( pm ); // impossible - pm.isNull();
+
+        p->begin( myWidget );
+        p2->begin( myWidget ); // impossible - only one painter at a time
+
+ +

Note that most of the time, you can use one of the constructors +instead of begin(), and that end() is automatically done at +destruction. +

Warning: A paint device can only be painted by one painter at a +time. +

See also end() and flush(). + +

Examples: aclock/aclock.cpp, desktop/desktop.cpp, drawdemo/drawdemo.cpp, hello/hello.cpp, picture/picture.cpp, t10/cannon.cpp, and xform/xform.cpp. +

bool QPainter::begin ( const QPaintDevice * pd, const QWidget * copyAttributes, bool unclipped = FALSE ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

This version opens the painter on a paint device pd and sets +the initial pen, background color and font from copyAttributes, +painting over the paint device's children when unclipped is +TRUE. This is equivalent to: +

+        QPainter p;
+        p.begin( pd );
+        p.setPen( copyAttributes->foregroundColor() );
+        p.setBackgroundColor( copyAttributes->backgroundColor() );
+        p.setFont( copyAttributes->font() );
+
+ +

This begin function is convenient for double buffering. When you +draw in a pixmap instead of directly in a widget (to later bitBlt +the pixmap into the widget) you will need to set the widget's +font etc. This function does exactly that. +

Example: +

+        void MyWidget::paintEvent( QPaintEvent * )
+        {
+            QPixmap pm(size());
+            QPainter p;
+            p.begin(&pm, this);
+            // ... potentially flickering paint operation ...
+            p.end();
+            bitBlt(this, 0, 0, &pm);
+        }
+
+ +

See also end(). + +

QRect QPainter::boundingRect ( int x, int y, int w, int h, int flags, const QString &, int len = -1, QTextParag ** intern = 0 ) +

+ +

Returns the bounding rectangle of the aligned text that would be +printed with the corresponding drawText() function using the first +len characters of the string if len is > -1, or the whole of +the string if len is -1. The drawing, and hence the bounding +rectangle, is constrained to the rectangle that begins at point (x, y) with width w and hight h, or to the +rectangle required to draw the text, whichever is the larger. +

The flags argument is +the bitwise OR of the following flags: +

+
Flag Meaning +
AlignAuto aligns according to the language, usually left. +
AlignLeft aligns to the left border. +
AlignRight aligns to the right border. +
AlignHCenter aligns horizontally centered. +
AlignTop aligns to the top border. +
AlignBottom aligns to the bottom border. +
AlignVCenter aligns vertically centered. +
AlignCenter (== AlignHCenter | AlignVCenter). +
SingleLine ignores newline characters in the text. +
ExpandTabs expands tabs. +
ShowPrefix interprets "&x" as "x". +
WordBreak breaks the text to fit the rectangle. +
+

Horizontal alignment defaults to AlignLeft and vertical +alignment defaults to AlignTop. +

If several of the horizontal or several of the vertical alignment flags +are set, the resulting alignment is undefined. +

The intern parameter should not be used. +

See also Qt::TextFlags. + +

QRect QPainter::boundingRect ( const QRect & r, int flags, const QString & str, int len = -1, QTextParag ** internal = 0 ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the bounding rectangle of the aligned text that would be +printed with the corresponding drawText() function using the first +len characters from str if len is > -1, or the whole of +str if len is -1. The drawing, and hence the bounding +rectangle, is constrained to the rectangle r, or to the +rectangle required to draw the text, whichever is the larger. +

The internal parameter should not be used. +

See also drawText(), fontMetrics(), QFontMetrics::boundingRect(), and Qt::TextFlags. + +

const QBrush & QPainter::brush () const +

+ +

Returns the painter's current brush. +

See also QPainter::setBrush(). + +

Examples: themes/metal.cpp and themes/wood.cpp. +

const QPoint & QPainter::brushOrigin () const +

+ +

Returns the brush origin currently set. +

See also setBrushOrigin(). + +

QRegion QPainter::clipRegion ( CoordinateMode m = CoordDevice ) const +

+Returns the currently set clip region. Note that the clip region +is given in physical device coordinates and not subject to any +coordinate transformation if m is +equal to CoordDevice (the default). If m equals CoordPainter the returned region is in model coordinates. +

See also setClipRegion(), setClipRect(), setClipping(), and QPainter::CoordinateMode. + +

Example: themes/wood.cpp. +

QPaintDevice * QPainter::device () const +

+ +

Returns the paint device on which this painter is currently +painting, or 0 if the painter is not active. +

See also QPaintDevice::paintingActive(). + +

Examples: action/application.cpp, application/application.cpp, helpviewer/helpwindow.cpp, listboxcombo/listboxcombo.cpp, and mdi/application.cpp. +

void QPainter::drawArc ( int x, int y, int w, int h, int a, int alen ) +

+Draws an arc defined by the rectangle (x, y, w, h), the start +angle a and the arc length alen. +

The angles a and alen are 1/16th of a degree, i.e. a full +circle equals 5760 (16*360). Positive values of a and alen +mean counter-clockwise while negative values mean the clockwise +direction. Zero degrees is at the 3 o'clock position. +

Example: +

+        QPainter p( myWidget );
+        p.drawArc( 10,10, 70,100, 100*16, 160*16 ); // draws a "(" arc
+
+ +

See also drawPie() and drawChord(). + +

void QPainter::drawArc ( const QRect & r, int a, int alen ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the arc that fits inside the rectangle r with start angle +a and arc length alen. + +

void QPainter::drawChord ( int x, int y, int w, int h, int a, int alen ) +

+Draws a chord defined by the rectangle (x, y, w, h), the start +angle a and the arc length alen. +

The chord is filled with the current brush(). +

The angles a and alen are 1/16th of a degree, i.e. a full +circle equals 5760 (16*360). Positive values of a and alen +mean counter-clockwise while negative values mean the clockwise +direction. Zero degrees is at the 3 o'clock position. +

See also drawArc() and drawPie(). + +

void QPainter::drawChord ( const QRect & r, int a, int alen ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a chord that fits inside the rectangle r with start angle +a and arc length alen. + +

void QPainter::drawConvexPolygon ( const QPointArray & pa, int index = 0, int npoints = -1 ) +

+Draws the convex polygon defined by the npoints points in pa +starting at pa[index] (index defaults to 0). +

If the supplied polygon is not convex, the results are undefined. +

On some platforms (e.g. X Window), this is faster than +drawPolygon(). +

Warning: On X11, coordinates that do not fit into 16-bit signed +values are truncated. This limitation is expected to go away in +Qt 4. + +

Example: aclock/aclock.cpp. +

void QPainter::drawCubicBezier ( const QPointArray & a, int index = 0 ) +

+Draws a cubic Bezier curve defined by the control points in a, +starting at a[index] (index defaults to 0). +

Control points after a[index + 3] are ignored. Nothing happens +if there aren't enough control points. +

Warning: On X11, coordinates that do not fit into 16-bit signed +values are truncated. This limitation is expected to go away in +Qt 4. + +

void QPainter::drawEllipse ( int x, int y, int w, int h ) +

+Draws an ellipse with center at (x + w/2, y + h/2) and size (w, h). + +

Examples: drawdemo/drawdemo.cpp, multiple/ax2.h, picture/picture.cpp, and tictac/tictac.cpp. +

void QPainter::drawEllipse ( const QRect & r ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the ellipse that fits inside rectangle r. + +

void QPainter::drawImage ( int x, int y, const QImage & image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, int conversionFlags = 0 ) +

+Draws at (x, y) the sw by sh area of pixels from (sx, sy) in image, using conversionFlags if the image +needs to be converted to a pixmap. The default value for conversionFlags is 0; see convertFromImage() for information about +what other values do. +

This function may convert image to a pixmap and then draw it, +if device() is a QPixmap or a QWidget, or else draw it directly, +if device() is a QPrinter or QPicture. +

Currently alpha masks of the image are ignored when painting on a QPrinter. +

See also drawPixmap() and QPixmap::convertFromImage(). + +

Example: canvas/canvas.cpp. +

void QPainter::drawImage ( const QPoint &, const QImage &, const QRect & sr, int conversionFlags = 0 ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the rectangle sr from the image at the given point. + +

void QPainter::drawImage ( const QPoint & p, const QImage & i, int conversion_flags = 0 ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the image i at point p. +

If the image needs to be modified to fit in a lower-resolution +result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. +

See also Qt::ImageConversionFlags. + +

void QPainter::drawImage ( const QRect & r, const QImage & i ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the image i into the rectangle r. The image will be +scaled to fit the rectangle if image and rectangle dimensions +differ. + +

void QPainter::drawLine ( int x1, int y1, int x2, int y2 ) +

+Draws a line from (x1, y1) to (x2, y2) and sets the +current pen position to (x2, y2). +

See also pen(). + +

Examples: aclock/aclock.cpp, drawlines/connect.cpp, progress/progress.cpp, splitter/splitter.cpp, themes/metal.cpp, and themes/wood.cpp. +

void QPainter::drawLine ( const QPoint & p1, const QPoint & p2 ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a line from point p1 to point p2. + +

void QPainter::drawLineSegments ( const QPointArray & a, int index = 0, int nlines = -1 ) +

+Draws nlines separate lines from points defined in a, +starting at a[index] (index defaults to 0). If nlines is +-1 (the default) all points until the end of the array are used +(i.e. (a.size()-index)/2 lines are drawn). +

Draws the 1st line from a[index] to a[index+1]. Draws the +2nd line from a[index+2] to a[index+3] etc. +

Warning: On X11, coordinates that do not fit into 16-bit signed +values are truncated. This limitation is expected to go away in +Qt 4. +

See also drawPolyline(), drawPolygon(), and QPen. + +

void QPainter::drawPicture ( int x, int y, const QPicture & pic ) +

+Replays the picture pic translated by (x, y). +

This function does exactly the same as QPicture::play() when +called with (x, y) = (0, 0). + +

Examples: picture/picture.cpp and xform/xform.cpp. +

void QPainter::drawPicture ( const QPicture & pic ) +

+This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

Use one of the other QPainter::drawPicture() functions with a (0, 0) +offset instead. + +

void QPainter::drawPicture ( const QPoint & p, const QPicture & pic ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws picture pic at point p. + +

void QPainter::drawPie ( int x, int y, int w, int h, int a, int alen ) +

+Draws a pie defined by the rectangle (x, y, w, h), the start +angle a and the arc length alen. +

The pie is filled with the current brush(). +

The angles a and alen are 1/16th of a degree, i.e. a full +circle equals 5760 (16*360). Positive values of a and alen +mean counter-clockwise while negative values mean the clockwise +direction. Zero degrees is at the 3 o'clock position. +

See also drawArc() and drawChord(). + +

Examples: drawdemo/drawdemo.cpp, grapher/grapher.cpp, t10/cannon.cpp, and t9/cannon.cpp. +

void QPainter::drawPie ( const QRect & r, int a, int alen ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a pie segment that fits inside the rectangle r with start +angle a and arc length alen. + +

void QPainter::drawPixmap ( int x, int y, const QPixmap & pixmap, int sx = 0, int sy = 0, int sw = -1, int sh = -1 ) +

+Draws a pixmap at (x, y) by copying a part of pixmap into +the paint device. +

(x, y) specifies the top-left point in the paint device that is +to be drawn onto. (sx, sy) specifies the top-left point in pixmap that is to be drawn. The default is (0, 0). +

(sw, sh) specifies the size of the pixmap that is to be drawn. +The default, (-1, -1), means all the way to the bottom right of +the pixmap. +

Currently the mask of the pixmap or it's alpha channel are ignored +when painting on a QPrinter. +

See also bitBlt() and QPixmap::setMask(). + +

Examples: grapher/grapher.cpp, picture/picture.cpp, qdir/qdir.cpp, qmag/qmag.cpp, showimg/showimg.cpp, t10/cannon.cpp, and xform/xform.cpp. +

void QPainter::drawPixmap ( const QPoint & p, const QPixmap & pm, const QRect & sr ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the rectangle sr of pixmap pm with its origin at point +p. + +

void QPainter::drawPixmap ( const QPoint & p, const QPixmap & pm ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the pixmap pm with its origin at point p. + +

void QPainter::drawPixmap ( const QRect & r, const QPixmap & pm ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the pixmap pm into the rectangle r. The pixmap is +scaled to fit the rectangle, if image and rectangle size disagree. + +

void QPainter::drawPoint ( int x, int y ) +

+Draws/plots a single point at (x, y) using the current pen. +

See also QPen. + +

Examples: desktop/desktop.cpp and drawlines/connect.cpp. +

void QPainter::drawPoint ( const QPoint & p ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the point p. + +

void QPainter::drawPoints ( const QPointArray & a, int index = 0, int npoints = -1 ) +

+Draws/plots an array of points, a, using the current pen. +

If index is non-zero (the default is zero) only points from index are drawn. If npoints is negative (the default) the rest +of the points from index are drawn. If npoints is zero or +greater, npoints points are drawn. +

Warning: On X11, coordinates that do not fit into 16-bit signed +values are truncated. This limitation is expected to go away in +Qt 4. + +

void QPainter::drawPolygon ( const QPointArray & a, bool winding = FALSE, int index = 0, int npoints = -1 ) +

+Draws the polygon defined by the npoints points in a +starting at a[index]. (index defaults to 0.) +

If npoints is -1 (the default) all points until the end of the +array are used (i.e. a.size()-index line segments define the +polygon). +

The first point is always connected to the last point. +

The polygon is filled with the current brush(). If winding is +TRUE, the polygon is filled using the winding fill algorithm. If +winding is FALSE, the polygon is filled using the even-odd +(alternative) fill algorithm. +

Warning: On X11, coordinates that do not fit into 16-bit signed +values are truncated. This limitation is expected to go away in +Qt 4. +

See also drawLineSegments(), drawPolyline(), and QPen. + +

Examples: desktop/desktop.cpp and picture/picture.cpp. +

void QPainter::drawPolyline ( const QPointArray & a, int index = 0, int npoints = -1 ) +

+Draws the polyline defined by the npoints points in a +starting at a[index]. (index defaults to 0.) +

If npoints is -1 (the default) all points until the end of the +array are used (i.e. a.size()-index-1 line segments are drawn). +

Warning: On X11, coordinates that do not fit into 16-bit signed +values are truncated. This limitation is expected to go away in +Qt 4. +

See also drawLineSegments(), drawPolygon(), and QPen. + +

Examples: scribble/scribble.cpp and themes/metal.cpp. +

void QPainter::drawRect ( int x, int y, int w, int h ) +

+Draws a rectangle with upper left corner at (x, y) and with +width w and height h. +

See also QPen and drawRoundRect(). + +

Examples: drawdemo/drawdemo.cpp, picture/picture.cpp, t10/cannon.cpp, t11/cannon.cpp, t9/cannon.cpp, tooltip/tooltip.cpp, and trivial/trivial.cpp. +

void QPainter::drawRect ( const QRect & r ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the rectangle r. + +

void QPainter::drawRoundRect ( int x, int y, int w, int h, int xRnd = 25, int yRnd = 25 ) +

+Draws a rectangle with rounded corners at (x, y), with width w and height h. +

The xRnd and yRnd arguments specify how rounded the corners +should be. 0 is angled corners, 99 is maximum roundedness. +

The width and height include all of the drawn lines. +

See also drawRect() and QPen. + +

Examples: drawdemo/drawdemo.cpp and themes/wood.cpp. +

void QPainter::drawRoundRect ( const QRect & r, int xRnd = 25, int yRnd = 25 ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a rounded rectangle r, rounding to the x position xRnd +and the y position yRnd on each corner. + +

void QPainter::drawText ( const QPoint & p, const QString &, int pos, int len, TextDirection dir = Auto ) +

+ +

Draws the text from position pos, at point p. If len is +-1 the entire string is drawn, otherwise just the first len +characters. The text's direction is specified by dir. +

Note that the meaning of y is not the same for the two +drawText() varieties. For overloads that take a simple x, y +pair (or a point), the y value is the text's baseline; for +overloads that take a rectangle, rect.y() is the top of the +rectangle and the text is aligned within that rectangle in +accordance with the alignment flags. +

See also QPainter::TextDirection. + +

Examples: desktop/desktop.cpp, drawdemo/drawdemo.cpp, grapher/grapher.cpp, picture/picture.cpp, progress/progress.cpp, t8/cannon.cpp, and trivial/trivial.cpp. +

void QPainter::drawText ( int x, int y, const QString &, int len = -1, TextDirection dir = Auto ) +

+ +

This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the given text at position x, y. If len is -1 (the +default) all the text is drawn, otherwise the first len +characters are drawn. The text's direction is given by dir. +

See also QPainter::TextDirection. + +

void QPainter::drawText ( const QPoint &, const QString &, int len = -1, TextDirection dir = Auto ) +

+ +

This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the text at the given point. +

See also QPainter::TextDirection. + +

void QPainter::drawText ( int x, int y, const QString &, int pos, int len, TextDirection dir = Auto ) +

+ +

This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the text from position pos, at point (x, y). If len is +-1 the entire string is drawn, otherwise just the first len +characters. The text's direction is specified by dir. + +

void QPainter::drawText ( int x, int y, int w, int h, int flags, const QString &, int len = -1, QRect * br = 0, QTextParag ** internal = 0 ) +

+ +

This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws the given text within the rectangle starting at x, y, +with width w and height h. If len is -1 (the default) all +the text is drawn, otherwise the first len characters are +drawn. The text's flags that are given in the flags parameter +are Qt::AlignmentFlags and Qt::TextFlags OR'd together. br (if not null) is set to the actual bounding rectangle of the +output. The internal parameter is for internal use only. + +

void QPainter::drawText ( const QRect & r, int tf, const QString & str, int len = -1, QRect * brect = 0, QTextParag ** internal = 0 ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws at most len characters from str in the rectangle r. +

This function draws formatted text. The tf text format is +really of type Qt::AlignmentFlags and Qt::TextFlags OR'd +together. +

Horizontal alignment defaults to AlignAuto and vertical alignment +defaults to AlignTop. +

brect (if not null) is set to the actual bounding rectangle of +the output. internal is, yes, internal. +

See also boundingRect(). + +

void QPainter::drawTiledPixmap ( int x, int y, int w, int h, const QPixmap & pixmap, int sx = 0, int sy = 0 ) +

+Draws a tiled pixmap in the specified rectangle. +

(x, y) specifies the top-left point in the paint device that is +to be drawn onto; with the width and height given by w and h. (sx, sy) specifies the top-left point in pixmap that is +to be drawn. The default is (0, 0). +

Calling drawTiledPixmap() is similar to calling drawPixmap() +several times to fill (tile) an area with a pixmap, but is +potentially much more efficient depending on the underlying window +system. +

See also drawPixmap(). + +

void QPainter::drawTiledPixmap ( const QRect & r, const QPixmap & pm, const QPoint & sp ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a tiled pixmap, pm, inside rectangle r with its origin +at point sp. + +

void QPainter::drawTiledPixmap ( const QRect & r, const QPixmap & pm ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a tiled pixmap, pm, inside rectangle r. + +

void QPainter::drawWinFocusRect ( int x, int y, int w, int h, const QColor & bgColor ) +

+Draws a Windows focus rectangle with upper left corner at (x, +y) and with width w and height h using a pen color that +contrasts with bgColor. +

This function draws a stippled rectangle (XOR is not used) that is +used to indicate keyboard focus (when the QApplication::style() is +WindowStyle). +

The pen color used to draw the rectangle is either white or black +depending on the color of bgColor (see QColor::gray()). +

Warning: This function draws nothing if the coordinate system has +been rotated or sheared. +

See also drawRect() and QApplication::style(). + +

void QPainter::drawWinFocusRect ( int x, int y, int w, int h ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a Windows focus rectangle with upper left corner at (x, +y) and with width w and height h. +

This function draws a stippled XOR rectangle that is used to +indicate keyboard focus (when QApplication::style() is WindowStyle). +

Warning: This function draws nothing if the coordinate system has +been rotated or sheared. +

See also drawRect() and QApplication::style(). + +

void QPainter::drawWinFocusRect ( const QRect & r ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws rectangle r as a window focus rectangle. + +

void QPainter::drawWinFocusRect ( const QRect & r, const QColor & bgColor ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws rectangle r as a window focus rectangle using background +color bgColor. + +

bool QPainter::end () +

+Ends painting. Any resources used while painting are released. +

Note that while you mostly don't need to call end(), the +destructor will do it, there is at least one common case when it +is needed, namely double buffering. +

+        QPainter p( myPixmap, this )
+        // ...
+        p.end(); // stops drawing on myPixmap
+        p.begin( this );
+        p.drawPixmap( 0, 0, myPixmap );
+
+ +

Since you can't draw a QPixmap while it is being painted, it is +necessary to close the active painter. +

See also begin() and isActive(). + +

Examples: aclock/aclock.cpp, desktop/desktop.cpp, hello/hello.cpp, picture/picture.cpp, scribble/scribble.cpp, t10/cannon.cpp, and xform/xform.cpp. +

void QPainter::eraseRect ( int x, int y, int w, int h ) +

+ +

Erases the area inside x, y, w, h. Equivalent to +fillRect( x, y, w, h, backgroundColor() ). + +

Examples: listboxcombo/listboxcombo.cpp and showimg/showimg.cpp. +

void QPainter::eraseRect ( const QRect & r ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Erases the area inside the rectangle r. + +

void QPainter::fillRect ( int x, int y, int w, int h, const QBrush & brush ) +

+Fills the rectangle (x, y, w, h) with the brush. +

You can specify a QColor as brush, since there is a QBrush +constructor that takes a QColor argument and creates a solid +pattern brush. +

See also drawRect(). + +

Examples: listboxcombo/listboxcombo.cpp, multiple/ax1.h, progress/progress.cpp, qdir/qdir.cpp, qfd/fontdisplayer.cpp, themes/metal.cpp, and themes/wood.cpp. +

void QPainter::fillRect ( const QRect & r, const QBrush & brush ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Fills the rectangle r using brush brush. + +

void QPainter::flush ( const QRegion & region, CoordinateMode cm = CoordDevice ) +

+Flushes any buffered drawing operations inside the region region using clipping mode cm. +

The flush may update the whole device if the platform does not +support flushing to a specified region. +

See also CoordinateMode. + +

void QPainter::flush () +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Flushes any buffered drawing operations. + +

const QFont & QPainter::font () const +

+ +

Returns the currently set painter font. +

See also setFont() and QFont. + +

Example: fileiconview/qfileiconview.cpp. +

QFontInfo QPainter::fontInfo () const +

+Returns the font info for the painter, if the painter is active. +It is not possible to obtain font information for an inactive +painter, so the return value is undefined if the painter is not +active. +

See also fontMetrics() and isActive(). + +

QFontMetrics QPainter::fontMetrics () const +

+Returns the font metrics for the painter, if the painter is +active. It is not possible to obtain metrics for an inactive +painter, so the return value is undefined if the painter is not +active. +

See also fontInfo() and isActive(). + +

Examples: action/application.cpp, application/application.cpp, desktop/desktop.cpp, drawdemo/drawdemo.cpp, helpviewer/helpwindow.cpp, mdi/application.cpp, and qwerty/qwerty.cpp. +

HDC QPainter::handle () const +

+ +

Returns the platform-dependent handle used for drawing. Using this +function is not portable. + +

bool QPainter::hasClipping () const +

+ +

Returns TRUE if clipping has been set; otherwise returns FALSE. +

See also setClipping(). + +

Example: themes/wood.cpp. +

bool QPainter::hasViewXForm () const +

+ +

Returns TRUE if view transformation is enabled; otherwise returns +FALSE. +

See also setViewXForm() and xForm(). + +

bool QPainter::hasWorldXForm () const +

+ +

Returns TRUE if world transformation is enabled; otherwise returns +FALSE. +

See also setWorldXForm(). + +

bool QPainter::isActive () const +

+ +

Returns TRUE if the painter is active painting, i.e. begin() has +been called and end() has not yet been called; otherwise returns +FALSE. +

See also QPaintDevice::paintingActive(). + +

Examples: desktop/desktop.cpp and helpviewer/helpwindow.cpp. +

void QPainter::lineTo ( int x, int y ) +

This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

Use drawLine() instead. +

Draws a line from the current pen position to (x, y) and sets +(x, y) to be the new current pen position. +

See also QPen, moveTo(), drawLine(), and pos(). + +

void QPainter::lineTo ( const QPoint & p ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Draws a line to the point p. + +

void QPainter::moveTo ( int x, int y ) +

This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

Sets the current pen position to (x, y) +

See also lineTo() and pos(). + +

void QPainter::moveTo ( const QPoint & p ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Moves to the point p. + +

const QPen & QPainter::pen () const +

+ +

Returns the painter's current pen. +

See also setPen(). + +

Examples: multiple/ax2.h, progress/progress.cpp, and themes/wood.cpp. +

QPoint QPainter::pos () const +

+This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

Returns the current position of the pen. +

See also moveTo(). + +

RasterOp QPainter::rasterOp () const +

+ +

Returns the current raster operation. +

See also setRasterOp() and RasterOp. + +

void QPainter::redirect ( QPaintDevice * pdev, QPaintDevice * replacement ) [static] +

+Redirects all paint commands for a paint device, pdev, to +another paint device, replacement, unless replacement is 0. +If replacement is 0, the redirection for pdev is removed. +

In general, you'll probably find calling QPixmap::grabWidget() or +QPixmap::grabWindow() is an easier solution. + +

void QPainter::resetXForm () +

+Resets any transformations that were made using translate(), scale(), +shear(), rotate(), setWorldMatrix(), setViewport() and +setWindow(). +

See also worldMatrix(), viewport(), and window(). + +

void QPainter::restore () +

+Restores the current painter state (pops a saved state off the +stack). +

See also save(). + +

Example: aclock/aclock.cpp. +

void QPainter::restoreWorldMatrix () +

This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

We recommend using restore() instead. + +

void QPainter::rotate ( double a ) +

+Rotates the coordinate system a degrees counterclockwise. +

See also translate(), scale(), shear(), resetXForm(), setWorldMatrix(), and xForm(). + +

Examples: aclock/aclock.cpp, t10/cannon.cpp, and t9/cannon.cpp. +

void QPainter::save () +

+Saves the current painter state (pushes the state onto a stack). A +save() must be followed by a corresponding restore(). end() +unwinds the stack. +

See also restore(). + +

Example: aclock/aclock.cpp. +

void QPainter::saveWorldMatrix () +

This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

We recommend using save() instead. + +

void QPainter::scale ( double sx, double sy ) +

+Scales the coordinate system by (sx, sy). +

See also translate(), shear(), rotate(), resetXForm(), setWorldMatrix(), and xForm(). + +

Example: xform/xform.cpp. +

void QPainter::setBackgroundColor ( const QColor & c ) +

+Sets the background color of the painter to c. +

The background color is the color that is filled in when drawing +opaque text, stippled lines and bitmaps. The background color has +no effect in transparent background mode (which is the default). +

See also backgroundColor(), setBackgroundMode(), and BackgroundMode. + +

void QPainter::setBackgroundMode ( BGMode m ) +

+Sets the background mode of the painter to m, which must be +either TransparentMode (the default) or OpaqueMode. +

Transparent mode draws stippled lines and text without setting the +background pixels. Opaque mode fills these space with the current +background color. +

Note that in order to draw a bitmap or pixmap transparently, you +must use QPixmap::setMask(). +

See also backgroundMode() and setBackgroundColor(). + +

Example: picture/picture.cpp. +

void QPainter::setBrush ( BrushStyle style ) +

+Sets the painter's brush to black color and the specified style. +

See also brush() and QBrush. + +

Examples: aclock/aclock.cpp, drawdemo/drawdemo.cpp, picture/picture.cpp, t10/cannon.cpp, t9/cannon.cpp, themes/wood.cpp, and tooltip/tooltip.cpp. +

void QPainter::setBrush ( const QBrush & brush ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the painter's brush to brush. +

The brush defines how shapes are filled. +

See also brush(). + +

void QPainter::setBrush ( const QColor & color ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the painter's brush to have style SolidPattern and the +specified color. +

See also brush() and QBrush. + +

void QPainter::setBrushOrigin ( int x, int y ) +

+Sets the brush origin to (x, y). +

The brush origin specifies the (0, 0) coordinate of the painter's +brush. This setting only applies to pattern brushes and pixmap +brushes. +

See also brushOrigin(). + +

void QPainter::setBrushOrigin ( const QPoint & p ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the brush origin to point p. + +

void QPainter::setClipRect ( int x, int y, int w, int h, CoordinateMode m = CoordDevice ) +

+ +

Sets the clip region to the rectangle x, y, w, h and +enables clipping. The clip mode is set to m. +

If m is CoordDevice (the default), the coordinates given for +the clip region are taken to be physical device coordinates and +are not subject to any coordinate + transformations. If m is CoordPainter, the +coordinates given for the clip region are taken to be model +coordinates. +

See also setClipRegion(), clipRegion(), setClipping(), and QPainter::CoordinateMode. + +

Examples: grapher/grapher.cpp, progress/progress.cpp, showimg/showimg.cpp, splitter/splitter.cpp, and trivial/trivial.cpp. +

void QPainter::setClipRect ( const QRect & r, CoordinateMode m = CoordDevice ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the clip region to the rectangle r and enables clipping. +The clip mode is set to m. +

See also CoordinateMode. + +

void QPainter::setClipRegion ( const QRegion & rgn, CoordinateMode m = CoordDevice ) +

+Sets the clip region to rgn and enables clipping. The clip mode +is set to m. +

Note that the clip region is given in physical device coordinates +and not subject to any coordinate + transformation. +

See also setClipRect(), clipRegion(), setClipping(), and CoordinateMode. + +

Examples: qfd/fontdisplayer.cpp and themes/wood.cpp. +

void QPainter::setClipping ( bool enable ) +

+Enables clipping if enable is TRUE, or disables clipping if enable is FALSE. +

See also hasClipping(), setClipRect(), and setClipRegion(). + +

Example: themes/wood.cpp. +

void QPainter::setFont ( const QFont & font ) +

+Sets the painter's font to font. +

This font is used by subsequent drawText() functions. The text +color is the same as the pen color. +

See also font() and drawText(). + +

Examples: drawdemo/drawdemo.cpp, grapher/grapher.cpp, hello/hello.cpp, picture/picture.cpp, qwerty/qwerty.cpp, t13/cannon.cpp, and xform/xform.cpp. +

void QPainter::setPen ( const QPen & pen ) +

+Sets a new painter pen. +

The pen defines how to draw lines and outlines, and it also +defines the text color. +

See also pen(). + +

Examples: desktop/desktop.cpp, drawdemo/drawdemo.cpp, multiple/ax2.h, progress/progress.cpp, t9/cannon.cpp, themes/metal.cpp, and themes/wood.cpp. +

void QPainter::setPen ( PenStyle style ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the painter's pen to have style style, width 0 and black +color. +

See also pen() and QPen. + +

void QPainter::setPen ( const QColor & color ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the painter's pen to have style SolidLine, width 0 and the +specified color. +

See also pen() and QPen. + +

void QPainter::setRasterOp ( RasterOp r ) +

+Sets the raster operation to r. +The default is CopyROP. +

See also rasterOp() and Qt::RasterOp. + +

void QPainter::setTabArray ( int * ta ) +

+Sets the tab stop array to ta. This puts tab stops at ta[0], +ta[1] and so on. The array is null-terminated. +

If both a tab array and a tab top size is set, the tab array wins. +

See also tabArray(), setTabStops(), drawText(), and fontMetrics(). + +

void QPainter::setTabStops ( int ts ) +

+Set the tab stop width to ts, i.e. locates tab stops at ts, +2*ts, 3*ts and so on. +

Tab stops are used when drawing formatted text with ExpandTabs +set. This fixed tab stop value is used only if no tab array is set +(which is the default case). +

A value of 0 (the default) implies a tabstop setting of 8 times the width of the +character 'x' in the font currently set on the painter. +

See also tabStops(), setTabArray(), drawText(), and fontMetrics(). + +

void QPainter::setViewXForm ( bool enable ) +

+Enables view transformations if enable is TRUE, or disables +view transformations if enable is FALSE. +

See also hasViewXForm(), setWindow(), setViewport(), setWorldMatrix(), setWorldXForm(), and xForm(). + +

void QPainter::setViewport ( int x, int y, int w, int h ) +

+Sets the viewport rectangle view transformation for the painter +and enables view transformation. +

The viewport rectangle is part of the view transformation. The +viewport specifies the device coordinate system and is specified +by the x, y, w width and h height parameters. Its +sister, the window(), specifies the logical coordinate system. +

The default viewport rectangle is the same as the device's +rectangle. See the Coordinate System Overview for an overview of coordinate transformation. +

See also viewport(), setWindow(), setViewXForm(), setWorldMatrix(), setWorldXForm(), and xForm(). + +

Example: aclock/aclock.cpp. +

void QPainter::setViewport ( const QRect & r ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the painter's viewport to rectangle r. + +

void QPainter::setWindow ( int x, int y, int w, int h ) +

+Sets the window rectangle view transformation for the painter and +enables view transformation. +

The window rectangle is part of the view transformation. The +window specifies the logical coordinate system and is specified by +the x, y, w width and h height parameters. Its sister, +the viewport(), specifies the device coordinate system. +

The default window rectangle is the same as the device's +rectangle. See the Coordinate System Overview for an overview of coordinate transformation. +

See also window(), setViewport(), setViewXForm(), setWorldMatrix(), and setWorldXForm(). + +

Examples: aclock/aclock.cpp and drawdemo/drawdemo.cpp. +

void QPainter::setWindow ( const QRect & r ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Sets the painter's window to rectangle r. + +

void QPainter::setWorldMatrix ( const QWMatrix & m, bool combine = FALSE ) +

+Sets the world transformation matrix to m and enables world +transformation. +

If combine is TRUE, then m is combined with the current +transformation matrix, otherwise m replaces the current +transformation matrix. +

If m is the identity matrix and combine is FALSE, this +function calls setWorldXForm(FALSE). (The identity matrix is the +matrix where QWMatrix::m11() and QWMatrix::m22() are 1.0 and the +rest are 0.0.) +

World transformations are applied after the view transformations +(i.e. window and viewport). +

The following functions can transform the coordinate system without using +a QWMatrix: +

+

They operate on the painter's worldMatrix() and are implemented like this: +

+        void QPainter::rotate( double a )
+        {
+            QWMatrix m;
+            m.rotate( a );
+            setWorldMatrix( m, TRUE );
+        }
+
+ +

Note that you should always use combine when you are drawing +into a QPicture. Otherwise it may not be possible to replay the +picture with additional transformations. Using translate(), +scale(), etc., is safe. +

For a brief overview of coordinate transformation, see the Coordinate System Overview. +

See also worldMatrix(), setWorldXForm(), setWindow(), setViewport(), setViewXForm(), xForm(), and QWMatrix. + +

Examples: drawdemo/drawdemo.cpp and xform/xform.cpp. +

void QPainter::setWorldXForm ( bool enable ) +

+Enables world transformations if enable is TRUE, or disables +world transformations if enable is FALSE. The world +transformation matrix is not changed. +

See also setWorldMatrix(), setWindow(), setViewport(), setViewXForm(), and xForm(). + +

void QPainter::shear ( double sh, double sv ) +

+Shears the coordinate system by (sh, sv). +

See also translate(), scale(), rotate(), resetXForm(), setWorldMatrix(), and xForm(). + +

int * QPainter::tabArray () const +

+ +

Returns the currently set tab stop array. +

See also setTabArray(). + +

int QPainter::tabStops () const +

+ +

Returns the tab stop setting. +

See also setTabStops(). + +

void QPainter::translate ( double dx, double dy ) +

+Translates the coordinate system by (dx, dy). After this call, +(dx, dy) is added to points. +

For example, the following code draws the same point twice: +

+        void MyWidget::paintEvent()
+        {
+            QPainter paint( this );
+
+            paint.drawPoint( 0, 0 );
+
+            paint.translate( 100.0, 40.0 );
+            paint.drawPoint( -100, -40 );
+        }
+
+ +

See also scale(), shear(), rotate(), resetXForm(), setWorldMatrix(), and xForm(). + +

Examples: action/application.cpp, application/application.cpp, t10/cannon.cpp, t9/cannon.cpp, themes/metal.cpp, themes/wood.cpp, and xform/xform.cpp. +

QRect QPainter::viewport () const +

+Returns the viewport rectangle. +

See also setViewport() and setViewXForm(). + +

Example: aclock/aclock.cpp. +

QRect QPainter::window () const +

+Returns the window rectangle. +

See also setWindow() and setViewXForm(). + +

const QWMatrix & QPainter::worldMatrix () const +

+Returns the world transformation matrix. +

See also setWorldMatrix(). + +

QPoint QPainter::xForm ( const QPoint & pv ) const +

+Returns the point pv transformed from model coordinates to +device coordinates. +

See also xFormDev() and QWMatrix::map(). + +

QRect QPainter::xForm ( const QRect & rv ) const +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the rectangle rv transformed from model coordinates to +device coordinates. +

If world transformation is enabled and rotation or shearing has +been specified, then the bounding rectangle is returned. +

See also xFormDev() and QWMatrix::map(). + +

QPointArray QPainter::xForm ( const QPointArray & av ) const +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the point array av transformed from model coordinates +to device coordinates. +

See also xFormDev() and QWMatrix::map(). + +

QPointArray QPainter::xForm ( const QPointArray & av, int index, int npoints ) const +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the point array av transformed from model coordinates +to device coordinates. The index is the first point in the +array and npoints denotes the number of points to be +transformed. If npoints is negative, all points from av[index] until the last point in the array are transformed. +

The returned point array consists of the number of points that +were transformed. +

Example: +

+        QPointArray a(10);
+        QPointArray b;
+        b = painter.xForm(a, 2, 4);  // b.size() == 4
+        b = painter.xForm(a, 2, -1); // b.size() == 8
+
+ +

See also xFormDev() and QWMatrix::map(). + +

QRect QPainter::xFormDev ( const QRect & rd ) const +

+Returns the rectangle rd transformed from device coordinates to +model coordinates. +

If world transformation is enabled and rotation or shearing is +used, then the bounding rectangle is returned. +

See also xForm() and QWMatrix::map(). + +

QPoint QPainter::xFormDev ( const QPoint & pd ) const +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the point pd transformed from device coordinates to +model coordinates. +

See also xForm() and QWMatrix::map(). + +

QPointArray QPainter::xFormDev ( const QPointArray & ad ) const +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the point array ad transformed from device coordinates +to model coordinates. +

See also xForm() and QWMatrix::map(). + +

QPointArray QPainter::xFormDev ( const QPointArray & ad, int index, int npoints ) const +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Returns the point array ad transformed from device coordinates +to model coordinates. The index is the first point in the array +and npoints denotes the number of points to be transformed. If +npoints is negative, all points from ad[index] until the +last point in the array are transformed. +

The returned point array consists of the number of points that +were transformed. +

Example: +

+        QPointArray a(10);
+        QPointArray b;
+        b = painter.xFormDev(a, 1, 3);  // b.size() == 3
+        b = painter.xFormDev(a, 1, -1); // b.size() == 9
+
+ +

See also xForm() and QWMatrix::map(). + +

Related Functions

+

void qDrawPlainRect ( QPainter * p, int x, int y, int w, int h, const QColor & c, int lineWidth, const QBrush * fill ) +

+ +

#include <qdrawutil.h> +

Draws the plain rectangle specified by (x, y, w, h) +using the painter p. +

The color argument c specifies the line color. +

The lineWidth argument specifies the line width. +

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

If you want to use a QFrame widget instead, you can make it +display a plain rectangle, for example QFrame::setFrameStyle( QFrame::Box | QFrame::Plain ). +

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. +

See also qDrawShadeRect() and QStyle::drawPrimitive(). + +

void qDrawShadeLine ( QPainter * p, int x1, int y1, int x2, int y2, const QColorGroup & g, bool sunken, int lineWidth, int midLineWidth ) +

+ +

#include <qdrawutil.h> +

Draws a horizontal (y1 == y2) or vertical (x1 == x2) +shaded line using the painter p. +

Nothing is drawn if y1 != y2 and x1 != x2 (i.e. the +line is neither horizontal nor vertical). +

The color group argument g specifies the shading colors (light, dark and middle colors). +

The line appears sunken if sunken is TRUE, or raised if sunken is FALSE. +

The lineWidth argument specifies the line width for each of the +lines. It is not the total line width. +

The midLineWidth argument specifies the width of a middle line +drawn in the QColorGroup::mid() color. +

If you want to use a QFrame widget instead, you can make it +display a shaded line, for example QFrame::setFrameStyle( QFrame::HLine | QFrame::Sunken ). +

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. +

See also qDrawShadeRect(), qDrawShadePanel(), and QStyle::drawPrimitive(). + +

void qDrawShadePanel ( QPainter * p, int x, int y, int w, int h, const QColorGroup & g, bool sunken, int lineWidth, const QBrush * fill ) +

+ +

#include <qdrawutil.h> +

Draws the shaded panel specified by (x, y, w, h) using +the painter p. +

The color group argument g specifies the shading colors (light, dark and middle colors). +

The panel appears sunken if sunken is TRUE, or raised if sunken is FALSE. +

The lineWidth argument specifies the line width. +

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

If you want to use a QFrame widget instead, you can make it +display a shaded panel, for example QFrame::setFrameStyle( QFrame::Panel | QFrame::Sunken ). +

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. +

See also qDrawWinPanel(), qDrawShadeLine(), qDrawShadeRect(), and QStyle::drawPrimitive(). + +

void qDrawShadeRect ( QPainter * p, int x, int y, int w, int h, const QColorGroup & g, bool sunken, int lineWidth, int midLineWidth, const QBrush * fill ) +

+ +

#include <qdrawutil.h> +

Draws the shaded rectangle specified by (x, y, w, h) +using the painter p. +

The color group argument g specifies the shading colors (light, dark and middle colors). +

The rectangle appears sunken if sunken is TRUE, or raised if sunken is FALSE. +

The lineWidth argument specifies the line width for each of the +lines. It is not the total line width. +

The midLineWidth argument specifies the width of a middle line +drawn in the QColorGroup::mid() color. +

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

If you want to use a QFrame widget instead, you can make it +display a shaded rectangle, for example QFrame::setFrameStyle( QFrame::Box | QFrame::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. +

See also qDrawShadeLine(), qDrawShadePanel(), qDrawPlainRect(), QStyle::drawItem(), QStyle::drawControl(), and QStyle::drawComplexControl(). + +

void qDrawWinButton ( QPainter * p, int x, int y, int w, int h, const QColorGroup & g, bool sunken, const QBrush * fill ) +

+ +

#include <qdrawutil.h> +

Draws the Windows-style button specified by (x, y, w, h) using the painter p. +

The color group argument g specifies the shading colors (light, dark and middle colors). +

The button appears sunken if sunken is TRUE, or raised if sunken is FALSE. +

The line width is 2 pixels. +

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

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. +

See also qDrawWinPanel() and QStyle::drawControl(). + +

void qDrawWinPanel ( QPainter * p, int x, int y, int w, int h, const QColorGroup & g, bool sunken, const QBrush * fill ) +

+ +

#include <qdrawutil.h> +

Draws the Windows-style panel specified by (x, y, w, h) using the painter p. +

The color group argument g specifies the shading colors. +

The panel appears sunken if sunken is TRUE, or raised if sunken is FALSE. +

The line width is 2 pixels. +

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

If you want to use a QFrame widget instead, you can make it +display a shaded panel, for example QFrame::setFrameStyle( QFrame::WinPanel | QFrame::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. +

See also qDrawShadePanel(), qDrawWinButton(), and QStyle::drawPrimitive(). + + +

+This file is part of the Qt toolkit. +Copyright © 1995-2007 +Trolltech. All Rights Reserved.

+ +
Copyright © 2007 +TrolltechTrademarks +
Qt 3.3.8
+
+ -- cgit v1.2.1