/**************************************************************************** ** ** Implementation of QPainter, QPen and QBrush classes ** ** Created : 940112 ** ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved. ** ** This file is part of the kernel module of the Qt GUI Toolkit. ** ** This file may be used under the terms of the GNU General ** Public License versions 2.0 or 3.0 as published by the Free ** Software Foundation and appearing in the files LICENSE.GPL2 ** and LICENSE.GPL3 included in the packaging of this file. ** Alternatively you may (at your option) use any later version ** of the GNU General Public License if such license has been ** publicly approved by Trolltech ASA (or its successors, if any) ** and the KDE Free Qt Foundation. ** ** Please review the following information to ensure GNU General ** Public Licensing requirements will be met: ** http://trolltech.com/products/qt/licenses/licensing/opensource/. ** If you are unsure which license is appropriate for your use, please ** review the following information: ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview ** or contact the sales department at sales@trolltech.com. ** ** This file may be used under the terms of the Q Public License as ** defined by Trolltech ASA and appearing in the file LICENSE.QPL ** included in the packaging of this file. Licensees holding valid Qt ** Commercial licenses may use this file in accordance with the Qt ** Commercial License Agreement provided with the Software. ** ** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, ** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted ** herein. ** **********************************************************************/ #include "qpainter.h" #include "qpainter_p.h" #include "qbitmap.h" #include "qptrstack.h" #include "qptrdict.h" #include "qdatastream.h" #include "qwidget.h" #include "qimage.h" #include "qpaintdevicemetrics.h" #include "qapplication.h" #include "qrichtext_p.h" #include "qregexp.h" #include "qcleanuphandler.h" #ifdef Q_WS_QWS #include "qgfx_qws.h" #endif #include #include "qtextlayout_p.h" #include "qfontengine_p.h" #ifndef QT_NO_TRANSFORMATIONS typedef QPtrStack QWMatrixStack; #endif // POSIX Large File Support redefines truncate -> truncate64 #if defined(truncate) # undef truncate #endif /*! \class QPainter qpainter.h \brief The QPainter class does low-level painting e.g. on widgets. \ingroup graphics \ingroup images \mainclass 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: \list \i Construct a painter. \i Set a pen, a brush etc. \i Draw. \i Destroy the painter. \endlist 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: \code void SimpleExampleWidget::paintEvent() { QPainter paint( this ); paint.setPen( Qt::blue ); paint.drawText( rect(), AlignCenter, "The Text" ); } \endcode Usage is simple, and there are many settings you can use: \list \i font() is the currently set font. If you set a font that isn't available, Qt finds a close match. In fact font() returns what you set using setFont() and fontInfo() returns the font actually being used (which may be the same). \i brush() is the currently set brush; the color or pattern that's used for filling e.g. circles. \i pen() is the currently set pen; the color or stipple that's used for drawing lines or boundaries. \i backgroundMode() is \c Opaque or \c Transparent, i.e. whether backgroundColor() is used or not. \i backgroundColor() only applies when backgroundMode() is Opaque and pen() is a stipple. In that case, it describes the color of the background pixels in the stipple. \i rasterOp() is how pixels drawn interact with the pixels already there. \i brushOrigin() is the origin of the tiled brushes, normally the origin of the window. \i viewport(), window(), worldMatrix() and many more make up the painter's coordinate transformation system. See \link coordsys.html The Coordinate System \endlink for an explanation of this, or see below for a very brief overview of the functions. \i hasClipping() is whether the painter clips at all. (The paint device clips, too.) If the painter clips, it clips to clipRegion(). \i pos() is the current position, set by moveTo() and used by lineTo(). \endlist 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 \link coordsys.html The Coordinate System \endlink 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. \headerfile qdrawutil.h \sa QPaintDevice QWidget QPixmap QPrinter QPicture \link simple-application.html Application Walkthrough \endlink \link coordsys.html Coordinate System Overview \endlink */ /*! \fn QGfx * QPainter::internalGfx() \internal */ /*! \enum QPainter::CoordinateMode \value CoordDevice \value CoordPainter \sa clipRegion() */ /*! \enum QPainter::TextDirection \value Auto \value RTL right to left \value LTR left to right \sa drawText() */ /*! \enum Qt::PaintUnit \value PixelUnit \value LoMetricUnit \e obsolete \value HiMetricUnit \e obsolete \value LoEnglishUnit \e obsolete \value HiEnglishUnit \e obsolete \value TwipsUnit \e obsolete */ /*! \enum Qt::BrushStyle \value NoBrush \value SolidPattern \value Dense1Pattern \value Dense2Pattern \value Dense3Pattern \value Dense4Pattern \value Dense5Pattern \value Dense6Pattern \value Dense7Pattern \value HorPattern \value VerPattern \value CrossPattern \value BDiagPattern \value FDiagPattern \value DiagCrossPattern \value CustomPattern \img brush-styles.png Brush Styles */ /*! \enum Qt::RasterOp This enum type is used to describe the way things are written to the paint device. Each bit of the \e src (what you write) interacts with the corresponding bit of the \e dst pixel. \value CopyROP dst = src \value OrROP dst = src OR dst \value XorROP dst = src XOR dst \value NotAndROP dst = (NOT src) AND dst \value EraseROP an alias for \c NotAndROP \value NotCopyROP dst = NOT src \value NotOrROP dst = (NOT src) OR dst \value NotXorROP dst = (NOT src) XOR dst \value AndROP dst = src AND dst \value NotEraseROP an alias for \c AndROP \value NotROP dst = NOT dst \value ClearROP dst = 0 \value SetROP dst = 1 \value NopROP dst = dst \value AndNotROP dst = src AND (NOT dst) \value OrNotROP dst = src OR (NOT dst) \value NandROP dst = NOT (src AND dst) \value NorROP dst = NOT (src OR dst) By far the most useful ones are \c CopyROP and \c XorROP. On Qt/Embedded, only \c CopyROP, \c XorROP, and \c NotROP are supported. */ /*! \enum Qt::AlignmentFlags This enum type is used to describe alignment. It contains horizontal and vertical flags. The horizontal flags are: \value AlignAuto Aligns according to the language. Left for most, right for Arabic and Hebrew. \value AlignLeft Aligns with the left edge. \value AlignRight Aligns with the right edge. \value AlignHCenter Centers horizontally in the available space. \value AlignJustify Justifies the text in the available space. Does not work for everything and may be interpreted as AlignAuto in some cases. The vertical flags are: \value AlignTop Aligns with the top. \value AlignBottom Aligns with the bottom. \value AlignVCenter Centers vertically in the available space. You can use only one of the horizontal flags at a time. There is one two-dimensional flag: \value AlignCenter Centers in both dimensions. You can use at most one horizontal and one vertical flag at a time. \c AlignCenter counts as both horizontal and vertical. Masks: \value AlignHorizontal_Mask \value AlignVertical_Mask Conflicting combinations of flags have undefined meanings. */ /*! \enum Qt::TextFlags This enum type is used to define some modifier flags. Some of these flags only make sense in the context of printing: \value SingleLine Treats all whitespace as spaces and prints just one line. \value DontClip If it's impossible to stay within the given bounds, it prints outside. \value ExpandTabs Makes the U+0009 (ASCII tab) character move to the next tab stop. \value ShowPrefix Displays the string "\&P" as P (see QButton for an example). For an ampersand, use "\&\&". \value WordBreak Breaks lines at appropriate points, e.g. at word boundaries. \value BreakAnywhere Breaks lines anywhere, even within words. \value NoAccel Same as ShowPrefix but doesn't draw the underlines. You can use as many modifier flags as you want, except that \c SingleLine and \c WordBreak cannot be combined. Flags that are inappropriate for a given use (e.g. ShowPrefix to QGridLayout::addWidget()) are generally ignored. */ /*! \enum Qt::PenStyle This enum type defines the pen styles that can be drawn using QPainter. The styles are \value NoPen no line at all. For example, QPainter::drawRect() fills but does not draw any boundary line. \value SolidLine a simple line. \value DashLine dashes separated by a few pixels. \value DotLine dots separated by a few pixels. \value DashDotLine alternate dots and dashes. \value DashDotDotLine one dash, two dots, one dash, two dots. \value MPenStyle mask of the pen styles. \img pen-styles.png Pen Styles */ /*! \enum Qt::PenCapStyle This enum type defines the pen cap styles supported by Qt, i.e. the line end caps that can be drawn using QPainter. \value FlatCap a square line end that does not cover the end point of the line. \value SquareCap a square line end that covers the end point and extends beyond it with half the line width. \value RoundCap a rounded line end. \value MPenCapStyle mask of the pen cap styles. \img pen-cap-styles.png Pen Cap Styles */ /*! \enum Qt::PenJoinStyle This enum type defines the pen join styles supported by Qt, i.e. which joins between two connected lines can be drawn using QPainter. \value MiterJoin The outer edges of the lines are extended to meet at an angle, and this area is filled. \value BevelJoin The triangular notch between the two lines is filled. \value RoundJoin A circular arc between the two lines is filled. \value MPenJoinStyle mask of the pen join styles. \img pen-join-styles.png Pen Join Styles */ /*! \enum Qt::BGMode Background mode \value TransparentMode \value OpaqueMode */ /*! Constructs a painter. Notice that all painter settings (setPen, setBrush etc.) are reset to default values when begin() is called. \sa begin(), end() */ QPainter::QPainter() { init(); } /*! Constructs a painter that begins painting the paint device \a pd immediately. Depending on the underlying graphic system the painter will paint over children of the paintdevice if \a unclipped is TRUE. This constructor is convenient for short-lived painters, e.g. in a \link QWidget::paintEvent() paint event\endlink 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(): \code void MyWidget::paintEvent( QPaintEvent * ) { QPainter p; p.begin( this ); p.drawLine( ... ); // drawing code p.end(); } \endcode The same example using this constructor: \code void MyWidget::paintEvent( QPaintEvent * ) { QPainter p( this ); p.drawLine( ... ); // drawing code } \endcode 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. \sa begin(), end() */ QPainter::QPainter( const QPaintDevice *pd, bool unclipped ) { init(); if ( begin( pd, unclipped ) ) flags |= CtorBegin; } /*! Constructs a painter that begins painting the paint device \a pd immediately, with the default arguments taken from \a copyAttributes. The painter will paint over children of the paint device if \a unclipped is TRUE (although this is not supported on all platforms). \sa begin() */ QPainter::QPainter( const QPaintDevice *pd, const QWidget *copyAttributes, bool unclipped ) { init(); if ( begin( pd, copyAttributes, unclipped ) ) flags |= CtorBegin; } /*! Destroys the painter. */ QPainter::~QPainter() { if ( isActive() ) end(); else killPStack(); if ( tabarray ) // delete tab array delete [] tabarray; #ifndef QT_NO_TRANSFORMATIONS if ( wm_stack ) delete (QWMatrixStack *)wm_stack; #endif destroy(); } /*! \overload bool QPainter::begin( const QPaintDevice *pd, const QWidget *copyAttributes, bool unclipped ) This version opens the painter on a paint device \a pd and sets the initial pen, background color and font from \a copyAttributes, painting over the paint device's children when \a unclipped is TRUE. This is equivalent to: \code QPainter p; p.begin( pd ); p.setPen( copyAttributes->foregroundColor() ); p.setBackgroundColor( copyAttributes->backgroundColor() ); p.setFont( copyAttributes->font() ); \endcode 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: \code void MyWidget::paintEvent( QPaintEvent * ) { QPixmap pm(size()); QPainter p; p.begin(&pm, this); // ... potentially flickering paint operation ... p.end(); bitBlt(this, 0, 0, &pm); } \endcode \sa end() */ bool QPainter::begin( const QPaintDevice *pd, const QWidget *copyAttributes, bool unclipped ) { if ( copyAttributes == 0 ) { #if defined(QT_CHECK_NULL) qWarning( "QPainter::begin: The widget to copy attributes from cannot " "be null" ); #endif return FALSE; } if ( begin( pd, unclipped ) ) { setPen( copyAttributes->foregroundColor() ); setBackgroundColor( copyAttributes->backgroundColor() ); setFont( copyAttributes->font() ); return TRUE; } return FALSE; } /*! \internal Sets or clears a pointer flag. */ void QPainter::setf( uint b, bool v ) { if ( v ) setf( b ); else clearf( b ); } /*! \fn 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. \sa QPaintDevice::paintingActive() */ /*! \fn QPaintDevice *QPainter::device() const Returns the paint device on which this painter is currently painting, or 0 if the painter is not active. \sa QPaintDevice::paintingActive() */ struct QPState { // painter state QFont font; QPen pen; QPoint curPt; QBrush brush; QColor bgc; uchar bgm; uchar rop; QPoint bro; QRect wr, vr; #ifndef QT_NO_TRANSFORMATIONS QWMatrix wm; #else int xlatex; int xlatey; #endif bool vxf; bool wxf; QRegion rgn; bool clip; int ts; int *ta; void* wm_stack; }; //TODO lose the worldmatrix stack typedef QPtrStack QPStateStack; void QPainter::killPStack() { #if defined(QT_CHECK_STATE) if ( ps_stack && !((QPStateStack *)ps_stack)->isEmpty() ) qWarning( "QPainter::killPStack: non-empty save/restore stack when " "end() was called" ); #endif delete (QPStateStack *)ps_stack; ps_stack = 0; } /*! Saves the current painter state (pushes the state onto a stack). A save() must be followed by a corresponding restore(). end() unwinds the stack. \sa restore() */ void QPainter::save() { if ( testf(ExtDev) ) { if ( testf(DirtyFont) ) updateFont(); if ( testf(DirtyPen) ) updatePen(); if ( testf(DirtyBrush) ) updateBrush(); pdev->cmd( QPaintDevice::PdcSave, this, 0 ); } QPStateStack *pss = (QPStateStack *)ps_stack; if ( pss == 0 ) { pss = new QPtrStack; Q_CHECK_PTR( pss ); pss->setAutoDelete( TRUE ); ps_stack = pss; } QPState *ps = new QPState; Q_CHECK_PTR( ps ); ps->font = cfont; ps->pen = cpen; ps->curPt = pos(); ps->brush = cbrush; ps->bgc = bg_col; ps->bgm = bg_mode; ps->rop = rop; ps->bro = bro; #ifndef QT_NO_TRANSFORMATIONS ps->wr = QRect( wx, wy, ww, wh ); ps->vr = QRect( vx, vy, vw, vh ); ps->wm = wxmat; ps->vxf = testf(VxF); ps->wxf = testf(WxF); #else ps->xlatex = xlatex; ps->xlatey = xlatey; #endif ps->rgn = crgn; ps->clip = testf(ClipOn); ps->ts = tabstops; ps->ta = tabarray; ps->wm_stack = wm_stack; wm_stack = 0; pss->push( ps ); } /*! Restores the current painter state (pops a saved state off the stack). \sa save() */ void QPainter::restore() { if ( testf(ExtDev) ) { pdev->cmd( QPaintDevice::PdcRestore, this, 0 ); if ( pdev->devType() == QInternal::Picture ) block_ext = TRUE; } QPStateStack *pss = (QPStateStack *)ps_stack; if ( pss == 0 || pss->isEmpty() ) { #if defined(QT_CHECK_STATE) qWarning( "QPainter::restore: Empty stack error" ); #endif return; } QPState *ps = pss->pop(); bool hardRestore = testf(VolatileDC); if ( ps->font != cfont || hardRestore ) setFont( ps->font ); if ( ps->pen != cpen || hardRestore ) setPen( ps->pen ); if ( ps->brush != cbrush || hardRestore ) setBrush( ps->brush ); if ( ps->bgc != bg_col || hardRestore ) setBackgroundColor( ps->bgc ); if ( ps->bgm != bg_mode || hardRestore ) setBackgroundMode( (BGMode)ps->bgm ); if ( ps->rop != rop || hardRestore ) setRasterOp( (RasterOp)ps->rop ); if ( ps->bro != bro || hardRestore ) setBrushOrigin( ps->bro ); #ifndef QT_NO_TRANSFORMATIONS QRect wr( wx, wy, ww, wh ); QRect vr( vx, vy, vw, vh ); if ( ps->wr != wr || hardRestore ) setWindow( ps->wr ); if ( ps->vr != vr || hardRestore ) setViewport( ps->vr ); if ( ps->wm != wxmat || hardRestore ) setWorldMatrix( ps->wm ); if ( ps->vxf != testf(VxF) || hardRestore ) setViewXForm( ps->vxf ); if ( ps->wxf != testf(WxF) || hardRestore ) setWorldXForm( ps->wxf ); #else xlatex = ps->xlatex; xlatey = ps->xlatey; setf( VxF, xlatex || xlatey ); #endif if ( ps->curPt != pos() || hardRestore ) moveTo( ps->curPt ); if ( ps->rgn != crgn || hardRestore ) setClipRegion( ps->rgn ); if ( ps->clip != testf(ClipOn) || hardRestore ) setClipping( ps->clip ); tabstops = ps->ts; tabarray = ps->ta; #ifndef QT_NO_TRANSFORMATIONS if ( wm_stack ) delete (QWMatrixStack *)wm_stack; wm_stack = ps->wm_stack; #endif delete ps; block_ext = FALSE; } typedef QPtrDict QPaintDeviceDict; static QPaintDeviceDict *pdev_dict = 0; /*! Redirects all paint commands for a paint device, \a pdev, to another paint device, \a replacement, unless \a replacement is 0. If \a replacement is 0, the redirection for \a pdev is removed. In general, you'll probably find calling QPixmap::grabWidget() or QPixmap::grabWindow() is an easier solution. */ void QPainter::redirect( QPaintDevice *pdev, QPaintDevice *replacement ) { if ( pdev_dict == 0 ) { if ( replacement == 0 ) return; pdev_dict = new QPaintDeviceDict; Q_CHECK_PTR( pdev_dict ); } #if defined(QT_CHECK_NULL) if ( pdev == 0 ) qWarning( "QPainter::redirect: The pdev argument cannot be 0" ); #endif if ( replacement ) { pdev_dict->insert( pdev, replacement ); } else { pdev_dict->remove( pdev ); if ( pdev_dict->count() == 0 ) { delete pdev_dict; pdev_dict = 0; } } } /*! \internal Returns the replacement for \a pdev, or 0 if there is no replacement. */ QPaintDevice *QPainter::redirect( QPaintDevice *pdev ) { return pdev_dict ? pdev_dict->find( pdev ) : 0; } /*! 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. \sa fontInfo(), isActive() */ QFontMetrics QPainter::fontMetrics() const { if ( pdev && pdev->devType() == QInternal::Picture ) return QFontMetrics( cfont ); return QFontMetrics(this); } /*! 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. \sa fontMetrics(), isActive() */ QFontInfo QPainter::fontInfo() const { if ( pdev && pdev->devType() == QInternal::Picture ) return QFontInfo( cfont ); return QFontInfo(this); } /*! \fn const QPen &QPainter::pen() const Returns the painter's current pen. \sa setPen() */ /*! Sets a new painter pen. The \a pen defines how to draw lines and outlines, and it also defines the text color. \sa pen() */ void QPainter::setPen( const QPen &pen ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setPen: Will be reset by begin()" ); #endif if ( cpen == pen ) return; cpen = pen; updatePen(); } /*! \overload Sets the painter's pen to have style \a style, width 0 and black color. \sa pen(), QPen */ void QPainter::setPen( PenStyle style ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setPen: Will be reset by begin()" ); #endif QPen::QPenData *d = cpen.data; // low level access if ( d->style == style && d->linest == style && !d->width && d->color == Qt::black ) return; if ( d->count != 1 ) { cpen.detach(); d = cpen.data; } d->style = style; d->width = 0; d->color = Qt::black; d->linest = style; updatePen(); } /*! \overload Sets the painter's pen to have style \c SolidLine, width 0 and the specified \a color. \sa pen(), QPen */ void QPainter::setPen( const QColor &color ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setPen: Will be reset by begin()" ); #endif QPen::QPenData *d = cpen.data; // low level access if ( d->color == color && !d->width && d->style == SolidLine && d->linest == SolidLine ) return; if ( d->count != 1 ) { cpen.detach(); d = cpen.data; } d->style = SolidLine; d->width = 0; d->color = color; d->linest = SolidLine; updatePen(); } /*! \fn const QBrush &QPainter::brush() const Returns the painter's current brush. \sa QPainter::setBrush() */ /*! \overload Sets the painter's brush to \a brush. The \a brush defines how shapes are filled. \sa brush() */ void QPainter::setBrush( const QBrush &brush ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setBrush: Will be reset by begin()" ); #endif if ( cbrush == brush ) return; cbrush = brush; updateBrush(); } /*! Sets the painter's brush to black color and the specified \a style. \sa brush(), QBrush */ void QPainter::setBrush( BrushStyle style ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setBrush: Will be reset by begin()" ); #endif QBrush::QBrushData *d = cbrush.data; // low level access if ( d->style == style && d->color == Qt::black && !d->pixmap ) return; if ( d->count != 1 ) { cbrush.detach(); d = cbrush.data; } d->style = style; d->color = Qt::black; if ( d->pixmap ) { delete d->pixmap; d->pixmap = 0; } updateBrush(); } /*! \overload Sets the painter's brush to have style \c SolidPattern and the specified \a color. \sa brush(), QBrush */ void QPainter::setBrush( const QColor &color ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setBrush: Will be reset by begin()" ); #endif QBrush::QBrushData *d = cbrush.data; // low level access if ( d->color == color && d->style == SolidPattern && !d->pixmap ) return; if ( d->count != 1 ) { cbrush.detach(); d = cbrush.data; } d->style = SolidPattern; d->color = color; if ( d->pixmap ) { delete d->pixmap; d->pixmap = 0; } updateBrush(); } /*! \fn const QColor &QPainter::backgroundColor() const Returns the current background color. \sa setBackgroundColor() QColor */ /*! \fn BGMode QPainter::backgroundMode() const Returns the current background mode. \sa setBackgroundMode() BGMode */ /*! \fn RasterOp QPainter::rasterOp() const Returns the current \link Qt::RasterOp raster operation \endlink. \sa setRasterOp() RasterOp */ /*! \fn const QPoint &QPainter::brushOrigin() const Returns the brush origin currently set. \sa setBrushOrigin() */ /*! \fn int QPainter::tabStops() const Returns the tab stop setting. \sa setTabStops() */ /*! Set the tab stop width to \a ts, i.e. locates tab stops at \a ts, 2*\a ts, 3*\a ts and so on. Tab stops are used when drawing formatted text with \c 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. \sa tabStops(), setTabArray(), drawText(), fontMetrics() */ void QPainter::setTabStops( int ts ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setTabStops: Will be reset by begin()" ); #endif tabstops = ts; if ( isActive() && testf(ExtDev) ) { // tell extended device QPDevCmdParam param[1]; param[0].ival = ts; pdev->cmd( QPaintDevice::PdcSetTabStops, this, param ); } } /*! \fn int *QPainter::tabArray() const Returns the currently set tab stop array. \sa setTabArray() */ /*! Sets the tab stop array to \a ta. This puts tab stops at \a ta[0], \a 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. \sa tabArray(), setTabStops(), drawText(), fontMetrics() */ void QPainter::setTabArray( int *ta ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setTabArray: Will be reset by begin()" ); #endif if ( ta != tabarray ) { tabarraylen = 0; if ( tabarray ) // Avoid purify complaint delete [] tabarray; // delete old array if ( ta ) { // tabarray = copy of 'ta' while ( ta[tabarraylen] ) tabarraylen++; tabarraylen++; // and 0 terminator tabarray = new int[tabarraylen]; // duplicate ta memcpy( tabarray, ta, sizeof(int)*tabarraylen ); } else { tabarray = 0; } } if ( isActive() && testf(ExtDev) ) { // tell extended device QPDevCmdParam param[2]; param[0].ival = tabarraylen; param[1].ivec = tabarray; pdev->cmd( QPaintDevice::PdcSetTabArray, this, param ); } } /*! \fn HANDLE QPainter::handle() const Returns the platform-dependent handle used for drawing. Using this function is not portable. */ /***************************************************************************** QPainter xform settings *****************************************************************************/ #ifndef QT_NO_TRANSFORMATIONS /*! Enables view transformations if \a enable is TRUE, or disables view transformations if \a enable is FALSE. \sa hasViewXForm(), setWindow(), setViewport(), setWorldMatrix(), setWorldXForm(), xForm() */ void QPainter::setViewXForm( bool enable ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setViewXForm: Will be reset by begin()" ); #endif if ( !isActive() || enable == testf(VxF) ) return; setf( VxF, enable ); if ( testf(ExtDev) ) { QPDevCmdParam param[1]; param[0].ival = enable; pdev->cmd( QPaintDevice::PdcSetVXform, this, param ); } updateXForm(); } /*! \fn bool QPainter::hasViewXForm() const Returns TRUE if view transformation is enabled; otherwise returns FALSE. \sa setViewXForm(), xForm() */ /*! Returns the window rectangle. \sa setWindow(), setViewXForm() */ QRect QPainter::window() const { return QRect( wx, wy, ww, wh ); } /*! 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 \a x, \a y, \a w width and \a 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 \link coordsys.html Coordinate System Overview \endlink for an overview of coordinate transformation. \sa window(), setViewport(), setViewXForm(), setWorldMatrix(), setWorldXForm() */ void QPainter::setWindow( int x, int y, int w, int h ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setWindow: Will be reset by begin()" ); #endif wx = x; wy = y; ww = w; wh = h; if ( testf(ExtDev) ) { QRect r( x, y, w, h ); QPDevCmdParam param[1]; param[0].rect = (QRect*)&r; pdev->cmd( QPaintDevice::PdcSetWindow, this, param ); } if ( testf(VxF) ) updateXForm(); else setViewXForm( TRUE ); } /*! Returns the viewport rectangle. \sa setViewport(), setViewXForm() */ QRect QPainter::viewport() const // get viewport { return QRect( vx, vy, vw, vh ); } /*! 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 \a x, \a y, \a w width and \a 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 \link coordsys.html Coordinate System Overview \endlink for an overview of coordinate transformation. \sa viewport(), setWindow(), setViewXForm(), setWorldMatrix(), setWorldXForm(), xForm() */ void QPainter::setViewport( int x, int y, int w, int h ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setViewport: Will be reset by begin()" ); #endif vx = x; vy = y; vw = w; vh = h; if ( testf(ExtDev) ) { QRect r( x, y, w, h ); QPDevCmdParam param[1]; param[0].rect = (QRect*)&r; pdev->cmd( QPaintDevice::PdcSetViewport, this, param ); } if ( testf(VxF) ) updateXForm(); else setViewXForm( TRUE ); } /*! Enables world transformations if \a enable is TRUE, or disables world transformations if \a enable is FALSE. The world transformation matrix is not changed. \sa setWorldMatrix(), setWindow(), setViewport(), setViewXForm(), xForm() */ void QPainter::setWorldXForm( bool enable ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) qWarning( "QPainter::setWorldXForm: Will be reset by begin()" ); #endif if ( !isActive() || enable == testf(WxF) ) return; setf( WxF, enable ); if ( testf(ExtDev) && !block_ext ) { QPDevCmdParam param[1]; param[0].ival = enable; pdev->cmd( QPaintDevice::PdcSetWXform, this, param ); } updateXForm(); } /*! \fn bool QPainter::hasWorldXForm() const Returns TRUE if world transformation is enabled; otherwise returns FALSE. \sa setWorldXForm() */ /*! Returns the world transformation matrix. \sa setWorldMatrix() */ const QWMatrix &QPainter::worldMatrix() const { return wxmat; } /*! Sets the world transformation matrix to \a m and enables world transformation. If \a combine is TRUE, then \a m is combined with the current transformation matrix, otherwise \a m replaces the current transformation matrix. If \a m is the identity matrix and \a 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. \link setWindow() window\endlink and \link setViewport() viewport\endlink). The following functions can transform the coordinate system without using a QWMatrix: \list \i translate() \i scale() \i shear() \i rotate() \endlist They operate on the painter's worldMatrix() and are implemented like this: \code void QPainter::rotate( double a ) { QWMatrix m; m.rotate( a ); setWorldMatrix( m, TRUE ); } \endcode Note that you should always use \a 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 \link coordsys.html Coordinate System Overview. \endlink \sa worldMatrix() setWorldXForm() setWindow() setViewport() setViewXForm() xForm() QWMatrix */ void QPainter::setWorldMatrix( const QWMatrix &m, bool combine ) { if ( !isActive() ) { #if defined(QT_CHECK_STATE) qWarning( "QPainter::setWorldMatrix: Will be reset by begin()" ); #endif return; } if ( combine ) wxmat = m * wxmat; // combines else wxmat = m; // set new matrix bool identity = wxmat.m11() == 1.0F && wxmat.m22() == 1.0F && wxmat.m12() == 0.0F && wxmat.m21() == 0.0F && wxmat.dx() == 0.0F && wxmat.dy() == 0.0F; if ( testf(ExtDev) && !block_ext ) { QPDevCmdParam param[2]; param[0].matrix = &m; param[1].ival = combine; pdev->cmd( QPaintDevice::PdcSetWMatrix, this, param ); } if ( identity && pdev->devType() != QInternal::Picture ) setWorldXForm( FALSE ); else if ( !testf(WxF) ) setWorldXForm( TRUE ); else updateXForm(); } /*! \obsolete We recommend using save() instead. */ void QPainter::saveWorldMatrix() { QWMatrixStack *stack = (QWMatrixStack *)wm_stack; if ( stack == 0 ) { stack = new QPtrStack; Q_CHECK_PTR( stack ); stack->setAutoDelete( TRUE ); wm_stack = stack; } stack->push( new QWMatrix( wxmat ) ); } /*! \obsolete We recommend using restore() instead. */ void QPainter::restoreWorldMatrix() { QWMatrixStack *stack = (QWMatrixStack *)wm_stack; if ( stack == 0 || stack->isEmpty() ) { #if defined(QT_CHECK_STATE) qWarning( "QPainter::restoreWorldMatrix: Empty stack error" ); #endif return; } QWMatrix* m = stack->pop(); setWorldMatrix( *m ); delete m; } #endif // QT_NO_TRANSFORMATIONS /*! Translates the coordinate system by \a (dx, dy). After this call, \a (dx, dy) is added to points. For example, the following code draws the same point twice: \code void MyWidget::paintEvent() { QPainter paint( this ); paint.drawPoint( 0, 0 ); paint.translate( 100.0, 40.0 ); paint.drawPoint( -100, -40 ); } \endcode \sa scale(), shear(), rotate(), resetXForm(), setWorldMatrix(), xForm() */ void QPainter::translate( double dx, double dy ) { #ifndef QT_NO_TRANSFORMATIONS QWMatrix m; m.translate( dx, dy ); setWorldMatrix( m, TRUE ); #else xlatex += (int)dx; xlatey += (int)dy; setf( VxF, xlatex || xlatey ); #endif } #ifndef QT_NO_TRANSFORMATIONS /*! Scales the coordinate system by \a (sx, sy). \sa translate(), shear(), rotate(), resetXForm(), setWorldMatrix(), xForm() */ void QPainter::scale( double sx, double sy ) { QWMatrix m; m.scale( sx, sy ); setWorldMatrix( m, TRUE ); } /*! Shears the coordinate system by \a (sh, sv). \sa translate(), scale(), rotate(), resetXForm(), setWorldMatrix(), xForm() */ void QPainter::shear( double sh, double sv ) { QWMatrix m; m.shear( sv, sh ); setWorldMatrix( m, TRUE ); } /*! Rotates the coordinate system \a a degrees counterclockwise. \sa translate(), scale(), shear(), resetXForm(), setWorldMatrix(), xForm() */ void QPainter::rotate( double a ) { QWMatrix m; m.rotate( a ); setWorldMatrix( m, TRUE ); } /*! Resets any transformations that were made using translate(), scale(), shear(), rotate(), setWorldMatrix(), setViewport() and setWindow(). \sa worldMatrix(), viewport(), window() */ void QPainter::resetXForm() { if ( !isActive() ) return; wx = wy = vx = vy = 0; // default view origins ww = vw = pdev->metric( QPaintDeviceMetrics::PdmWidth ); wh = vh = pdev->metric( QPaintDeviceMetrics::PdmHeight ); wxmat = QWMatrix(); setWorldXForm( FALSE ); setViewXForm( FALSE ); } /*! \internal Updates an internal integer transformation matrix. */ void QPainter::updateXForm() { QWMatrix m; if ( testf(VxF) ) { double scaleW = (double)vw/(double)ww; double scaleH = (double)vh/(double)wh; m.setMatrix( scaleW, 0, 0, scaleH, vx - wx*scaleW, vy - wy*scaleH ); } if ( testf(WxF) ) { if ( testf(VxF) ) m = wxmat * m; else m = wxmat; } xmat = m; txinv = FALSE; // no inverted matrix txop = TxNone; if ( m12()==0.0 && m21()==0.0 && m11() >= 0.0 && m22() >= 0.0 ) { if ( m11()==1.0 && m22()==1.0 ) { if ( dx()!=0.0 || dy()!=0.0 ) txop = TxTranslate; } else { txop = TxScale; #if defined(Q_WS_WIN) setf(DirtyFont); #endif } } else { txop = TxRotShear; #if defined(Q_WS_WIN) setf(DirtyFont); #endif } } /*! \internal Updates an internal integer inverse transformation matrix. */ void QPainter::updateInvXForm() { #if defined(QT_CHECK_STATE) Q_ASSERT( txinv == FALSE ); #endif txinv = TRUE; // creating inverted matrix bool invertible; QWMatrix m; if ( testf(VxF) ) { m.translate( vx, vy ); m.scale( 1.0*vw/ww, 1.0*vh/wh ); m.translate( -wx, -wy ); } if ( testf(WxF) ) { if ( testf(VxF) ) m = wxmat * m; else m = wxmat; } ixmat = m.invert( &invertible ); // invert matrix } #else void QPainter::resetXForm() { xlatex = 0; xlatey = 0; clearf( VxF ); } #endif // QT_NO_TRANSFORMATIONS extern bool qt_old_transformations; /*! \internal Maps a point from logical coordinates to device coordinates. */ void QPainter::map( int x, int y, int *rx, int *ry ) const { #ifndef QT_NO_TRANSFORMATIONS if ( qt_old_transformations ) { switch ( txop ) { case TxNone: *rx = x; *ry = y; break; case TxTranslate: // #### "Why no rounding here?", Warwick asked of Haavard. *rx = int(x + dx()); *ry = int(y + dy()); break; case TxScale: { double tx = m11()*x + dx(); double ty = m22()*y + dy(); *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5); *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5); } break; default: { double tx = m11()*x + m21()*y+dx(); double ty = m12()*x + m22()*y+dy(); *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5); *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5); } break; } } else { switch ( txop ) { case TxNone: *rx = x; *ry = y; break; case TxTranslate: *rx = qRound( x + dx() ); *ry = qRound( y + dy() ); break; case TxScale: *rx = qRound( m11()*x + dx() ); *ry = qRound( m22()*y + dy() ); break; default: *rx = qRound( m11()*x + m21()*y+dx() ); *ry = qRound( m12()*x + m22()*y+dy() ); break; } } #else *rx = x + xlatex; *ry = y + xlatey; #endif } /*! \internal Maps a rectangle from logical coordinates to device coordinates. This internal function does not handle rotation and/or shear. */ void QPainter::map( int x, int y, int w, int h, int *rx, int *ry, int *rw, int *rh ) const { #ifndef QT_NO_TRANSFORMATIONS if ( qt_old_transformations ) { switch ( txop ) { case TxNone: *rx = x; *ry = y; *rw = w; *rh = h; break; case TxTranslate: // #### "Why no rounding here?", Warwick asked of Haavard. *rx = int(x + dx()); *ry = int(y + dy()); *rw = w; *rh = h; break; case TxScale: { double tx1 = m11()*x + dx(); double ty1 = m22()*y + dy(); double tx2 = m11()*(x + w - 1) + dx(); double ty2 = m22()*(y + h - 1) + dy(); *rx = qRound( tx1 ); *ry = qRound( ty1 ); *rw = qRound( tx2 ) - *rx + 1; *rh = qRound( ty2 ) - *ry + 1; } break; default: #if defined(QT_CHECK_STATE) qWarning( "QPainter::map: Internal error" ); #endif break; } } else { switch ( txop ) { case TxNone: *rx = x; *ry = y; *rw = w; *rh = h; break; case TxTranslate: *rx = qRound(x + dx() ); *ry = qRound(y + dy() ); *rw = w; *rh = h; break; case TxScale: *rx = qRound( m11()*x + dx() ); *ry = qRound( m22()*y + dy() ); *rw = qRound( m11()*w ); *rh = qRound( m22()*h ); break; default: #if defined(QT_CHECK_STATE) qWarning( "QPainter::map: Internal error" ); #endif break; } } #else *rx = x + xlatex; *ry = y + xlatey; *rw = w; *rh = h; #endif } /*! \internal Maps a point from device coordinates to logical coordinates. */ void QPainter::mapInv( int x, int y, int *rx, int *ry ) const { #ifndef QT_NO_TRANSFORMATIONS #if defined(QT_CHECK_STATE) if ( !txinv ) qWarning( "QPainter::mapInv: Internal error" ); #endif if ( qt_old_transformations ) { double tx = im11()*x + im21()*y+idx(); double ty = im12()*x + im22()*y+idy(); *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5); *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5); } else { *rx = qRound( im11()*x + im21()*y + idx() ); *ry = qRound( im12()*x + im22()*y + idy() ); } #else *rx = x - xlatex; *ry = y - xlatey; #endif } /*! \internal Maps a rectangle from device coordinates to logical coordinates. Cannot handle rotation and/or shear. */ void QPainter::mapInv( int x, int y, int w, int h, int *rx, int *ry, int *rw, int *rh ) const { #ifndef QT_NO_TRANSFORMATIONS #if defined(QT_CHECK_STATE) if ( !txinv || txop == TxRotShear ) qWarning( "QPainter::mapInv: Internal error" ); #endif if ( qt_old_transformations ) { double tx = im11()*x + idx(); double ty = im22()*y + idy(); double tw = im11()*w; double th = im22()*h; *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5); *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5); *rw = tw >= 0 ? int(tw + 0.5) : int(tw - 0.5); *rh = th >= 0 ? int(th + 0.5) : int(th - 0.5); } else { *rx = qRound( im11()*x + idx() ); *ry = qRound( im22()*y + idy() ); *rw = qRound( im11()*w ); *rh = qRound( im22()*h ); } #else *rx = x - xlatex; *ry = y - xlatey; *rw = w; *rh = h; #endif } /*! Returns the point \a pv transformed from model coordinates to device coordinates. \sa xFormDev(), QWMatrix::map() */ QPoint QPainter::xForm( const QPoint &pv ) const { #ifndef QT_NO_TRANSFORMATIONS if ( txop == TxNone ) return pv; int x=pv.x(), y=pv.y(); map( x, y, &x, &y ); return QPoint( x, y ); #else return QPoint( pv.x()+xlatex, pv.y()+xlatey ); #endif } /*! \overload Returns the rectangle \a 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. \sa xFormDev(), QWMatrix::map() */ QRect QPainter::xForm( const QRect &rv ) const { #ifndef QT_NO_TRANSFORMATIONS if ( txop == TxNone ) return rv; if ( txop == TxRotShear ) { // rotation/shear return xmat.mapRect( rv ); } // Just translation/scale int x, y, w, h; rv.rect( &x, &y, &w, &h ); map( x, y, w, h, &x, &y, &w, &h ); return QRect( x, y, w, h ); #else return QRect( rv.x()+xlatex, rv.y()+xlatey, rv.width(), rv.height() ); #endif } /*! \overload Returns the point array \a av transformed from model coordinates to device coordinates. \sa xFormDev(), QWMatrix::map() */ QPointArray QPainter::xForm( const QPointArray &av ) const { QPointArray a = av; #ifndef QT_NO_TRANSFORMATIONS if ( txop != TxNone ) { return xmat * av; } #else a.translate( xlatex, xlatey ); #endif return a; } /*! \overload Returns the point array \a av transformed from model coordinates to device coordinates. The \a index is the first point in the array and \a npoints denotes the number of points to be transformed. If \a npoints is negative, all points from \a 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: \code QPointArray a(10); QPointArray b; b = painter.xForm(a, 2, 4); // b.size() == 4 b = painter.xForm(a, 2, -1); // b.size() == 8 \endcode \sa xFormDev(), QWMatrix::map() */ QPointArray QPainter::xForm( const QPointArray &av, int index, int npoints ) const { int lastPoint = npoints < 0 ? av.size() : index+npoints; QPointArray a( lastPoint-index ); memcpy( a.data(), av.data()+index, (lastPoint-index)*sizeof( QPoint ) ); #ifndef QT_NO_TRANSFORMATIONS return xmat*a; #else a.translate( xlatex, xlatey ); return a; #endif } /*! \overload Returns the point \a pd transformed from device coordinates to model coordinates. \sa xForm(), QWMatrix::map() */ QPoint QPainter::xFormDev( const QPoint &pd ) const { #ifndef QT_NO_TRANSFORMATIONS if ( txop == TxNone ) return pd; if ( !txinv ) { QPainter *that = (QPainter*)this; // mutable that->updateInvXForm(); } #endif int x=pd.x(), y=pd.y(); mapInv( x, y, &x, &y ); return QPoint( x, y ); } /*! Returns the rectangle \a 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. \sa xForm(), QWMatrix::map() */ QRect QPainter::xFormDev( const QRect &rd ) const { #ifndef QT_NO_TRANSFORMATIONS if ( txop == TxNone ) return rd; if ( !txinv ) { QPainter *that = (QPainter*)this; // mutable that->updateInvXForm(); } if ( txop == TxRotShear ) { // rotation/shear return ixmat.mapRect( rd ); } #endif // Just translation/scale int x, y, w, h; rd.rect( &x, &y, &w, &h ); mapInv( x, y, w, h, &x, &y, &w, &h ); return QRect( x, y, w, h ); } /*! \overload Returns the point array \a ad transformed from device coordinates to model coordinates. \sa xForm(), QWMatrix::map() */ QPointArray QPainter::xFormDev( const QPointArray &ad ) const { #ifndef QT_NO_TRANSFORMATIONS if ( txop == TxNone ) return ad; if ( !txinv ) { QPainter *that = (QPainter*)this; // mutable that->updateInvXForm(); } return ixmat * ad; #else // ### return ad; #endif } /*! \overload Returns the point array \a ad transformed from device coordinates to model coordinates. The \a index is the first point in the array and \a npoints denotes the number of points to be transformed. If \a npoints is negative, all points from \a 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: \code QPointArray a(10); QPointArray b; b = painter.xFormDev(a, 1, 3); // b.size() == 3 b = painter.xFormDev(a, 1, -1); // b.size() == 9 \endcode \sa xForm(), QWMatrix::map() */ QPointArray QPainter::xFormDev( const QPointArray &ad, int index, int npoints ) const { int lastPoint = npoints < 0 ? ad.size() : index+npoints; QPointArray a( lastPoint-index ); memcpy( a.data(), ad.data()+index, (lastPoint-index)*sizeof( QPoint ) ); #ifndef QT_NO_TRANSFORMATIONS if ( txop == TxNone ) return a; if ( !txinv ) { QPainter *that = (QPainter*)this; // mutable that->updateInvXForm(); } return ixmat * a; #else // ### return a; #endif } /*! Fills the rectangle \a (x, y, w, h) with the \a brush. You can specify a QColor as \a brush, since there is a QBrush constructor that takes a QColor argument and creates a solid pattern brush. \sa drawRect() */ void QPainter::fillRect( int x, int y, int w, int h, const QBrush &brush ) { QPen oldPen = pen(); // save pen QBrush oldBrush = this->brush(); // save brush setPen( NoPen ); setBrush( brush ); drawRect( x, y, w, h ); // draw filled rect setBrush( oldBrush ); // restore brush setPen( oldPen ); // restore pen } /*! \overload void QPainter::setBrushOrigin( const QPoint &p ) Sets the brush origin to point \a p. */ /*! \overload void QPainter::setWindow( const QRect &r ) Sets the painter's window to rectangle \a r. */ /*! \overload void QPainter::setViewport( const QRect &r ) Sets the painter's viewport to rectangle \a r. */ /*! \fn bool QPainter::hasClipping() const Returns TRUE if clipping has been set; otherwise returns FALSE. \sa setClipping() */ /*! Returns the currently set clip region. Note that the clip region is given in physical device coordinates and \e not subject to any \link coordsys.html coordinate transformation \endlink if \a m is equal to \c CoordDevice (the default). If \a m equals \c CoordPainter the returned region is in model coordinates. \sa setClipRegion(), setClipRect(), setClipping() QPainter::CoordinateMode */ QRegion QPainter::clipRegion( CoordinateMode m ) const { // ### FIXME in 4.0: // If the transformation mode is CoordPainter, we should transform the // clip region with painter transformations. #ifndef QT_NO_TRANSFORMATIONS QRegion r; if ( m == CoordDevice ) { r = crgn; } else { if ( !txinv ) { QPainter *that = (QPainter*)this; // mutable that->updateInvXForm(); } r = ixmat * crgn; } return r; #else return crgn; #endif } /*! \fn void QPainter::setClipRect( int x, int y, int w, int h, CoordinateMode m) Sets the clip region to the rectangle \a x, \a y, \a w, \a h and enables clipping. The clip mode is set to \a m. If \a m is \c CoordDevice (the default), the coordinates given for the clip region are taken to be physical device coordinates and are \e not subject to any \link coordsys.html coordinate transformations\endlink. If \a m is \c CoordPainter, the coordinates given for the clip region are taken to be model coordinates. \sa setClipRegion(), clipRegion(), setClipping() QPainter::CoordinateMode */ /*! \overload void QPainter::drawPoint( const QPoint &p ) Draws the point \a p. */ /*! \overload void QPainter::moveTo( const QPoint &p ) Moves to the point \a p. */ /*! \overload void QPainter::lineTo( const QPoint &p ) Draws a line to the point \a p. */ /*! \overload void QPainter::drawLine( const QPoint &p1, const QPoint &p2 ) Draws a line from point \a p1 to point \a p2. */ /*! \overload void QPainter::drawRect( const QRect &r ) Draws the rectangle \a r. */ /*! \overload void QPainter::drawWinFocusRect( const QRect &r ) Draws rectangle \a r as a window focus rectangle. */ /*! \overload void QPainter::drawWinFocusRect( const QRect &r, const QColor &bgColor ) Draws rectangle \a r as a window focus rectangle using background color \a bgColor. */ #if !defined(Q_WS_X11) && !defined(Q_WS_QWS) && !defined(Q_WS_MAC) // The doc and X implementation of this functions is in qpainter_x11.cpp void QPainter::drawWinFocusRect( int, int, int, int, bool, const QColor & ) { // do nothing, only called from X11 specific functions } #endif /*! \overload void QPainter::drawRoundRect( const QRect &r, int xRnd, int yRnd ) Draws a rounded rectangle \a r, rounding to the x position \a xRnd and the y position \a yRnd on each corner. */ /*! \overload void QPainter::drawEllipse( const QRect &r ) Draws the ellipse that fits inside rectangle \a r. */ /*! \overload void QPainter::drawArc( const QRect &r, int a, int alen ) Draws the arc that fits inside the rectangle \a r with start angle \a a and arc length \a alen. */ /*! \overload void QPainter::drawPie( const QRect &r, int a, int alen ) Draws a pie segment that fits inside the rectangle \a r with start angle \a a and arc length \a alen. */ /*! \overload void QPainter::drawChord( const QRect &r, int a, int alen ) Draws a chord that fits inside the rectangle \a r with start angle \a a and arc length \a alen. */ /*! \overload void QPainter::drawPixmap( const QPoint &p, const QPixmap &pm, const QRect &sr ) Draws the rectangle \a sr of pixmap \a pm with its origin at point \a p. */ /*! \overload void QPainter::drawPixmap( const QPoint &p, const QPixmap &pm ) Draws the pixmap \a pm with its origin at point \a p. */ void QPainter::drawPixmap( const QPoint &p, const QPixmap &pm ) { drawPixmap( p.x(), p.y(), pm, 0, 0, pm.width(), pm.height() ); } #if !defined(QT_NO_IMAGE_SMOOTHSCALE) || !defined(QT_NO_PIXMAP_TRANSFORMATION) /*! \overload Draws the pixmap \a pm into the rectangle \a r. The pixmap is scaled to fit the rectangle, if image and rectangle size disagree. */ void QPainter::drawPixmap( const QRect &r, const QPixmap &pm ) { int rw = r.width(); int rh = r.height(); int iw= pm.width(); int ih = pm.height(); if ( rw <= 0 || rh <= 0 || iw <= 0 || ih <= 0 ) return; bool scale = ( rw != iw || rh != ih ); float scaleX = (float)rw/(float)iw; float scaleY = (float)rh/(float)ih; bool smooth = ( scaleX < 1.5 || scaleY < 1.5 ); if ( testf(ExtDev) ) { QPDevCmdParam param[2]; param[0].rect = &r; param[1].pixmap = ± #if defined(Q_WS_WIN) if ( !pdev->cmd( QPaintDevice::PdcDrawPixmap, this, param ) || !hdc ) return; #elif defined(Q_WS_QWS) pdev->cmd( QPaintDevice::PdcDrawPixmap, this, param ); return; #elif defined(Q_WS_MAC) if ( !pdev->cmd( QPaintDevice::PdcDrawPixmap, this, param ) || !pdev->handle()) return; #else if ( !pdev->cmd( QPaintDevice::PdcDrawPixmap, this, param ) || !hd ) return; #endif } QPixmap pixmap = pm; if ( scale ) { #ifndef QT_NO_IMAGE_SMOOTHSCALE # ifndef QT_NO_PIXMAP_TRANSFORMATION if ( smooth ) # endif { QImage i = pm.convertToImage(); pixmap = QPixmap( i.smoothScale( rw, rh ) ); } # ifndef QT_NO_PIXMAP_TRANSFORMATION else # endif #endif #ifndef QT_NO_PIXMAP_TRANSFORMATION { pixmap = pm.xForm( QWMatrix( scaleX, 0, 0, scaleY, 0, 0 ) ); } #endif } drawPixmap( r.x(), r.y(), pixmap ); } #endif /*! \overload void QPainter::drawImage( const QPoint &, const QImage &, const QRect &sr, int conversionFlags = 0 ); Draws the rectangle \a sr from the image at the given point. */ /* Draws at point \a p the \sr rect from image \a pm, using \a conversionFlags if the image needs to be converted to a pixmap. The default value for \a conversionFlags is 0; see convertFromImage() for information about what other values do. This function may convert \a 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. */ /*! Draws at (\a x, \a y) the \a sw by \a sh area of pixels from (\a sx, \a sy) in \a image, using \a conversionFlags if the image needs to be converted to a pixmap. The default value for \a conversionFlags is 0; see convertFromImage() for information about what other values do. This function may convert \a 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. \sa drawPixmap() QPixmap::convertFromImage() */ void QPainter::drawImage( int x, int y, const QImage & image, int sx, int sy, int sw, int sh, int conversionFlags ) { #ifdef Q_WS_QWS //### Hackish # ifndef QT_NO_TRANSFORMATIONS if ( !image.isNull() && gfx && (txop==TxNone||txop==TxTranslate) && !testf(ExtDev) ) # else if ( !image.isNull() && gfx && !testf(ExtDev) ) # endif { if(sw<0) sw=image.width(); if(sh<0) sh=image.height(); QImage image2 = qt_screen->mapToDevice( image ); // This is a bit dubious if(image2.depth()==1) { image2.setNumColors( 2 ); image2.setColor( 0, qRgb(255,255,255) ); image2.setColor( 1, qRgb(0,0,0) ); } if ( image2.hasAlphaBuffer() ) gfx->setAlphaType(QGfx::InlineAlpha); else gfx->setAlphaType(QGfx::IgnoreAlpha); gfx->setSource(&image2); if ( testf(VxF|WxF) ) { map( x, y, &x, &y ); } gfx->blt(x,y,sw,sh,sx,sy); return; } #endif if ( !isActive() || image.isNull() ) return; // right/bottom if ( sw < 0 ) sw = image.width() - sx; if ( sh < 0 ) sh = image.height() - sy; // Sanity-check clipping if ( sx < 0 ) { x -= sx; sw += sx; sx = 0; } if ( sw + sx > image.width() ) sw = image.width() - sx; if ( sy < 0 ) { y -= sy; sh += sy; sy = 0; } if ( sh + sy > image.height() ) sh = image.height() - sy; if ( sw <= 0 || sh <= 0 ) return; bool all = image.rect().intersect(QRect(sx,sy,sw,sh)) == image.rect(); QImage subimage = all ? image : image.copy(sx,sy,sw,sh); if ( testf(ExtDev) ) { QPDevCmdParam param[2]; QRect r( x, y, subimage.width(), subimage.height() ); param[0].rect = &r; param[1].image = &subimage; #if defined(Q_WS_WIN) if ( !pdev->cmd( QPaintDevice::PdcDrawImage, this, param ) || !hdc ) return; #elif defined (Q_WS_QWS) pdev->cmd( QPaintDevice::PdcDrawImage, this, param ); return; #elif defined(Q_WS_MAC) if(!pdev->cmd( QPaintDevice::PdcDrawImage, this, param ) || !pdev->handle() ) return; #else if ( !pdev->cmd( QPaintDevice::PdcDrawImage, this, param ) || !hd ) return; #endif } QPixmap pm; pm.convertFromImage( subimage, conversionFlags ); drawPixmap( x, y, pm ); } /*! \overload void QPainter::drawImage( const QPoint &p, const QImage &i, int conversion_flags ) Draws the image \a i at point \a 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 \a conversion_flags to specify how you'd prefer this to happen. \sa Qt::ImageConversionFlags */ void QPainter::drawImage( const QPoint & p, const QImage & i, int conversion_flags ) { drawImage(p, i, i.rect(), conversion_flags); } #if !defined(QT_NO_IMAGE_TRANSFORMATION) || !defined(QT_NO_IMAGE_SMOOTHSCALE) /*! \overload Draws the image \a i into the rectangle \a r. The image will be scaled to fit the rectangle if image and rectangle dimensions differ. */ void QPainter::drawImage( const QRect &r, const QImage &i ) { int rw = r.width(); int rh = r.height(); int iw= i.width(); int ih = i.height(); if ( rw <= 0 || rh <= 0 || iw <= 0 || ih <= 0 ) return; if ( testf(ExtDev) ) { QPDevCmdParam param[2]; param[0].rect = &r; param[1].image = &i; #if defined(Q_WS_WIN) if ( !pdev->cmd( QPaintDevice::PdcDrawImage, this, param ) || !hdc ) return; #elif defined(Q_WS_QWS) pdev->cmd( QPaintDevice::PdcDrawImage, this, param ); return; #elif defined(Q_WS_MAC) if ( !pdev->cmd( QPaintDevice::PdcDrawImage, this, param ) || !pdev->handle() ) return; #else if ( !pdev->cmd( QPaintDevice::PdcDrawImage, this, param ) || !hd ) return; #endif } bool scale = ( rw != iw || rh != ih ); float scaleX = (float)rw/(float)iw; float scaleY = (float)rh/(float)ih; bool smooth = ( scaleX < 1.5 || scaleY < 1.5 ); QImage img = scale ? ( #if defined(QT_NO_IMAGE_TRANSFORMATION) i.smoothScale( rw, rh ) #elif defined(QT_NO_IMAGE_SMOOTHSCALE) i.scale( rw, rh ) #else smooth ? i.smoothScale( rw, rh ) : i.scale( rw, rh ) #endif ) : i; drawImage( r.x(), r.y(), img ); } #endif void bitBlt( QPaintDevice *dst, int dx, int dy, const QImage *src, int sx, int sy, int sw, int sh, int conversion_flags ) { QPixmap tmp; if ( sx == 0 && sy == 0 && (sw<0 || sw==src->width()) && (sh<0 || sh==src->height()) ) { tmp.convertFromImage( *src, conversion_flags ); } else { tmp.convertFromImage( src->copy( sx, sy, sw, sh, conversion_flags), conversion_flags ); } bitBlt( dst, dx, dy, &tmp ); } /*! \overload void QPainter::drawTiledPixmap( const QRect &r, const QPixmap &pm, const QPoint &sp ) Draws a tiled pixmap, \a pm, inside rectangle \a r with its origin at point \a sp. */ /*! \overload void QPainter::drawTiledPixmap( const QRect &r, const QPixmap &pm ) Draws a tiled pixmap, \a pm, inside rectangle \a r. */ /*! \overload void QPainter::fillRect( const QRect &r, const QBrush &brush ) Fills the rectangle \a r using brush \a brush. */ /*! \fn void QPainter::eraseRect( int x, int y, int w, int h ) Erases the area inside \a x, \a y, \a w, \a h. Equivalent to \c{fillRect( x, y, w, h, backgroundColor() )}. */ /*! \overload void QPainter::eraseRect( const QRect &r ) Erases the area inside the rectangle \a r. */ /*! \fn QPainter::drawText( int x, int y, const QString &, int len = -1, TextDirection dir = Auto ) \overload Draws the given text at position \a x, \a y. If \a len is -1 (the default) all the text is drawn, otherwise the first \a len characters are drawn. The text's direction is given by \a dir. \sa QPainter::TextDirection */ /*! \fn void QPainter::drawText( int x, int y, int w, int h, int flags, const QString&, int len = -1, QRect *br=0, QTextParag **internal=0 ) \overload Draws the given text within the rectangle starting at \a x, \a y, with width \a w and height \a h. If \a len is -1 (the default) all the text is drawn, otherwise the first \a len characters are drawn. The text's flags that are given in the \a flags parameter are \l{Qt::AlignmentFlags} and \l{Qt::TextFlags} OR'd together. \a br (if not null) is set to the actual bounding rectangle of the output. The \a internal parameter is for internal use only. */ /*! \fn void QPainter::drawText( const QPoint &, const QString &, int len = -1, TextDirection dir = Auto ); \overload Draws the text at the given point. \sa QPainter::TextDirection */ /* Draws the text in \a s at point \a p. If \a len is -1 the entire string is drawn, otherwise just the first \a len characters. The text's direction is specified by \a dir. */ /*! \fn void QPainter::drawText( int x, int y, const QString &, int pos, int len, TextDirection dir = Auto ); \overload Draws the text from position \a pos, at point \a (x, y). If \a len is -1 the entire string is drawn, otherwise just the first \a len characters. The text's direction is specified by \a dir. */ /*! \fn void QPainter::drawText( const QPoint &p, const QString &, int pos, int len, TextDirection dir = Auto ); Draws the text from position \a pos, at point \a p. If \a len is -1 the entire string is drawn, otherwise just the first \a len characters. The text's direction is specified by \a dir. Note that the meaning of \e y is not the same for the two drawText() varieties. For overloads that take a simple \e x, \e y pair (or a point), the \e y value is the text's baseline; for overloads that take a rectangle, \e rect.y() is the top of the rectangle and the text is aligned within that rectangle in accordance with the alignment flags. \sa QPainter::TextDirection */ /*! \fn void QPainter::drawTextItem(const QPoint &, const QTextItem &, int) \internal */ static inline void fix_neg_rect( int *x, int *y, int *w, int *h ) { if ( *w < 0 ) { *w = -*w + 2; *x -= *w - 1; } if ( *h < 0 ) { *h = -*h + 2; *y -= *h - 1; } } void QPainter::fix_neg_rect( int *x, int *y, int *w, int *h ) { ::fix_neg_rect(x,y,w,h); } // // The drawText function takes two special parameters; 'internal' and 'brect'. // // The 'internal' parameter contains a pointer to an array of encoded // information that keeps internal geometry data. // If the drawText function is called repeatedly to display the same text, // it makes sense to calculate text width and linebreaks the first time, // and use these parameters later to print the text because we save a lot of // CPU time. // The 'internal' parameter will not be used if it is a null pointer. // The 'internal' parameter will be generated if it is not null, but points // to a null pointer, i.e. internal != 0 && *internal == 0. // The 'internal' parameter will be used if it contains a non-null pointer. // // If the 'brect parameter is a non-null pointer, then the bounding rectangle // of the text will be returned in 'brect'. // /*! \overload Draws at most \a len characters from \a str in the rectangle \a r. This function draws formatted text. The \a tf text format is really of type \l Qt::AlignmentFlags and \l Qt::TextFlags OR'd together. Horizontal alignment defaults to AlignAuto and vertical alignment defaults to AlignTop. \a brect (if not null) is set to the actual bounding rectangle of the output. \a internal is, yes, internal. \sa boundingRect() */ void QPainter::drawText( const QRect &r, int tf, const QString& str, int len, QRect *brect, QTextParag **internal ) { if ( !isActive() ) return; if ( len < 0 ) len = str.length(); if ( len == 0 ) // empty string return; if ( testf(DirtyFont|ExtDev) ) { if ( testf(DirtyFont) ) updateFont(); if ( testf(ExtDev) && (tf & DontPrint) == 0 ) { QPDevCmdParam param[3]; QString newstr = str; newstr.truncate( len ); param[0].rect = &r; param[1].ival = tf; param[2].str = &newstr; if ( pdev->devType() != QInternal::Printer ) { #if defined(Q_WS_WIN) if ( !pdev->cmd( QPaintDevice::PdcDrawText2Formatted, this, param) || !hdc ) return; // QPrinter wants PdcDrawText2 #elif defined(Q_WS_QWS) pdev->cmd( QPaintDevice::PdcDrawText2Formatted, this, param); return; #elif defined(Q_WS_MAC) if ( !pdev->cmd( QPaintDevice::PdcDrawText2Formatted, this, param) || !pdev->handle()) return; // QPrinter wants PdcDrawText2 #else if ( !pdev->cmd( QPaintDevice::PdcDrawText2Formatted, this, param) || !hd ) return; // QPrinter wants PdcDrawText2 #endif } } } qt_format_text(font(), r, tf, str, len, brect, tabstops, tabarray, tabarraylen, internal, this); } //#define QT_FORMAT_TEXT_DEBUG #define QChar_linesep QChar(0x2028U) void qt_format_text( const QFont& font, const QRect &_r, int tf, const QString& str, int len, QRect *brect, int tabstops, int* tabarray, int tabarraylen, QTextParag **, QPainter* painter ) { // we need to copy r here to protect against the case (&r == brect). QRect r( _r ); bool dontclip = (tf & Qt::DontClip) == Qt::DontClip; bool wordbreak = (tf & Qt::WordBreak) == Qt::WordBreak; bool singleline = (tf & Qt::SingleLine) == Qt::SingleLine; bool showprefix = (tf & Qt::ShowPrefix) == Qt::ShowPrefix; bool noaccel = ( tf & Qt::NoAccel ) == Qt::NoAccel; bool isRightToLeft = str.isRightToLeft(); if ( ( tf & Qt::AlignHorizontal_Mask ) == Qt::AlignAuto ) tf |= isRightToLeft ? Qt::AlignRight : Qt::AlignLeft; bool expandtabs = ( (tf & Qt::ExpandTabs) && ( ( (tf & Qt::AlignLeft) && !isRightToLeft ) || ( (tf & Qt::AlignRight) && isRightToLeft ) ) ); if ( !painter ) tf |= Qt::DontPrint; int maxUnderlines = 0; int numUnderlines = 0; int underlinePositionStack[32]; int *underlinePositions = underlinePositionStack; QFont fnt(painter ? (painter->pfont ? *painter->pfont : painter->cfont) : font); QFontMetrics fm( fnt ); QString text = str; // str.setLength() always does a deep copy, so the replacement // code below is safe. text.setLength( len ); // compatible behaviour to the old implementation. Replace // tabs by spaces QChar *chr = (QChar*)text.unicode(); const QChar *end = chr + len; bool haveLineSep = FALSE; while ( chr != end ) { if ( *chr == '\r' || ( singleline && *chr == '\n' ) ) { *chr = ' '; } else if ( *chr == '\n' ) { *chr = QChar_linesep; haveLineSep = TRUE; } else if ( *chr == '&' ) { ++maxUnderlines; } ++chr; } if ( !expandtabs ) { chr = (QChar*)text.unicode(); while ( chr != end ) { if ( *chr == '\t' ) *chr = ' '; ++chr; } } else if (!tabarraylen && !tabstops) { tabstops = fm.width('x')*8; } if ( noaccel || showprefix ) { if ( maxUnderlines > 32 ) underlinePositions = new int[maxUnderlines]; QChar *cout = (QChar*)text.unicode(); QChar *cin = cout; int l = len; while ( l ) { if ( *cin == '&' ) { ++cin; --l; if ( !l ) break; if ( *cin != '&' ) underlinePositions[numUnderlines++] = cout - text.unicode(); } *cout = *cin; ++cout; ++cin; --l; } uint newlen = cout - text.unicode(); if ( newlen != text.length()) text.setLength( newlen ); } // no need to do extra work for underlines if we don't paint if ( tf & Qt::DontPrint ) numUnderlines = 0; int height = 0; int left = r.width(); int right = 0; QTextLayout textLayout( text, fnt ); int rb = QMAX( 0, -fm.minRightBearing() ); int lb = QMAX( 0, -fm.minLeftBearing() ); if ( text.isEmpty() ) { height = fm.height(); left = right = 0; tf |= QPainter::DontPrint; } else { textLayout.beginLayout((haveLineSep || expandtabs || wordbreak) ? QTextLayout::MultiLine : (tf & Qt::DontPrint) ? QTextLayout::NoBidi : QTextLayout::SingleLine ); // break underline chars into items of their own for( int i = 0; i < numUnderlines; i++ ) { textLayout.setBoundary( underlinePositions[i] ); textLayout.setBoundary( underlinePositions[i]+1 ); } int lineWidth = wordbreak ? QMAX(0, r.width()-rb-lb) : INT_MAX; if(!wordbreak) tf |= Qt::IncludeTrailingSpaces; int leading = fm.leading(); int asc = fm.ascent(); int desc = fm.descent(); height = -leading; //qDebug("\n\nbeginLayout: lw = %d, rectwidth=%d", lineWidth , r.width()); while ( !textLayout.atEnd() ) { height += leading; textLayout.beginLine( lineWidth == INT_MAX ? lineWidth : lineWidth ); //qDebug("-----beginLine( %d )-----", lineWidth ); bool linesep = FALSE; while ( 1 ) { QTextItem ti = textLayout.currentItem(); //qDebug("item: from=%d, ch=%x", ti.from(), text.unicode()[ti.from()].unicode() ); if ( expandtabs && ti.isTab() ) { int tw = 0; int x = textLayout.widthUsed(); if ( tabarraylen ) { // qDebug("tabarraylen=%d", tabarraylen ); int tab = 0; while ( tab < tabarraylen ) { if ( tabarray[tab] > x ) { tw = tabarray[tab] - x; break; } ++tab; } } else { tw = tabstops - (x % tabstops); } //qDebug("tw = %d", tw ); if ( tw ) ti.setWidth( tw ); } if ( ti.isObject() && text.unicode()[ti.from()] == QChar_linesep ) linesep = TRUE; if ( linesep || textLayout.addCurrentItem() != QTextLayout::Ok || textLayout.atEnd() ) break; } int ascent = asc, descent = desc, lineLeft, lineRight; textLayout.setLineWidth( r.width()-rb-lb ); textLayout.endLine( 0, height, tf, &ascent, &descent, &lineLeft, &lineRight ); //qDebug("finalizing line: lw=%d ascent = %d, descent=%d lineleft=%d lineright=%d", lineWidth, ascent, descent,lineLeft, lineRight ); left = QMIN( left, lineLeft ); right = QMAX( right, lineRight ); height += ascent + descent + 1; if ( linesep ) textLayout.nextItem(); } } int yoff = 0; if ( tf & Qt::AlignBottom ) yoff = r.height() - height; else if ( tf & Qt::AlignVCenter ) yoff = (r.height() - height)/2; if ( brect ) { *brect = QRect( r.x() + left, r.y() + yoff, right-left + lb+rb, height ); //qDebug("br = %d %d %d/%d, left=%d, right=%d", brect->x(), brect->y(), brect->width(), brect->height(), left, right); } if (!(tf & QPainter::DontPrint)) { bool restoreClipping = FALSE; bool painterHasClip = FALSE; QRegion painterClipRegion; if ( !dontclip ) { #ifndef QT_NO_TRANSFORMATIONS QRegion reg = painter->xmat * r; #else QRegion reg = r; reg.translate( painter->xlatex, painter->xlatey ); #endif if ( painter->hasClipping() ) reg &= painter->clipRegion(); painterHasClip = painter->hasClipping(); painterClipRegion = painter->clipRegion(); restoreClipping = TRUE; painter->setClipRegion( reg ); } else { if ( painter->hasClipping() ){ painterHasClip = painter->hasClipping(); painterClipRegion = painter->clipRegion(); restoreClipping = TRUE; painter->setClipping( FALSE ); } } int cUlChar = 0; int _tf = 0; if (fnt.underline()) _tf |= Qt::Underline; if (fnt.overline()) _tf |= Qt::Overline; if (fnt.strikeOut()) _tf |= Qt::StrikeOut; //qDebug("have %d items",textLayout.numItems()); for ( int i = 0; i < textLayout.numItems(); i++ ) { QTextItem ti = textLayout.itemAt( i ); //qDebug("Item %d: from=%d, length=%d, space=%d x=%d", i, ti.from(), ti.length(), ti.isSpace(), ti.x() ); if ( ti.isTab() || ti.isObject() ) continue; int textFlags = _tf; if ( !noaccel && numUnderlines > cUlChar && ti.from() == underlinePositions[cUlChar] ) { textFlags |= Qt::Underline; cUlChar++; } #if defined(Q_WS_X11) || defined(Q_WS_QWS) if ( painter->bg_mode == Qt::OpaqueMode ) { int h = ti.ascent() + ti.descent() + 1; if (ti.y() + h < height) // don't add leading to last line h += fm.leading(); qt_draw_background( painter, r.x()+lb + ti.x(), r.y() + yoff + ti.y() - ti.ascent(), ti.width(), h); } #endif painter->drawTextItem( r.x()+lb, r.y() + yoff, ti, textFlags ); } if ( restoreClipping ) { painter->setClipRegion( painterClipRegion ); painter->setClipping( painterHasClip ); } } if ( underlinePositions != underlinePositionStack ) delete [] underlinePositions; } /*! \overload Returns the bounding rectangle of the aligned text that would be printed with the corresponding drawText() function using the first \a len characters from \a str if \a len is > -1, or the whole of \a str if \a len is -1. The drawing, and hence the bounding rectangle, is constrained to the rectangle \a r, or to the rectangle required to draw the text, whichever is the larger. The \a internal parameter should not be used. \sa drawText(), fontMetrics(), QFontMetrics::boundingRect(), Qt::TextFlags */ QRect QPainter::boundingRect( const QRect &r, int flags, const QString& str, int len, QTextParag **internal ) { QRect brect; if ( str.isEmpty() ) brect.setRect( r.x(),r.y(), 0,0 ); else drawText( r, flags | DontPrint, str, len, &brect, internal ); return brect; } /*! \fn 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 \a len characters of the string if \a len is > -1, or the whole of the string if \a len is -1. The drawing, and hence the bounding rectangle, is constrained to the rectangle that begins at point \a (x, y) with width \a w and hight \a h, or to the rectangle required to draw the text, whichever is the larger. The \a flags argument is the bitwise OR of the following flags: \table \header \i Flag \i Meaning \row \i \c AlignAuto \i aligns according to the language, usually left. \row \i \c AlignLeft \i aligns to the left border. \row \i \c AlignRight \i aligns to the right border. \row \i \c AlignHCenter \i aligns horizontally centered. \row \i \c AlignTop \i aligns to the top border. \row \i \c AlignBottom \i aligns to the bottom border. \row \i \c AlignVCenter \i aligns vertically centered. \row \i \c AlignCenter \i (== \c AlignHCenter | \c AlignVCenter). \row \i \c SingleLine \i ignores newline characters in the text. \row \i \c ExpandTabs \i expands tabs. \row \i \c ShowPrefix \i interprets "&x" as "x". \row \i \c WordBreak \i breaks the text to fit the rectangle. \endtable Horizontal alignment defaults to \c AlignLeft and vertical alignment defaults to \c AlignTop. If several of the horizontal or several of the vertical alignment flags are set, the resulting alignment is undefined. The \a intern parameter should not be used. \sa Qt::TextFlags */ /***************************************************************************** QPen member functions *****************************************************************************/ /*! \class QPen qpen.h \brief The QPen class defines how a QPainter should draw lines and outlines of shapes. \ingroup graphics \ingroup images \ingroup shared \mainclass A pen has a style, width, color, cap style and join style. The pen style defines the line type. The default pen style is \c Qt::SolidLine. Setting the style to \c NoPen tells the painter to not draw lines or outlines. When drawing 1 pixel wide diagonal lines you can either use a very fast algorithm (specified by a line width of 0, which is the default), or a slower but more accurate algorithm (specified by a line width of 1). For horizontal and vertical lines a line width of 0 is the same as a line width of 1. The cap and join style have no effect on 0-width lines. The pen color defines the color of lines and text. The default line color is black. The QColor documentation lists predefined colors. The cap style defines how the end points of lines are drawn. The join style defines how the joins between two lines are drawn when multiple connected lines are drawn (QPainter::drawPolyline() etc.). The cap and join styles only apply to wide lines, i.e. when the width is 1 or greater. Use the QBrush class to specify fill styles. Example: \code QPainter painter; QPen pen( red, 2 ); // red solid line, 2 pixels wide painter.begin( &anyPaintDevice ); // paint something painter.setPen( pen ); // set the red, wide pen painter.drawRect( 40,30, 200,100 ); // draw a rectangle painter.setPen( blue ); // set blue pen, 0 pixel width painter.drawLine( 40,30, 240,130 ); // draw a diagonal in rectangle painter.end(); // painting done \endcode See the \l Qt::PenStyle enum type for a complete list of pen styles. With reference to the end points of lines, for wide (non-0-width) pens it depends on the cap style whether the end point is drawn or not. QPainter will try to make sure that the end point is drawn for 0-width pens, but this cannot be absolutely guaranteed because the underlying drawing engine is free to use any (typically accelerated) algorithm for drawing 0-width lines. On all tested systems, however, the end point of at least all non-diagonal lines are drawn. A pen's color(), width(), style(), capStyle() and joinStyle() can be set in the constructor or later with setColor(), setWidth(), setStyle(), setCapStyle() and setJoinStyle(). Pens may also be compared and streamed. \img pen-styles.png Pen styles \sa QPainter, QPainter::setPen() */ /*! \internal Initializes the pen. */ void QPen::init( const QColor &color, uint width, uint linestyle ) { data = new QPenData; Q_CHECK_PTR( data ); data->style = (PenStyle)(linestyle & MPenStyle); data->width = width; data->color = color; data->linest = linestyle; } /*! Constructs a default black solid line pen with 0 width, which renders lines 1 pixel wide (fast diagonals). */ QPen::QPen() { init( Qt::black, 0, SolidLine ); // default pen } /*! Constructs a black pen with 0 width (fast diagonals) and style \a style. \sa setStyle() */ QPen::QPen( PenStyle style ) { init( Qt::black, 0, style ); } /*! Constructs a pen with the specified \a color, \a width and \a style. \sa setWidth(), setStyle(), setColor() */ QPen::QPen( const QColor &color, uint width, PenStyle style ) { init( color, width, style ); } /*! Constructs a pen with the specified color \a cl and width \a w. The pen style is set to \a s, the pen cap style to \a c and the pen join style to \a j. A line width of 0 will produce a 1 pixel wide line using a fast algorithm for diagonals. A line width of 1 will also produce a 1 pixel wide line, but uses a slower more accurate algorithm for diagonals. For horizontal and vertical lines a line width of 0 is the same as a line width of 1. The cap and join style have no effect on 0-width lines. \sa setWidth(), setStyle(), setColor() */ QPen::QPen( const QColor &cl, uint w, PenStyle s, PenCapStyle c, PenJoinStyle j ) { init( cl, w, s | c | j ); } /*! Constructs a pen that is a copy of \a p. */ QPen::QPen( const QPen &p ) { data = p.data; data->ref(); } /*! Destroys the pen. */ QPen::~QPen() { if ( data->deref() ) delete data; } /*! Detaches from shared pen data to make sure that this pen is the only one referring the data. If multiple pens share common data, this pen dereferences the data and gets a copy of the data. Nothing is done if there is just a single reference. */ void QPen::detach() { if ( data->count != 1 ) *this = copy(); } /*! Assigns \a p to this pen and returns a reference to this pen. */ QPen &QPen::operator=( const QPen &p ) { p.data->ref(); if ( data->deref() ) delete data; data = p.data; return *this; } /*! Returns a \link shclass.html deep copy\endlink of the pen. */ QPen QPen::copy() const { QPen p( data->color, data->width, data->style, capStyle(), joinStyle() ); return p; } /*! \fn PenStyle QPen::style() const Returns the pen style. \sa setStyle() */ /*! Sets the pen style to \a s. See the \l Qt::PenStyle documentation for a list of all the styles. \warning On Mac OS X the style setting (other than \c NoPen and \c SolidLine) have no effect as they are not implemented by the underlying system. \warning On Windows 95/98, the style setting (other than \c NoPen and \c SolidLine) has no effect for lines with width greater than 1. \sa style() */ void QPen::setStyle( PenStyle s ) { if ( data->style == s ) return; detach(); data->style = s; data->linest = (data->linest & ~MPenStyle) | s; } /*! \fn uint QPen::width() const Returns the pen width. \sa setWidth() */ /*! Sets the pen width to \a w. A line width of 0 will produce a 1 pixel wide line using a fast algorithm for diagonals. A line width of 1 will also produce a 1 pixel wide line, but uses a slower more accurate algorithm for diagonals. For horizontal and vertical lines a line width of 0 is the same as a line width of 1. The cap and join style have no effect on 0-width lines. \sa width() */ void QPen::setWidth( uint w ) { if ( data->width == w ) return; detach(); data->width = w; } /*! Returns the pen's cap style. \sa setCapStyle() */ Qt::PenCapStyle QPen::capStyle() const { return (PenCapStyle)(data->linest & MPenCapStyle); } /*! Sets the pen's cap style to \a c. The default value is \c FlatCap. The cap style has no effect on 0-width pens. \img pen-cap-styles.png Pen Cap Styles \warning On Windows 95/98 and Macintosh, the cap style setting has no effect. Wide lines are rendered as if the cap style was \c SquareCap. \sa capStyle() */ void QPen::setCapStyle( PenCapStyle c ) { if ( (data->linest & MPenCapStyle) == c ) return; detach(); data->linest = (data->linest & ~MPenCapStyle) | c; } /*! Returns the pen's join style. \sa setJoinStyle() */ Qt::PenJoinStyle QPen::joinStyle() const { return (PenJoinStyle)(data->linest & MPenJoinStyle); } /*! Sets the pen's join style to \a j. The default value is \c MiterJoin. The join style has no effect on 0-width pens. \img pen-join-styles.png Pen Join Styles \warning On Windows 95/98 and Macintosh, the join style setting has no effect. Wide lines are rendered as if the join style was \c BevelJoin. \sa joinStyle() */ void QPen::setJoinStyle( PenJoinStyle j ) { if ( (data->linest & MPenJoinStyle) == j ) return; detach(); data->linest = (data->linest & ~MPenJoinStyle) | j; } /*! \fn const QColor &QPen::color() const Returns the pen color. \sa setColor() */ /*! Sets the pen color to \a c. \sa color() */ void QPen::setColor( const QColor &c ) { detach(); data->color = c; } /*! \fn bool QPen::operator!=( const QPen &p ) const Returns TRUE if the pen is different from \a p; otherwise returns FALSE. Two pens are different if they have different styles, widths or colors. \sa operator==() */ /*! Returns TRUE if the pen is equal to \a p; otherwise returns FALSE. Two pens are equal if they have equal styles, widths and colors. \sa operator!=() */ bool QPen::operator==( const QPen &p ) const { return (p.data == data) || (p.data->linest == data->linest && p.data->width == data->width && p.data->color == data->color); } /***************************************************************************** QPen stream functions *****************************************************************************/ #ifndef QT_NO_DATASTREAM /*! \relates QPen Writes the pen \a p to the stream \a s and returns a reference to the stream. \sa \link datastreamformat.html Format of the QDataStream operators \endlink */ QDataStream &operator<<( QDataStream &s, const QPen &p ) { // ### width() should not be restricted to 8-bit values if ( s.version() < 3 ) return s << (Q_UINT8)p.style() << (Q_UINT8)p.width() << p.color(); else return s << (Q_UINT8)( p.style() | p.capStyle() | p.joinStyle() ) << (Q_UINT8)p.width() << p.color(); } /*! \relates QPen Reads a pen from the stream \a s into \a p and returns a reference to the stream. \sa \link datastreamformat.html Format of the QDataStream operators \endlink */ QDataStream &operator>>( QDataStream &s, QPen &p ) { Q_UINT8 style, width; QColor color; s >> style; s >> width; s >> color; p = QPen( color, (uint)width, (Qt::PenStyle)style ); // owl return s; } #endif //QT_NO_DATASTREAM /***************************************************************************** QBrush member functions *****************************************************************************/ /*! \class QBrush qbrush.h \brief The QBrush class defines the fill pattern of shapes drawn by a QPainter. \ingroup graphics \ingroup images \ingroup shared A brush has a style and a color. One of the brush styles is a custom pattern, which is defined by a QPixmap. The brush style defines the fill pattern. The default brush style is \c NoBrush (depending on how you construct a brush). This style tells the painter to not fill shapes. The standard style for filling is \c SolidPattern. The brush color defines the color of the fill pattern. The QColor documentation lists the predefined colors. Use the QPen class for specifying line/outline styles. Example: \code QPainter painter; QBrush brush( yellow ); // yellow solid pattern painter.begin( &anyPaintDevice ); // paint something painter.setBrush( brush ); // set the yellow brush painter.setPen( NoPen ); // do not draw outline painter.drawRect( 40,30, 200,100 ); // draw filled rectangle painter.setBrush( NoBrush ); // do not fill painter.setPen( black ); // set black pen, 0 pixel width painter.drawRect( 10,10, 30,20 ); // draw rectangle outline painter.end(); // painting done \endcode See the setStyle() function for a complete list of brush styles. \img brush-styles.png Brush Styles \sa QPainter, QPainter::setBrush(), QPainter::setBrushOrigin() */ /*! \internal Initializes the brush. */ void QBrush::init( const QColor &color, BrushStyle style ) { data = new QBrushData; Q_CHECK_PTR( data ); data->style = style; data->color = color; data->pixmap = 0; } /*! Constructs a default black brush with the style \c NoBrush (will not fill shapes). */ QBrush::QBrush() { static QBrushData* defBrushData = 0; if ( !defBrushData ) { static QSharedCleanupHandler defBrushCleanup; defBrushData = new QBrushData; defBrushData->style = NoBrush; defBrushData->color = Qt::black; defBrushData->pixmap = 0; defBrushCleanup.set( &defBrushData ); } data = defBrushData; data->ref(); } /*! Constructs a black brush with the style \a style. \sa setStyle() */ QBrush::QBrush( BrushStyle style ) { init( Qt::black, style ); } /*! Constructs a brush with the color \a color and the style \a style. \sa setColor(), setStyle() */ QBrush::QBrush( const QColor &color, BrushStyle style ) { init( color, style ); } /*! Constructs a brush with the color \a color and a custom pattern stored in \a pixmap. The color will only have an effect for monochrome pixmaps, i.e. for QPixmap::depth() == 1. Pixmap brushes are currently not supported when printing on X11. \sa setColor(), setPixmap() */ QBrush::QBrush( const QColor &color, const QPixmap &pixmap ) { init( color, CustomPattern ); setPixmap( pixmap ); } /*! Constructs a brush that is a \link shclass.html shallow copy\endlink of \a b. */ QBrush::QBrush( const QBrush &b ) { data = b.data; data->ref(); } /*! Destroys the brush. */ QBrush::~QBrush() { if ( data->deref() ) { delete data->pixmap; delete data; } } /*! Detaches from shared brush data to make sure that this brush is the only one referring the data. If multiple brushes share common data, this brush dereferences the data and gets a copy of the data. Nothing is done if there is just a single reference. */ void QBrush::detach() { if ( data->count != 1 ) *this = copy(); } /*! Assigns \a b to this brush and returns a reference to this brush. */ QBrush &QBrush::operator=( const QBrush &b ) { b.data->ref(); // beware of b = b if ( data->deref() ) { delete data->pixmap; delete data; } data = b.data; return *this; } /*! Returns a \link shclass.html deep copy\endlink of the brush. */ QBrush QBrush::copy() const { if ( data->style == CustomPattern ) { // brush has pixmap QBrush b( data->color, *data->pixmap ); return b; } else { // brush has std pattern QBrush b( data->color, data->style ); return b; } } /*! \fn BrushStyle QBrush::style() const Returns the brush style. \sa setStyle() */ /*! Sets the brush style to \a s. The brush styles are: \table \header \i Pattern \i Meaning \row \i NoBrush \i will not fill shapes (default). \row \i SolidPattern \i solid (100%) fill pattern. \row \i Dense1Pattern \i11 94% fill pattern. \row \i Dense2Pattern \i11 88% fill pattern. \row \i Dense3Pattern \i11 63% fill pattern. \row \i Dense4Pattern \i11 50% fill pattern. \row \i Dense5Pattern \i11 37% fill pattern. \row \i Dense6Pattern \i11 12% fill pattern. \row \i Dense7Pattern \i11 6% fill pattern. \row \i HorPattern \i horizontal lines pattern. \row \i VerPattern \i vertical lines pattern. \row \i CrossPattern \i crossing lines pattern. \row \i BDiagPattern \i diagonal lines (directed /) pattern. \row \i FDiagPattern \i diagonal lines (directed \) pattern. \row \i DiagCrossPattern \i diagonal crossing lines pattern. \row \i CustomPattern \i set when a pixmap pattern is being used. \endtable On Windows, dense and custom patterns cannot be transparent. See the \link #details Detailed Description\endlink for a picture of all the styles. \sa style() */ void QBrush::setStyle( BrushStyle s ) // set brush style { if ( data->style == s ) return; #if defined(QT_CHECK_RANGE) if ( s == CustomPattern ) qWarning( "QBrush::setStyle: CustomPattern is for internal use" ); #endif detach(); data->style = s; } /*! \fn const QColor &QBrush::color() const Returns the brush color. \sa setColor() */ /*! Sets the brush color to \a c. \sa color(), setStyle() */ void QBrush::setColor( const QColor &c ) { detach(); data->color = c; } /*! \fn QPixmap *QBrush::pixmap() const Returns a pointer to the custom brush pattern, or 0 if no custom brush pattern has been set. \sa setPixmap() */ /*! Sets the brush pixmap to \a pixmap. The style is set to \c CustomPattern. The current brush color will only have an effect for monochrome pixmaps, i.e. for QPixmap::depth() == 1. Pixmap brushes are currently not supported when printing on X11. \sa pixmap(), color() */ void QBrush::setPixmap( const QPixmap &pixmap ) { detach(); if ( data->pixmap ) delete data->pixmap; if ( pixmap.isNull() ) { data->style = NoBrush; data->pixmap = 0; } else { data->style = CustomPattern; data->pixmap = new QPixmap( pixmap ); if ( data->pixmap->optimization() == QPixmap::MemoryOptim ) data->pixmap->setOptimization( QPixmap::NormalOptim ); } } /*! \fn bool QBrush::operator!=( const QBrush &b ) const Returns TRUE if the brush is different from \a b; otherwise returns FALSE. Two brushes are different if they have different styles, colors or pixmaps. \sa operator==() */ /*! Returns TRUE if the brush is equal to \a b; otherwise returns FALSE. Two brushes are equal if they have equal styles, colors and pixmaps. \sa operator!=() */ bool QBrush::operator==( const QBrush &b ) const { return (b.data == data) || (b.data->style == data->style && b.data->color == data->color && b.data->pixmap == data->pixmap); } /*! \fn inline double QPainter::translationX() const \internal */ /*! \fn inline double QPainter::translationY() const \internal */ /***************************************************************************** QBrush stream functions *****************************************************************************/ #ifndef QT_NO_DATASTREAM /*! \relates QBrush Writes the brush \a b to the stream \a s and returns a reference to the stream. \sa \link datastreamformat.html Format of the QDataStream operators \endlink */ QDataStream &operator<<( QDataStream &s, const QBrush &b ) { s << (Q_UINT8)b.style() << b.color(); if ( b.style() == Qt::CustomPattern ) #ifndef QT_NO_IMAGEIO s << *b.pixmap(); #else qWarning("No Image Brush I/O"); #endif return s; } /*! \relates QBrush Reads the brush \a b from the stream \a s and returns a reference to the stream. \sa \link datastreamformat.html Format of the QDataStream operators \endlink */ QDataStream &operator>>( QDataStream &s, QBrush &b ) { Q_UINT8 style; QColor color; s >> style; s >> color; if ( style == Qt::CustomPattern ) { #ifndef QT_NO_IMAGEIO QPixmap pm; s >> pm; b = QBrush( color, pm ); #else qWarning("No Image Brush I/O"); #endif } else b = QBrush( color, (Qt::BrushStyle)style ); return s; } #endif // QT_NO_DATASTREAM