1 /****************************************************************************
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
7 ** This file is part of the QtGui module of the Qt Toolkit.
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
50 #include "qpaintdevice.h"
51 #include "qpaintengine.h"
53 #include "qpainter_p.h"
54 #include "qpainterpath.h"
56 #include "qpixmapcache.h"
58 #include "qtextlayout.h"
60 #include "qvarlengtharray.h"
61 #include "qstatictext.h"
62 #include "qglyphrun.h"
64 #include <private/qfontengine_p.h>
65 #include <private/qpaintengine_p.h>
66 #include <private/qemulationpaintengine_p.h>
67 #include <private/qpainterpath_p.h>
68 #include <private/qtextengine_p.h>
69 #include <private/qpaintengine_raster_p.h>
70 #include <private/qmath_p.h>
71 #include <private/qstatictext_p.h>
72 #include <private/qglyphrun_p.h>
73 #include <private/qhexstring_p.h>
74 #include <private/qguiapplication_p.h>
75 #include <private/qrawfont_p.h>
79 #define QGradient_StretchToDevice 0x10000000
80 #define QPaintEngine_OpaqueBackground 0x40000000
82 // #define QT_DEBUG_DRAW
84 bool qt_show_painter_debug_output = true;
87 extern QPixmap qt_pixmapForBrush(int style, bool invert);
89 void qt_format_text(const QFont &font,
90 const QRectF &_r, int tf, const QTextOption *option, const QString& str, QRectF *brect,
91 int tabstops, int* tabarray, int tabarraylen,
93 static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QFontEngine *fe,
94 QTextCharFormat::UnderlineStyle underlineStyle,
95 QTextItem::RenderFlags flags, qreal width,
96 const QTextCharFormat &charFormat);
97 // Helper function to calculate left most position, width and flags for decoration drawing
98 Q_GUI_EXPORT void qt_draw_decoration_for_glyphs(QPainter *painter, const glyph_t *glyphArray,
99 const QFixedPoint *positions, int glyphCount,
100 QFontEngine *fontEngine, const QFont &font,
101 const QTextCharFormat &charFormat);
103 static inline QGradient::CoordinateMode coordinateMode(const QBrush &brush)
105 switch (brush.style()) {
106 case Qt::LinearGradientPattern:
107 case Qt::RadialGradientPattern:
108 case Qt::ConicalGradientPattern:
109 return brush.gradient()->coordinateMode();
113 return QGradient::LogicalMode;
116 /* Returns true if the gradient requires stretch to device...*/
117 static inline bool check_gradient(const QBrush &brush)
119 return coordinateMode(brush) == QGradient::StretchToDeviceMode;
122 extern bool qHasPixmapTexture(const QBrush &);
124 static inline bool is_brush_transparent(const QBrush &brush) {
125 Qt::BrushStyle s = brush.style();
126 bool brushBitmap = qHasPixmapTexture(brush)
127 ? brush.texture().isQBitmap()
128 : (brush.textureImage().depth() == 1);
129 return ((s >= Qt::Dense1Pattern && s <= Qt::DiagCrossPattern)
130 || (s == Qt::TexturePattern && brushBitmap));
133 static inline bool is_pen_transparent(const QPen &pen) {
134 return pen.style() > Qt::SolidLine || is_brush_transparent(pen.brush());
137 /* Discards the emulation flags that are not relevant for line drawing
138 and returns the result
140 static inline uint line_emulation(uint emulation)
142 return emulation & (QPaintEngine::PrimitiveTransform
143 | QPaintEngine::AlphaBlend
144 | QPaintEngine::Antialiasing
145 | QPaintEngine::BrushStroke
146 | QPaintEngine::ConstantOpacity
147 | QGradient_StretchToDevice
148 | QPaintEngine::ObjectBoundingModeGradients
149 | QPaintEngine_OpaqueBackground);
153 static bool qt_painter_thread_test(int devType, const char *what, bool extraCondition = false)
156 case QInternal::Image:
157 case QInternal::Printer:
158 case QInternal::Picture:
159 // can be drawn onto these devices safely from any thread
166 if (QApplication::testAttribute(Qt::AA_X11InitThreads))
169 if (!extraCondition && QThread::currentThread() != qApp->thread()) {
170 qWarning("QPainter: It is not safe to use %s outside the GUI thread", what);
179 void QPainterPrivate::checkEmulation()
182 if (extended->flags() & QPaintEngineEx::DoNotEmulate)
185 bool doEmulation = false;
186 if (state->bgMode == Qt::OpaqueMode)
189 const QGradient *bg = state->brush.gradient();
190 if (bg && bg->coordinateMode() > QGradient::LogicalMode)
193 const QGradient *pg = qpen_brush(state->pen).gradient();
194 if (pg && pg->coordinateMode() > QGradient::LogicalMode)
198 if (extended != emulationEngine) {
199 if (!emulationEngine)
200 emulationEngine = new QEmulationPaintEngine(extended);
201 extended = emulationEngine;
202 extended->setState(state);
204 } else if (emulationEngine == extended) {
205 extended = emulationEngine->real_engine;
210 QPainterPrivate::~QPainterPrivate()
212 delete emulationEngine;
213 for (int i=0; i<states.size(); ++i)
221 QTransform QPainterPrivate::viewTransform() const
224 qreal scaleW = qreal(state->vw)/qreal(state->ww);
225 qreal scaleH = qreal(state->vh)/qreal(state->wh);
226 return QTransform(scaleW, 0, 0, scaleH,
227 state->vx - state->wx*scaleW, state->vy - state->wy*scaleH);
235 Returns true if using a shared painter; otherwise false.
237 bool QPainterPrivate::attachPainterPrivate(QPainter *q, QPaintDevice *pdev)
242 QPainter *sp = pdev->sharedPainter();
246 // Save the current state of the shared painter and assign
247 // the current d_ptr to the shared painter's d_ptr.
249 if (!sp->d_ptr->d_ptrs) {
250 // Allocate space for 4 d-pointers (enough for up to 4 sub-sequent
251 // redirections within the same paintEvent(), which should be enough
252 // in 99% of all cases). E.g: A renders B which renders C which renders D.
253 sp->d_ptr->d_ptrs_size = 4;
254 sp->d_ptr->d_ptrs = (QPainterPrivate **)malloc(4 * sizeof(QPainterPrivate *));
255 Q_CHECK_PTR(sp->d_ptr->d_ptrs);
256 } else if (sp->d_ptr->refcount - 1 == sp->d_ptr->d_ptrs_size) {
257 // However, to support corner cases we grow the array dynamically if needed.
258 sp->d_ptr->d_ptrs_size <<= 1;
259 const int newSize = sp->d_ptr->d_ptrs_size * sizeof(QPainterPrivate *);
260 sp->d_ptr->d_ptrs = q_check_ptr((QPainterPrivate **)realloc(sp->d_ptr->d_ptrs, newSize));
262 sp->d_ptr->d_ptrs[++sp->d_ptr->refcount - 2] = q->d_ptr.data();
264 q->d_ptr.reset(sp->d_ptr.data());
266 Q_ASSERT(q->d_ptr->state);
268 // Now initialize the painter with correct widget properties.
271 pdev->redirected(&offset);
272 offset += q->d_ptr->engine->coordinateOffset();
274 // Update system rect.
275 q->d_ptr->state->ww = q->d_ptr->state->vw = pdev->width();
276 q->d_ptr->state->wh = q->d_ptr->state->vh = pdev->height();
279 if (q->d_ptr->state->WxF) {
280 q->d_ptr->state->redirectionMatrix = q->d_ptr->state->matrix;
281 q->d_ptr->state->redirectionMatrix.translate(-offset.x(), -offset.y());
282 q->d_ptr->state->worldMatrix = QTransform();
283 q->d_ptr->state->WxF = false;
285 q->d_ptr->state->redirectionMatrix = QTransform::fromTranslate(-offset.x(), -offset.y());
287 q->d_ptr->updateMatrix();
289 QPaintEnginePrivate *enginePrivate = q->d_ptr->engine->d_func();
290 if (enginePrivate->currentClipDevice == pdev) {
291 enginePrivate->systemStateChanged();
295 // Update system transform and clip.
296 enginePrivate->currentClipDevice = pdev;
297 enginePrivate->setSystemTransform(q->d_ptr->state->matrix);
301 void QPainterPrivate::detachPainterPrivate(QPainter *q)
303 Q_ASSERT(refcount > 1);
306 QPainterPrivate *original = d_ptrs[--refcount - 1];
308 inDestructor = false;
310 original->inDestructor = true;
311 } else if (!original) {
312 original = new QPainterPrivate(q);
315 d_ptrs[refcount - 1] = 0;
318 q->d_ptr.reset(original);
320 if (emulationEngine) {
321 extended = emulationEngine->real_engine;
322 delete emulationEngine;
328 void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperation op)
331 if (qt_show_painter_debug_output) {
332 printf("QPainter::drawHelper\n");
336 if (originalPath.isEmpty())
339 QPaintEngine::PaintEngineFeatures gradientStretch =
340 QPaintEngine::PaintEngineFeatures(QGradient_StretchToDevice
341 | QPaintEngine::ObjectBoundingModeGradients);
343 const bool mustEmulateObjectBoundingModeGradients = extended
344 || ((state->emulationSpecifier & QPaintEngine::ObjectBoundingModeGradients)
345 && !engine->hasFeature(QPaintEngine::PatternTransform));
347 if (!(state->emulationSpecifier & ~gradientStretch)
348 && !mustEmulateObjectBoundingModeGradients) {
349 drawStretchedGradient(originalPath, op);
351 } else if (state->emulationSpecifier & QPaintEngine_OpaqueBackground) {
352 drawOpaqueBackground(originalPath, op);
358 qreal strokeOffsetX = 0, strokeOffsetY = 0;
360 QPainterPath path = originalPath * state->matrix;
361 QRectF pathBounds = path.boundingRect();
363 bool doStroke = (op & StrokeDraw) && (state->pen.style() != Qt::NoPen);
365 qreal penWidth = state->pen.widthF();
370 // In case of complex xform
371 if (state->matrix.type() > QTransform::TxScale) {
372 QPainterPathStroker stroker;
373 stroker.setWidth(penWidth);
374 stroker.setJoinStyle(state->pen.joinStyle());
375 stroker.setCapStyle(state->pen.capStyle());
376 QPainterPath stroke = stroker.createStroke(originalPath);
377 strokeBounds = (stroke * state->matrix).boundingRect();
379 strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0);
380 strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0);
386 if (!strokeBounds.isEmpty()) {
387 absPathRect = strokeBounds.intersected(QRectF(0, 0, device->width(), device->height())).toAlignedRect();
389 absPathRect = pathBounds.adjusted(-strokeOffsetX, -strokeOffsetY, strokeOffsetX, strokeOffsetY)
390 .intersected(QRectF(0, 0, device->width(), device->height())).toAlignedRect();
393 if (q->hasClipping()) {
394 bool hasPerspectiveTransform = false;
395 for (int i = 0; i < state->clipInfo.size(); ++i) {
396 const QPainterClipInfo &info = state->clipInfo.at(i);
397 if (info.matrix.type() == QTransform::TxProject) {
398 hasPerspectiveTransform = true;
402 // avoid mapping QRegions with perspective transforms
403 if (!hasPerspectiveTransform) {
404 // The trick with txinv and invMatrix is done in order to
405 // avoid transforming the clip to logical coordinates, and
406 // then back to device coordinates. This is a problem with
407 // QRegion/QRect based clips, since they use integer
408 // coordinates and converting to/from logical coordinates will
410 bool old_txinv = txinv;
411 QTransform old_invMatrix = invMatrix;
413 invMatrix = QTransform();
414 QPainterPath clipPath = q->clipPath();
415 QRectF r = clipPath.boundingRect().intersected(absPathRect);
416 absPathRect = r.toAlignedRect();
418 invMatrix = old_invMatrix;
422 // qDebug("\nQPainterPrivate::draw_helper(), x=%d, y=%d, w=%d, h=%d",
423 // devMinX, devMinY, device->width(), device->height());
424 // qDebug() << " - matrix" << state->matrix;
425 // qDebug() << " - originalPath.bounds" << originalPath.boundingRect();
426 // qDebug() << " - path.bounds" << path.boundingRect();
428 if (absPathRect.width() <= 0 || absPathRect.height() <= 0)
431 QImage image(absPathRect.width(), absPathRect.height(), QImage::Format_ARGB32_Premultiplied);
436 p.d_ptr->helper_device = helper_device;
438 p.setOpacity(state->opacity);
439 p.translate(-absPathRect.x(), -absPathRect.y());
440 p.setTransform(state->matrix, true);
441 p.setPen(doStroke ? state->pen : QPen(Qt::NoPen));
442 p.setBrush((op & FillDraw) ? state->brush : QBrush(Qt::NoBrush));
443 p.setBackground(state->bgBrush);
444 p.setBackgroundMode(state->bgMode);
445 p.setBrushOrigin(state->brushOrigin);
447 p.setRenderHint(QPainter::Antialiasing, state->renderHints & QPainter::Antialiasing);
448 p.setRenderHint(QPainter::SmoothPixmapTransform,
449 state->renderHints & QPainter::SmoothPixmapTransform);
451 p.drawPath(originalPath);
454 static bool do_fallback_overlay = qgetenv("QT_PAINT_FALLBACK_OVERLAY").size() > 0;
455 if (do_fallback_overlay) {
456 QImage block(8, 8, QImage::Format_ARGB32_Premultiplied);
458 pt.fillRect(0, 0, 8, 8, QColor(196, 0, 196));
459 pt.drawLine(0, 0, 8, 8);
462 p.setCompositionMode(QPainter::CompositionMode_SourceAtop);
464 p.fillRect(0, 0, image.width(), image.height(), QBrush(block));
471 state->matrix = QTransform();
473 extended->transformChanged();
475 state->dirtyFlags |= QPaintEngine::DirtyTransform;
478 engine->drawImage(absPathRect,
480 QRectF(0, 0, absPathRect.width(), absPathRect.height()),
481 Qt::OrderedDither | Qt::OrderedAlphaDither);
485 void QPainterPrivate::drawOpaqueBackground(const QPainterPath &path, DrawOperation op)
489 q->setBackgroundMode(Qt::TransparentMode);
491 if (op & FillDraw && state->brush.style() != Qt::NoBrush) {
492 q->fillPath(path, state->bgBrush.color());
493 q->fillPath(path, state->brush);
496 if (op & StrokeDraw && state->pen.style() != Qt::NoPen) {
497 q->strokePath(path, QPen(state->bgBrush.color(), state->pen.width()));
498 q->strokePath(path, state->pen);
501 q->setBackgroundMode(Qt::OpaqueMode);
504 static inline QBrush stretchGradientToUserSpace(const QBrush &brush, const QRectF &boundingRect)
506 Q_ASSERT(brush.style() >= Qt::LinearGradientPattern
507 && brush.style() <= Qt::ConicalGradientPattern);
509 QTransform gradientToUser(boundingRect.width(), 0, 0, boundingRect.height(),
510 boundingRect.x(), boundingRect.y());
512 QGradient g = *brush.gradient();
513 g.setCoordinateMode(QGradient::LogicalMode);
516 b.setTransform(gradientToUser * b.transform());
520 void QPainterPrivate::drawStretchedGradient(const QPainterPath &path, DrawOperation op)
524 const qreal sw = helper_device->width();
525 const qreal sh = helper_device->height();
527 bool changedPen = false;
528 bool changedBrush = false;
529 bool needsFill = false;
531 const QPen pen = state->pen;
532 const QBrush brush = state->brush;
534 const QGradient::CoordinateMode penMode = coordinateMode(pen.brush());
535 const QGradient::CoordinateMode brushMode = coordinateMode(brush);
539 // Draw the xformed fill if the brush is a stretch gradient.
540 if ((op & FillDraw) && brush.style() != Qt::NoBrush) {
541 if (brushMode == QGradient::StretchToDeviceMode) {
542 q->setPen(Qt::NoPen);
543 changedPen = pen.style() != Qt::NoPen;
547 const qreal isw = 1.0 / sw;
548 const qreal ish = 1.0 / sh;
549 QTransform inv(isw, 0, 0, ish, 0, 0);
550 engine->drawPath(path * inv);
555 if (brushMode == QGradient::ObjectBoundingMode) {
556 Q_ASSERT(engine->hasFeature(QPaintEngine::PatternTransform));
557 boundingRect = path.boundingRect();
558 q->setBrush(stretchGradientToUserSpace(brush, boundingRect));
564 if ((op & StrokeDraw) && pen.style() != Qt::NoPen) {
565 // Draw the xformed outline if the pen is a stretch gradient.
566 if (penMode == QGradient::StretchToDeviceMode) {
567 q->setPen(Qt::NoPen);
572 engine->drawPath(path);
576 q->setBrush(pen.brush());
580 QPainterPathStroker stroker;
581 stroker.setDashPattern(pen.style());
582 stroker.setWidth(pen.widthF());
583 stroker.setJoinStyle(pen.joinStyle());
584 stroker.setCapStyle(pen.capStyle());
585 stroker.setMiterLimit(pen.miterLimit());
586 QPainterPath stroke = stroker.createStroke(path);
588 const qreal isw = 1.0 / sw;
589 const qreal ish = 1.0 / sh;
590 QTransform inv(isw, 0, 0, ish, 0, 0);
591 engine->drawPath(stroke * inv);
594 if (!needsFill && brush.style() != Qt::NoBrush) {
595 q->setBrush(Qt::NoBrush);
599 if (penMode == QGradient::ObjectBoundingMode) {
600 Q_ASSERT(engine->hasFeature(QPaintEngine::PatternTransform));
602 // avoid computing the bounding rect twice
603 if (!needsFill || brushMode != QGradient::ObjectBoundingMode)
604 boundingRect = path.boundingRect();
607 p.setBrush(stretchGradientToUserSpace(pen.brush(), boundingRect));
610 } else if (changedPen) {
616 engine->drawPath(path);
618 } else if (needsFill) {
619 if (pen.style() != Qt::NoPen) {
620 q->setPen(Qt::NoPen);
625 engine->drawPath(path);
635 void QPainterPrivate::updateMatrix()
637 state->matrix = state->WxF ? state->worldMatrix : QTransform();
639 state->matrix *= viewTransform();
641 txinv = false; // no inverted matrix
642 state->matrix *= state->redirectionMatrix;
644 extended->transformChanged();
646 state->dirtyFlags |= QPaintEngine::DirtyTransform;
648 // printf("VxF=%d, WxF=%d\n", state->VxF, state->WxF);
649 // qDebug() << " --- using matrix" << state->matrix << redirection_offset;
653 void QPainterPrivate::updateInvMatrix()
655 Q_ASSERT(txinv == false);
656 txinv = true; // creating inverted matrix
657 invMatrix = state->matrix.inverted();
660 extern bool qt_isExtendedRadialGradient(const QBrush &brush);
662 void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
665 bool linearGradient = false;
666 bool radialGradient = false;
667 bool extendedRadialGradient = false;
668 bool conicalGradient = false;
669 bool patternBrush = false;
671 bool complexXform = false;
675 // Pen and brush properties (we have to check both if one changes because the
676 // one that's unchanged can still be in a state which requires emulation)
677 if (s->state() & (QPaintEngine::DirtyPen | QPaintEngine::DirtyBrush | QPaintEngine::DirtyHints)) {
678 // Check Brush stroke emulation
679 if (!s->pen.isSolid() && !engine->hasFeature(QPaintEngine::BrushStroke))
680 s->emulationSpecifier |= QPaintEngine::BrushStroke;
682 s->emulationSpecifier &= ~QPaintEngine::BrushStroke;
686 QBrush penBrush = (qpen_style(s->pen) == Qt::NoPen) ? QBrush(Qt::NoBrush) : qpen_brush(s->pen);
687 Qt::BrushStyle brushStyle = qbrush_style(s->brush);
688 Qt::BrushStyle penBrushStyle = qbrush_style(penBrush);
689 alpha = (penBrushStyle != Qt::NoBrush
690 && (penBrushStyle < Qt::LinearGradientPattern && penBrush.color().alpha() != 255)
691 && !penBrush.isOpaque())
692 || (brushStyle != Qt::NoBrush
693 && (brushStyle < Qt::LinearGradientPattern && s->brush.color().alpha() != 255)
694 && !s->brush.isOpaque());
695 linearGradient = ((penBrushStyle == Qt::LinearGradientPattern) ||
696 (brushStyle == Qt::LinearGradientPattern));
697 radialGradient = ((penBrushStyle == Qt::RadialGradientPattern) ||
698 (brushStyle == Qt::RadialGradientPattern));
699 extendedRadialGradient = radialGradient && (qt_isExtendedRadialGradient(penBrush) || qt_isExtendedRadialGradient(s->brush));
700 conicalGradient = ((penBrushStyle == Qt::ConicalGradientPattern) ||
701 (brushStyle == Qt::ConicalGradientPattern));
702 patternBrush = (((penBrushStyle > Qt::SolidPattern
703 && penBrushStyle < Qt::LinearGradientPattern)
704 || penBrushStyle == Qt::TexturePattern) ||
705 ((brushStyle > Qt::SolidPattern
706 && brushStyle < Qt::LinearGradientPattern)
707 || brushStyle == Qt::TexturePattern));
709 bool penTextureAlpha = false;
710 if (penBrush.style() == Qt::TexturePattern)
711 penTextureAlpha = qHasPixmapTexture(penBrush)
712 ? (penBrush.texture().depth() > 1) && penBrush.texture().hasAlpha()
713 : penBrush.textureImage().hasAlphaChannel();
714 bool brushTextureAlpha = false;
715 if (s->brush.style() == Qt::TexturePattern) {
716 brushTextureAlpha = qHasPixmapTexture(s->brush)
717 ? (s->brush.texture().depth() > 1) && s->brush.texture().hasAlpha()
718 : s->brush.textureImage().hasAlphaChannel();
720 if (((penBrush.style() == Qt::TexturePattern && penTextureAlpha)
721 || (s->brush.style() == Qt::TexturePattern && brushTextureAlpha))
722 && !engine->hasFeature(QPaintEngine::MaskedBrush))
723 s->emulationSpecifier |= QPaintEngine::MaskedBrush;
725 s->emulationSpecifier &= ~QPaintEngine::MaskedBrush;
728 if (s->state() & (QPaintEngine::DirtyHints
729 | QPaintEngine::DirtyOpacity
730 | QPaintEngine::DirtyBackgroundMode)) {
738 qDebug("QPainterPrivate::updateEmulationSpecifier, state=%p\n"
740 " - linearGradient: %d\n"
741 " - radialGradient: %d\n"
742 " - conicalGradient: %d\n"
743 " - patternBrush: %d\n"
752 uint(s->renderHints),
757 if (s->state() & QPaintEngine::DirtyTransform) {
758 xform = !s->matrix.isIdentity();
759 complexXform = !s->matrix.isAffine();
760 } else if (s->matrix.type() >= QTransform::TxTranslate) {
762 complexXform = !s->matrix.isAffine();
765 const bool brushXform = (!s->brush.transform().type() == QTransform::TxNone);
766 const bool penXform = (!s->pen.brush().transform().type() == QTransform::TxNone);
768 const bool patternXform = patternBrush && (xform || brushXform || penXform);
770 // Check alphablending
771 if (alpha && !engine->hasFeature(QPaintEngine::AlphaBlend))
772 s->emulationSpecifier |= QPaintEngine::AlphaBlend;
774 s->emulationSpecifier &= ~QPaintEngine::AlphaBlend;
776 // Linear gradient emulation
777 if (linearGradient && !engine->hasFeature(QPaintEngine::LinearGradientFill))
778 s->emulationSpecifier |= QPaintEngine::LinearGradientFill;
780 s->emulationSpecifier &= ~QPaintEngine::LinearGradientFill;
782 // Radial gradient emulation
783 if (extendedRadialGradient || (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill)))
784 s->emulationSpecifier |= QPaintEngine::RadialGradientFill;
786 s->emulationSpecifier &= ~QPaintEngine::RadialGradientFill;
788 // Conical gradient emulation
789 if (conicalGradient && !engine->hasFeature(QPaintEngine::ConicalGradientFill))
790 s->emulationSpecifier |= QPaintEngine::ConicalGradientFill;
792 s->emulationSpecifier &= ~QPaintEngine::ConicalGradientFill;
795 if (patternBrush && !engine->hasFeature(QPaintEngine::PatternBrush))
796 s->emulationSpecifier |= QPaintEngine::PatternBrush;
798 s->emulationSpecifier &= ~QPaintEngine::PatternBrush;
801 if (patternXform && !engine->hasFeature(QPaintEngine::PatternTransform))
802 s->emulationSpecifier |= QPaintEngine::PatternTransform;
804 s->emulationSpecifier &= ~QPaintEngine::PatternTransform;
807 if (xform && !engine->hasFeature(QPaintEngine::PrimitiveTransform))
808 s->emulationSpecifier |= QPaintEngine::PrimitiveTransform;
810 s->emulationSpecifier &= ~QPaintEngine::PrimitiveTransform;
812 // Perspective XForms
813 if (complexXform && !engine->hasFeature(QPaintEngine::PerspectiveTransform))
814 s->emulationSpecifier |= QPaintEngine::PerspectiveTransform;
816 s->emulationSpecifier &= ~QPaintEngine::PerspectiveTransform;
819 if (state->opacity != 1 && !engine->hasFeature(QPaintEngine::ConstantOpacity))
820 s->emulationSpecifier |= QPaintEngine::ConstantOpacity;
822 s->emulationSpecifier &= ~QPaintEngine::ConstantOpacity;
824 bool gradientStretch = false;
825 bool objectBoundingMode = false;
826 if (linearGradient || conicalGradient || radialGradient) {
827 QGradient::CoordinateMode brushMode = coordinateMode(s->brush);
828 QGradient::CoordinateMode penMode = coordinateMode(s->pen.brush());
830 gradientStretch |= (brushMode == QGradient::StretchToDeviceMode);
831 gradientStretch |= (penMode == QGradient::StretchToDeviceMode);
833 objectBoundingMode |= (brushMode == QGradient::ObjectBoundingMode);
834 objectBoundingMode |= (penMode == QGradient::ObjectBoundingMode);
837 s->emulationSpecifier |= QGradient_StretchToDevice;
839 s->emulationSpecifier &= ~QGradient_StretchToDevice;
841 if (objectBoundingMode && !engine->hasFeature(QPaintEngine::ObjectBoundingModeGradients))
842 s->emulationSpecifier |= QPaintEngine::ObjectBoundingModeGradients;
844 s->emulationSpecifier &= ~QPaintEngine::ObjectBoundingModeGradients;
846 // Opaque backgrounds...
847 if (s->bgMode == Qt::OpaqueMode &&
848 (is_pen_transparent(s->pen) || is_brush_transparent(s->brush)))
849 s->emulationSpecifier |= QPaintEngine_OpaqueBackground;
851 s->emulationSpecifier &= ~QPaintEngine_OpaqueBackground;
854 //won't be correct either way because the device can already have
855 // something rendered to it in which case subsequent emulation
856 // on a fully transparent qimage and then blitting the results
857 // won't produce correct results
859 if (state->composition_mode > QPainter::CompositionMode_Xor &&
860 !engine->hasFeature(QPaintEngine::BlendModes))
861 s->emulationSpecifier |= QPaintEngine::BlendModes;
863 s->emulationSpecifier &= ~QPaintEngine::BlendModes;
867 void QPainterPrivate::updateStateImpl(QPainterState *newState)
869 // ### we might have to call QPainter::begin() here...
870 if (!engine->state) {
871 engine->state = newState;
872 engine->setDirty(QPaintEngine::AllDirty);
875 if (engine->state->painter() != newState->painter)
876 // ### this could break with clip regions vs paths.
877 engine->setDirty(QPaintEngine::AllDirty);
879 // Upon restore, revert all changes since last save
880 else if (engine->state != newState)
881 newState->dirtyFlags |= QPaintEngine::DirtyFlags(static_cast<QPainterState *>(engine->state)->changeFlags);
883 // We need to store all changes made so that restore can deal with them
885 newState->changeFlags |= newState->dirtyFlags;
887 updateEmulationSpecifier(newState);
889 // Unset potential dirty background mode
890 newState->dirtyFlags &= ~(QPaintEngine::DirtyBackgroundMode
891 | QPaintEngine::DirtyBackground);
893 engine->state = newState;
894 engine->updateState(*newState);
895 engine->clearDirty(QPaintEngine::AllDirty);
899 void QPainterPrivate::updateState(QPainterState *newState)
903 engine->state = newState;
905 } else if (newState->state() || engine->state!=newState) {
906 bool setNonCosmeticPen = (newState->renderHints & QPainter::NonCosmeticDefaultPen)
907 && newState->pen.widthF() == 0;
908 if (setNonCosmeticPen) {
909 // Override the default pen's cosmetic state if the
910 // NonCosmeticDefaultPen render hint is used.
911 QPen oldPen = newState->pen;
912 newState->pen.setWidth(1);
913 newState->pen.setCosmetic(false);
914 newState->dirtyFlags |= QPaintEngine::DirtyPen;
916 updateStateImpl(newState);
918 // Restore the state pen back to its default to preserve visible
920 newState->pen = oldPen;
922 updateStateImpl(newState);
930 \brief The QPainter class performs low-level painting on widgets and
937 QPainter provides highly optimized functions to do most of the
938 drawing GUI programs require. It can draw everything from simple
939 lines to complex shapes like pies and chords. It can also draw
940 aligned text and pixmaps. Normally, it draws in a "natural"
941 coordinate system, but it can also do view and world
942 transformation. QPainter can operate on any object that inherits
943 the QPaintDevice class.
945 The common use of QPainter is inside a widget's paint event:
946 Construct and customize (e.g. set the pen or the brush) the
947 painter. Then draw. Remember to destroy the QPainter object after
948 drawing. For example:
950 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 0
952 The core functionality of QPainter is drawing, but the class also
953 provide several functions that allows you to customize QPainter's
954 settings and its rendering quality, and others that enable
955 clipping. In addition you can control how different shapes are
956 merged together by specifying the painter's composition mode.
958 The isActive() function indicates whether the painter is active. A
959 painter is activated by the begin() function and the constructor
960 that takes a QPaintDevice argument. The end() function, and the
961 destructor, deactivates it.
963 Together with the QPaintDevice and QPaintEngine classes, QPainter
964 form the basis for Qt's paint system. QPainter is the class used
965 to perform drawing operations. QPaintDevice represents a device
966 that can be painted on using a QPainter. QPaintEngine provides the
967 interface that the painter uses to draw onto different types of
968 devices. If the painter is active, device() returns the paint
969 device on which the painter paints, and paintEngine() returns the
970 paint engine that the painter is currently operating on. For more
971 information, see the \l {Paint System}.
973 Sometimes it is desirable to make someone else paint on an unusual
974 QPaintDevice. QPainter supports a static function to do this,
977 \warning When the paintdevice is a widget, QPainter can only be
978 used inside a paintEvent() function or in a function called by
979 paintEvent(); that is unless the Qt::WA_PaintOutsidePaintEvent
980 widget attribute is set. On Mac OS X and Windows, you can only
981 paint in a paintEvent() function regardless of this attribute's
988 There are several settings that you can customize to make QPainter
989 draw according to your preferences:
993 \o font() is the font used for drawing text. If the painter
994 isActive(), you can retrieve information about the currently set
995 font, and its metrics, using the fontInfo() and fontMetrics()
996 functions respectively.
998 \o brush() defines the color or pattern that is used for filling
1001 \o pen() defines the color or stipple that is used for drawing
1002 lines or boundaries.
1004 \o backgroundMode() defines whether there is a background() or
1005 not, i.e it is either Qt::OpaqueMode or Qt::TransparentMode.
1007 \o background() only applies when backgroundMode() is \l
1008 Qt::OpaqueMode and pen() is a stipple. In that case, it
1009 describes the color of the background pixels in the stipple.
1011 \o brushOrigin() defines the origin of the tiled brushes, normally
1012 the origin of widget's background.
1014 \o viewport(), window(), worldTransform() make up the painter's coordinate
1015 transformation system. For more information, see the \l
1016 {Coordinate Transformations} section and the \l {Coordinate
1017 System} documentation.
1019 \o hasClipping() tells whether the painter clips at all. (The paint
1020 device clips, too.) If the painter clips, it clips to clipRegion().
1022 \o layoutDirection() defines the layout direction used by the
1023 painter when drawing text.
1025 \o worldMatrixEnabled() tells whether world transformation is enabled.
1027 \o viewTransformEnabled() tells whether view transformation is
1032 Note that some of these settings mirror settings in some paint
1033 devices, e.g. QWidget::font(). The QPainter::begin() function (or
1034 equivalently the QPainter constructor) copies these attributes
1035 from the paint device.
1037 You can at any time save the QPainter's state by calling the
1038 save() function which saves all the available settings on an
1039 internal stack. The restore() function pops them back.
1043 QPainter provides functions to draw most primitives: drawPoint(),
1044 drawPoints(), drawLine(), drawRect(), drawRoundedRect(),
1045 drawEllipse(), drawArc(), drawPie(), drawChord(), drawPolyline(),
1046 drawPolygon(), drawConvexPolygon() and drawCubicBezier(). The two
1047 convenience functions, drawRects() and drawLines(), draw the given
1048 number of rectangles or lines in the given array of \l
1049 {QRect}{QRects} or \l {QLine}{QLines} using the current pen and
1052 The QPainter class also provides the fillRect() function which
1053 fills the given QRect, with the given QBrush, and the eraseRect()
1054 function that erases the area inside the given rectangle.
1056 All of these functions have both integer and floating point
1061 \o \inlineimage qpainter-basicdrawing.png
1063 \bold {Basic Drawing Example}
1065 The \l {painting/basicdrawing}{Basic Drawing} example shows how to
1066 display basic graphics primitives in a variety of styles using the
1071 If you need to draw a complex shape, especially if you need to do
1072 so repeatedly, consider creating a QPainterPath and drawing it
1078 \bold {Painter Paths example}
1080 The QPainterPath class provides a container for painting
1081 operations, enabling graphical shapes to be constructed and
1084 The \l {painting/painterpaths}{Painter Paths} example shows how
1085 painter paths can be used to build complex shapes for rendering.
1087 \o \inlineimage qpainter-painterpaths.png
1090 QPainter also provides the fillPath() function which fills the
1091 given QPainterPath with the given QBrush, and the strokePath()
1092 function that draws the outline of the given path (i.e. strokes
1095 See also the \l {painting/deform}{Vector Deformation} example which
1096 shows how to use advanced vector techniques to draw text using a
1097 QPainterPath, the \l {painting/gradients}{Gradients} example which shows
1098 the different types of gradients that are available in Qt, and the \l
1099 {painting/pathstroke}{Path Stroking} example which shows Qt's built-in
1100 dash patterns and shows how custom patterns can be used to extend
1101 the range of available patterns.
1105 \o \l {painting/deform}{Vector Deformation}
1106 \o \l {painting/gradients}{Gradients}
1107 \o \l {painting/pathstroke}{Path Stroking}
1109 \o \inlineimage qpainter-vectordeformation.png
1110 \o \inlineimage qpainter-gradients.png
1111 \o \inlineimage qpainter-pathstroking.png
1115 There are functions to draw pixmaps/images, namely drawPixmap(),
1116 drawImage() and drawTiledPixmap(). Both drawPixmap() and drawImage()
1117 produce the same result, except that drawPixmap() is faster
1118 on-screen while drawImage() may be faster on a QPrinter or other
1121 Text drawing is done using drawText(). When you need
1122 fine-grained positioning, boundingRect() tells you where a given
1123 drawText() command will draw.
1125 There is a drawPicture() function that draws the contents of an
1126 entire QPicture. The drawPicture() function is the only function
1127 that disregards all the painter's settings as QPicture has its own
1130 \section1 Rendering Quality
1132 To get the optimal rendering result using QPainter, you should use
1133 the platform independent QImage as paint device; i.e. using QImage
1134 will ensure that the result has an identical pixel representation
1137 The QPainter class also provides a means of controlling the
1138 rendering quality through its RenderHint enum and the support for
1139 floating point precision: All the functions for drawing primitives
1140 has a floating point version. These are often used in combination
1141 with the \l {RenderHint}{QPainter::Antialiasing} render hint.
1145 \o \inlineimage qpainter-concentriccircles.png
1147 \bold {Concentric Circles Example}
1149 The \l {painting/concentriccircles}{Concentric Circles} example
1150 shows the improved rendering quality that can be obtained using
1151 floating point precision and anti-aliasing when drawing custom
1154 The application's main window displays several widgets which are
1155 drawn using the various combinations of precision and
1160 The RenderHint enum specifies flags to QPainter that may or may
1161 not be respected by any given engine. \l
1162 {RenderHint}{QPainter::Antialiasing} indicates that the engine
1163 should antialias edges of primitives if possible, \l
1164 {RenderHint}{QPainter::TextAntialiasing} indicates that the engine
1165 should antialias text if possible, and the \l
1166 {RenderHint}{QPainter::SmoothPixmapTransform} indicates that the
1167 engine should use a smooth pixmap transformation algorithm.
1168 \l {RenderHint}{HighQualityAntialiasing} is an OpenGL-specific rendering hint
1169 indicating that the engine should use fragment programs and offscreen
1170 rendering for antialiasing.
1172 The renderHints() function returns a flag that specifies the
1173 rendering hints that are set for this painter. Use the
1174 setRenderHint() function to set or clear the currently set
1177 \section1 Coordinate Transformations
1179 Normally, the QPainter operates on the device's own coordinate
1180 system (usually pixels), but QPainter has good support for
1181 coordinate transformations.
1185 \o nop \o rotate() \o scale() \o translate()
1187 \o \inlineimage qpainter-clock.png
1188 \o \inlineimage qpainter-rotation.png
1189 \o \inlineimage qpainter-scale.png
1190 \o \inlineimage qpainter-translation.png
1193 The most commonly used transformations are scaling, rotation,
1194 translation and shearing. Use the scale() function to scale the
1195 coordinate system by a given offset, the rotate() function to
1196 rotate it clockwise and translate() to translate it (i.e. adding a
1197 given offset to the points). You can also twist the coordinate
1198 system around the origin using the shear() function. See the \l
1199 {painting/affine}{Affine Transformations} example for a visualization of
1200 a sheared coordinate system.
1202 See also the \l {painting/transformations}{Transformations}
1203 example which shows how transformations influence the way that
1204 QPainter renders graphics primitives. In particular it shows how
1205 the order of transformations affects the result.
1210 \bold {Affine Transformations Example}
1212 The \l {painting/affine}{Affine Transformations} example shows Qt's
1213 ability to perform affine transformations on painting
1214 operations. The demo also allows the user to experiment with the
1215 transformation operations and see the results immediately.
1217 \o \inlineimage qpainter-affinetransformations.png
1220 All the tranformation operations operate on the transformation
1221 worldTransform(). A matrix transforms a point in the plane to another
1222 point. For more information about the transformation matrix, see
1223 the \l {Coordinate System} and QTransform documentation.
1225 The setWorldTransform() function can replace or add to the currently
1226 set worldTransform(). The resetTransform() function resets any
1227 transformations that were made using translate(), scale(),
1228 shear(), rotate(), setWorldTransform(), setViewport() and setWindow()
1229 functions. The deviceTransform() returns the matrix that transforms
1230 from logical coordinates to device coordinates of the platform
1231 dependent paint device. The latter function is only needed when
1232 using platform painting commands on the platform dependent handle,
1233 and the platform does not do transformations nativly.
1235 When drawing with QPainter, we specify points using logical
1236 coordinates which then are converted into the physical coordinates
1237 of the paint device. The mapping of the logical coordinates to the
1238 physical coordinates are handled by QPainter's combinedTransform(), a
1239 combination of viewport() and window() and worldTransform(). The
1240 viewport() represents the physical coordinates specifying an
1241 arbitrary rectangle, the window() describes the same rectangle in
1242 logical coordinates, and the worldTransform() is identical with the
1243 transformation matrix.
1245 See also \l {Coordinate System}
1249 QPainter can clip any drawing operation to a rectangle, a region,
1250 or a vector path. The current clip is available using the
1251 functions clipRegion() and clipPath(). Whether paths or regions are
1252 preferred (faster) depends on the underlying paintEngine(). For
1253 example, the QImage paint engine prefers paths while the X11 paint
1254 engine prefers regions. Setting a clip is done in the painters
1255 logical coordinates.
1257 After QPainter's clipping, the paint device may also clip. For
1258 example, most widgets clip away the pixels used by child widgets,
1259 and most printers clip away an area near the edges of the paper.
1260 This additional clipping is not reflected by the return value of
1261 clipRegion() or hasClipping().
1263 \section1 Composition Modes
1264 \target Composition Modes
1266 QPainter provides the CompositionMode enum which defines the
1267 Porter-Duff rules for digital image compositing; it describes a
1268 model for combining the pixels in one image, the source, with the
1269 pixels in another image, the destination.
1271 The two most common forms of composition are \l
1272 {QPainter::CompositionMode}{Source} and \l
1273 {QPainter::CompositionMode}{SourceOver}. \l
1274 {QPainter::CompositionMode}{Source} is used to draw opaque objects
1275 onto a paint device. In this mode, each pixel in the source
1276 replaces the corresponding pixel in the destination. In \l
1277 {QPainter::CompositionMode}{SourceOver} composition mode, the
1278 source object is transparent and is drawn on top of the
1281 Note that composition transformation operates pixelwise. For that
1282 reason, there is a difference between using the graphic primitive
1283 itself and its bounding rectangle: The bounding rect contains
1284 pixels with alpha == 0 (i.e the pixels surrounding the
1285 primitive). These pixels will overwrite the other image's pixels,
1286 affectively clearing those, while the primitive only overwrites
1291 \o \inlineimage qpainter-compositiondemo.png
1294 \bold {Composition Modes Demo}
1296 The \l {painting/composition}{Composition Modes} example, available in
1297 Qt's examples directory, allows you to experiment with the various
1298 composition modes and see the results immediately.
1302 \section1 Limitations
1305 If you are using coordinates with Qt's raster-based paint engine, it is
1306 important to note that, while coordinates greater than +/- 2\sup 15 can
1307 be used, any painting performed with coordinates outside this range is not
1308 guaranteed to be shown; the drawing may be clipped. This is due to the
1309 use of \c{short int} in the implementation.
1311 The outlines generated by Qt's stroker are only an approximation when dealing
1312 with curved shapes. It is in most cases impossible to represent the outline of
1313 a bezier curve segment using another bezier curve segment, and so Qt approximates
1314 the curve outlines by using several smaller curves. For performance reasons there
1315 is a limit to how many curves Qt uses for these outlines, and thus when using
1316 large pen widths or scales the outline error increases. To generate outlines with
1317 smaller errors it is possible to use the QPainterPathStroker class, which has the
1318 setCurveThreshold member function which let's the user specify the error tolerance.
1319 Another workaround is to convert the paths to polygons first and then draw the
1322 \section1 Performance
1324 QPainter is a rich framework that allows developers to do a great
1325 variety of graphical operations, such as gradients, composition
1326 modes and vector graphics. And QPainter can do this across a
1327 variety of different hardware and software stacks. Naturally the
1328 underlying combination of hardware and software has some
1329 implications for performance, and ensuring that every single
1330 operation is fast in combination with all the various combinations
1331 of composition modes, brushes, clipping, transformation, etc, is
1332 close to an impossible task because of the number of
1333 permutations. As a compromise we have selected a subset of the
1334 QPainter API and backends, where performance is guaranteed to be as
1335 good as we can sensibly get it for the given combination of
1336 hardware and software.
1338 The backends we focus on as high-performance engines are:
1342 \o Raster - This backend implements all rendering in pure software
1343 and is always used to render into QImages. For optimal performance
1344 only use the format types QImage::Format_ARGB32_Premultiplied,
1345 QImage::Format_RGB32 or QImage::Format_RGB16. Any other format,
1346 including QImage::Format_ARGB32, has significantly worse
1347 performance. This engine is used by default for QWidget and QPixmap.
1349 \o OpenGL 2.0 (ES) - This backend is the primary backend for
1350 hardware accelerated graphics. It can be run on desktop machines
1351 and embedded devices supporting the OpenGL 2.0 or OpenGL/ES 2.0
1352 specification. This includes most graphics chips produced in the
1353 last couple of years. The engine can be enabled by using QPainter
1354 onto a QGLWidget or by passing \c {-graphicssystem opengl} on the
1355 command line when the underlying system supports it.
1357 \o OpenVG - This backend implements the Khronos standard for 2D
1358 and Vector Graphics. It is primarily for embedded devices with
1359 hardware support for OpenVG. The engine can be enabled by
1360 passing \c {-graphicssystem openvg} on the command line when
1361 the underlying system supports it.
1365 These operations are:
1369 \o Simple transformations, meaning translation and scaling, pluss
1370 0, 90, 180, 270 degree rotations.
1372 \o \c drawPixmap() in combination with simple transformations and
1373 opacity with non-smooth transformation mode
1374 (\c QPainter::SmoothPixmapTransform not enabled as a render hint).
1376 \o Rectangle fills with solid color, two-color linear gradients
1377 and simple transforms.
1379 \o Rectangular clipping with simple transformations and intersect
1382 \o Composition Modes \c QPainter::CompositionMode_Source and
1383 QPainter::CompositionMode_SourceOver
1385 \o Rounded rectangle filling using solid color and two-color
1386 linear gradients fills.
1388 \o 3x3 patched pixmaps, via qDrawBorderPixmap.
1392 This list gives an indication of which features to safely use in
1393 an application where performance is critical. For certain setups,
1394 other operations may be fast too, but before making extensive use
1395 of them, it is recommended to benchmark and verify them on the
1396 system where the software will run in the end. There are also
1397 cases where expensive operations are ok to use, for instance when
1398 the result is cached in a QPixmap.
1400 \sa QPaintDevice, QPaintEngine, {QtSvg Module}, {Basic Drawing Example},
1401 {Drawing Utility Functions}
1405 \enum QPainter::RenderHint
1407 Renderhints are used to specify flags to QPainter that may or
1408 may not be respected by any given engine.
1410 \value Antialiasing Indicates that the engine should antialias
1411 edges of primitives if possible.
1413 \value TextAntialiasing Indicates that the engine should antialias
1414 text if possible. To forcibly disable antialiasing for text, do not
1415 use this hint. Instead, set QFont::NoAntialias on your font's style
1418 \value SmoothPixmapTransform Indicates that the engine should use
1419 a smooth pixmap transformation algorithm (such as bilinear) rather
1420 than nearest neighbor.
1422 \value HighQualityAntialiasing An OpenGL-specific rendering hint
1423 indicating that the engine should use fragment programs and offscreen
1424 rendering for antialiasing.
1426 \value NonCosmeticDefaultPen The engine should interpret pens with a width
1427 of 0 (which otherwise enables QPen::isCosmetic()) as being a non-cosmetic
1428 pen with a width of 1.
1430 \sa renderHints(), setRenderHint(), {QPainter#Rendering
1431 Quality}{Rendering Quality}, {Concentric Circles Example}
1436 Constructs a painter.
1441 QPainter::QPainter()
1442 : d_ptr(new QPainterPrivate(this))
1447 \fn QPainter::QPainter(QPaintDevice *device)
1449 Constructs a painter that begins painting the paint \a device
1452 This constructor is convenient for short-lived painters, e.g. in a
1453 QWidget::paintEvent() and should be used only once. The
1454 constructor calls begin() for you and the QPainter destructor
1455 automatically calls end().
1457 Here's an example using begin() and end():
1458 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 1
1460 The same example using this constructor:
1461 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 2
1463 Since the constructor cannot provide feedback when the initialization
1464 of the painter failed you should rather use begin() and end() to paint
1465 on external devices, e.g. printers.
1470 QPainter::QPainter(QPaintDevice *pd)
1474 if (!QPainterPrivate::attachPainterPrivate(this, pd)) {
1475 d_ptr.reset(new QPainterPrivate(this));
1482 Destroys the painter.
1484 QPainter::~QPainter()
1486 d_ptr->inDestructor = true;
1490 else if (d_ptr->refcount > 1)
1491 d_ptr->detachPainterPrivate(this);
1493 // don't throw anything in the destructor.
1496 // Make sure we haven't messed things up.
1497 Q_ASSERT(d_ptr->inDestructor);
1498 d_ptr->inDestructor = false;
1499 Q_ASSERT(d_ptr->refcount == 1);
1501 free(d_ptr->d_ptrs);
1506 Returns the paint device on which this painter is currently
1507 painting, or 0 if the painter is not active.
1512 QPaintDevice *QPainter::device() const
1514 Q_D(const QPainter);
1515 if (isActive() && d->engine->d_func()->currentClipDevice)
1516 return d->engine->d_func()->currentClipDevice;
1517 return d->original_device;
1521 Returns true if begin() has been called and end() has not yet been
1522 called; otherwise returns false.
1524 \sa begin(), QPaintDevice::paintingActive()
1527 bool QPainter::isActive() const
1529 Q_D(const QPainter);
1534 Initializes the painters pen, background and font to the same as
1535 the given \a paint device.
1539 \sa begin(), {QPainter#Settings}{Settings}
1541 void QPainter::initFrom(const QPaintDevice *device)
1543 Q_ASSERT_X(device, "QPainter::initFrom(const QPaintDevice *device)", "QPaintDevice cannot be 0");
1546 qWarning("QPainter::initFrom: Painter not active, aborted");
1553 d->extended->penChanged();
1554 } else if (d->engine) {
1555 d->engine->setDirty(QPaintEngine::DirtyPen);
1556 d->engine->setDirty(QPaintEngine::DirtyBrush);
1557 d->engine->setDirty(QPaintEngine::DirtyFont);
1563 Saves the current painter state (pushes the state onto a stack). A
1564 save() must be followed by a corresponding restore(); the end()
1565 function unwinds the stack.
1570 void QPainter::save()
1572 #ifdef QT_DEBUG_DRAW
1573 if (qt_show_painter_debug_output)
1574 printf("QPainter::save()\n");
1578 qWarning("QPainter::save: Painter not active");
1583 d->state = d->extended->createState(d->states.back());
1584 d->extended->setState(d->state);
1586 d->updateState(d->state);
1587 d->state = new QPainterState(d->states.back());
1588 d->engine->state = d->state;
1590 d->states.push_back(d->state);
1594 Restores the current painter state (pops a saved state off the
1600 void QPainter::restore()
1602 #ifdef QT_DEBUG_DRAW
1603 if (qt_show_painter_debug_output)
1604 printf("QPainter::restore()\n");
1607 if (d->states.size()<=1) {
1608 qWarning("QPainter::restore: Unbalanced save/restore");
1610 } else if (!d->engine) {
1611 qWarning("QPainter::restore: Painter not active");
1615 QPainterState *tmp = d->state;
1616 d->states.pop_back();
1617 d->state = d->states.back();
1621 d->checkEmulation();
1622 d->extended->setState(d->state);
1627 // trigger clip update if the clip path/region has changed since
1629 if (!d->state->clipInfo.isEmpty()
1630 && (tmp->changeFlags & (QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipPath))) {
1631 // reuse the tmp state to avoid any extra allocs...
1632 tmp->dirtyFlags = QPaintEngine::DirtyClipPath;
1633 tmp->clipOperation = Qt::NoClip;
1634 tmp->clipPath = QPainterPath();
1635 d->engine->updateState(*tmp);
1636 // replay the list of clip states,
1637 for (int i=0; i<d->state->clipInfo.size(); ++i) {
1638 const QPainterClipInfo &info = d->state->clipInfo.at(i);
1639 tmp->matrix = info.matrix;
1640 tmp->matrix *= d->state->redirectionMatrix;
1641 tmp->clipOperation = info.operation;
1642 if (info.clipType == QPainterClipInfo::RectClip) {
1643 tmp->dirtyFlags = QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyTransform;
1644 tmp->clipRegion = info.rect;
1645 } else if (info.clipType == QPainterClipInfo::RegionClip) {
1646 tmp->dirtyFlags = QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyTransform;
1647 tmp->clipRegion = info.region;
1648 } else { // clipType == QPainterClipInfo::PathClip
1649 tmp->dirtyFlags = QPaintEngine::DirtyClipPath | QPaintEngine::DirtyTransform;
1650 tmp->clipPath = info.path;
1652 d->engine->updateState(*tmp);
1656 //Since we've updated the clip region anyway, pretend that the clip path hasn't changed:
1657 d->state->dirtyFlags &= ~(QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipRegion);
1658 tmp->changeFlags &= ~(QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipRegion);
1659 tmp->changeFlags |= QPaintEngine::DirtyTransform;
1662 d->updateState(d->state);
1669 \fn bool QPainter::begin(QPaintDevice *device)
1671 Begins painting the paint \a device and returns true if
1672 successful; otherwise returns false.
1674 Notice that all painter settings (setPen(), setBrush() etc.) are reset
1675 to default values when begin() is called.
1677 The errors that can occur are serious problems, such as these:
1679 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 3
1681 Note that most of the time, you can use one of the constructors
1682 instead of begin(), and that end() is automatically done at
1685 \warning A paint device can only be painted by one painter at a
1688 \warning Painting on a QImage with the format
1689 QImage::Format_Indexed8 is not supported.
1691 \sa end(), QPainter()
1694 static inline void qt_cleanup_painter_state(QPainterPrivate *d)
1703 bool QPainter::begin(QPaintDevice *pd)
1707 if (pd->painters > 0) {
1708 qWarning("QPainter::begin: A paint device can only be painted by one painter at a time.");
1712 if (d_ptr->engine) {
1713 qWarning("QPainter::begin: Painter already active");
1717 if (QPainterPrivate::attachPainterPrivate(this, pd))
1722 d->helper_device = pd;
1723 d->original_device = pd;
1725 QPoint redirectionOffset;
1726 QPaintDevice *rpd = pd->redirected(&redirectionOffset);
1730 #ifdef QT_DEBUG_DRAW
1731 if (qt_show_painter_debug_output)
1732 printf("QPainter::begin(), device=%p, type=%d\n", pd, pd->devType());
1735 if (pd->devType() == QInternal::Pixmap)
1736 static_cast<QPixmap *>(pd)->detach();
1737 else if (pd->devType() == QInternal::Image)
1738 static_cast<QImage *>(pd)->detach();
1740 d->engine = pd->paintEngine();
1743 qWarning("QPainter::begin: Paint device returned engine == 0, type: %d", pd->devType());
1749 d->extended = d->engine->isExtended() ? static_cast<QPaintEngineEx *>(d->engine) : 0;
1750 if (d->emulationEngine)
1751 d->emulationEngine->real_engine = d->extended;
1753 // Setup new state...
1754 Q_ASSERT(!d->state);
1755 d->state = d->extended ? d->extended->createState(0) : new QPainterState;
1756 d->state->painter = this;
1757 d->states.push_back(d->state);
1759 d->state->redirectionMatrix.translate(-redirectionOffset.x(), -redirectionOffset.y());
1760 d->state->brushOrigin = QPointF();
1762 // Slip a painter state into the engine before we do any other operations
1764 d->extended->setState(d->state);
1766 d->engine->state = d->state;
1768 switch (pd->devType()) {
1770 // is this needed any more??
1771 case QInternal::Widget:
1773 const QWidget *widget = static_cast<const QWidget *>(pd);
1776 const bool paintOutsidePaintEvent = widget->testAttribute(Qt::WA_PaintOutsidePaintEvent);
1777 const bool inPaintEvent = widget->testAttribute(Qt::WA_WState_InPaintEvent);
1779 // Adjust offset for alien widgets painting outside the paint event.
1780 if (!inPaintEvent && paintOutsidePaintEvent && !widget->internalWinId()
1781 && widget->testAttribute(Qt::WA_WState_Created)) {
1782 const QPoint offset = widget->mapTo(widget->nativeParentWidget(), QPoint());
1783 d->state->redirectionMatrix.translate(offset.x(), offset.y());
1788 case QInternal::Pixmap:
1790 QPixmap *pm = static_cast<QPixmap *>(pd);
1793 qWarning("QPainter::begin: Cannot paint on a null pixmap");
1794 qt_cleanup_painter_state(d);
1798 if (pm->depth() == 1) {
1799 d->state->pen = QPen(Qt::color1);
1800 d->state->brush = QBrush(Qt::color0);
1804 case QInternal::Image:
1806 QImage *img = static_cast<QImage *>(pd);
1808 if (img->isNull()) {
1809 qWarning("QPainter::begin: Cannot paint on a null image");
1810 qt_cleanup_painter_state(d);
1812 } else if (img->format() == QImage::Format_Indexed8) {
1813 // Painting on indexed8 images is not supported.
1814 qWarning("QPainter::begin: Cannot paint on an image with the QImage::Format_Indexed8 format");
1815 qt_cleanup_painter_state(d);
1818 if (img->depth() == 1) {
1819 d->state->pen = QPen(Qt::color1);
1820 d->state->brush = QBrush(Qt::color0);
1827 if (d->state->ww == 0) // For compat with 3.x painter defaults
1828 d->state->ww = d->state->wh = d->state->vw = d->state->vh = 1024;
1830 d->engine->setPaintDevice(pd);
1832 bool begun = d->engine->begin(pd);
1834 qWarning("QPainter::begin(): Returned false");
1835 if (d->engine->isActive()) {
1838 qt_cleanup_painter_state(d);
1842 d->engine->setActive(begun);
1845 // Copy painter properties from original paint device,
1846 // required for QPixmap::grabWidget()
1847 if (d->original_device->devType() == QInternal::Widget) {
1848 initFrom(d->original_device);
1850 d->state->layoutDirection = Qt::LayoutDirectionAuto;
1851 // make sure we have a font compatible with the paintdevice
1852 d->state->deviceFont = d->state->font = QFont(d->state->deviceFont, device());
1855 QRect systemRect = d->engine->systemRect();
1856 if (!systemRect.isEmpty()) {
1857 d->state->ww = d->state->vw = systemRect.width();
1858 d->state->wh = d->state->vh = systemRect.height();
1860 d->state->ww = d->state->vw = pd->metric(QPaintDevice::PdmWidth);
1861 d->state->wh = d->state->vh = pd->metric(QPaintDevice::PdmHeight);
1864 const QPoint coordinateOffset = d->engine->coordinateOffset();
1865 d->state->redirectionMatrix.translate(-coordinateOffset.x(), -coordinateOffset.y());
1867 Q_ASSERT(d->engine->isActive());
1869 if (!d->state->redirectionMatrix.isIdentity())
1872 Q_ASSERT(d->engine->isActive());
1873 d->state->renderHints = QPainter::TextAntialiasing;
1874 ++d->device->painters;
1876 d->state->emulationSpecifier = 0;
1882 Ends painting. Any resources used while painting are released. You
1883 don't normally need to call this since it is called by the
1886 Returns true if the painter is no longer active; otherwise returns false.
1888 \sa begin(), isActive()
1891 bool QPainter::end()
1893 #ifdef QT_DEBUG_DRAW
1894 if (qt_show_painter_debug_output)
1895 printf("QPainter::end()\n");
1900 qWarning("QPainter::end: Painter not active, aborted");
1901 qt_cleanup_painter_state(d);
1905 if (d->refcount > 1) {
1906 d->detachPainterPrivate(this);
1912 if (d->engine->isActive()) {
1913 ended = d->engine->end();
1916 --d->device->painters;
1917 if (d->device->painters == 0) {
1918 d->engine->setPaintDevice(0);
1919 d->engine->setActive(false);
1923 if (d->states.size() > 1) {
1924 qWarning("QPainter::end: Painter ended with %d saved states",
1928 if (d->engine->autoDestruct()) {
1932 if (d->emulationEngine) {
1933 delete d->emulationEngine;
1934 d->emulationEngine = 0;
1941 qt_cleanup_painter_state(d);
1948 Returns the paint engine that the painter is currently operating
1949 on if the painter is active; otherwise 0.
1953 QPaintEngine *QPainter::paintEngine() const
1955 Q_D(const QPainter);
1962 Flushes the painting pipeline and prepares for the user issuing commands
1963 directly to the underlying graphics context. Must be followed by a call to
1964 endNativePainting().
1966 Note that only the states the underlying paint engine changes will be reset
1967 to their respective default states. The states we reset may change from
1968 release to release. The following states are currently reset in the OpenGL
1972 \i blending is disabled
1973 \i the depth, stencil and scissor tests are disabled
1974 \i the active texture unit is reset to 0
1975 \i the depth mask, depth function and the clear depth are reset to their
1977 \i the stencil mask, stencil operation and stencil function are reset to
1978 their default values
1979 \i the current color is reset to solid white
1982 If, for example, the OpenGL polygon mode is changed by the user inside a
1983 beginNativePaint()/endNativePainting() block, it will not be reset to the
1984 default state by endNativePainting(). Here is an example that shows
1985 intermixing of painter commands and raw OpenGL commands:
1987 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 21
1989 \sa endNativePainting()
1991 void QPainter::beginNativePainting()
1995 qWarning("QPainter::beginNativePainting: Painter not active");
2000 d->extended->beginNativePainting();
2006 Restores the painter after manually issuing native painting commands. Lets
2007 the painter restore any native state that it relies on before calling any
2008 other painter commands.
2010 \sa beginNativePainting()
2012 void QPainter::endNativePainting()
2014 Q_D(const QPainter);
2016 qWarning("QPainter::beginNativePainting: Painter not active");
2021 d->extended->endNativePainting();
2023 d->engine->syncState();
2027 Returns the font metrics for the painter if the painter is
2028 active. Otherwise, the return value is undefined.
2030 \sa font(), isActive(), {QPainter#Settings}{Settings}
2033 QFontMetrics QPainter::fontMetrics() const
2035 Q_D(const QPainter);
2037 qWarning("QPainter::fontMetrics: Painter not active");
2038 return QFontMetrics(QFont());
2040 return QFontMetrics(d->state->font);
2045 Returns the font info for the painter if the painter is
2046 active. Otherwise, the return value is undefined.
2048 \sa font(), isActive(), {QPainter#Settings}{Settings}
2051 QFontInfo QPainter::fontInfo() const
2053 Q_D(const QPainter);
2055 qWarning("QPainter::fontInfo: Painter not active");
2056 return QFontInfo(QFont());
2058 return QFontInfo(d->state->font);
2064 Returns the opacity of the painter. The default value is
2068 qreal QPainter::opacity() const
2070 Q_D(const QPainter);
2072 qWarning("QPainter::opacity: Painter not active");
2075 return d->state->opacity;
2081 Sets the opacity of the painter to \a opacity. The value should
2082 be in the range 0.0 to 1.0, where 0.0 is fully transparent and
2083 1.0 is fully opaque.
2085 Opacity set on the painter will apply to all drawing operations
2089 void QPainter::setOpacity(qreal opacity)
2094 qWarning("QPainter::setOpacity: Painter not active");
2098 opacity = qMin(qreal(1), qMax(qreal(0), opacity));
2100 if (opacity == d->state->opacity)
2103 d->state->opacity = opacity;
2106 d->extended->opacityChanged();
2108 d->state->dirtyFlags |= QPaintEngine::DirtyOpacity;
2113 Returns the currently set brush origin.
2115 \sa setBrushOrigin(), {QPainter#Settings}{Settings}
2118 QPoint QPainter::brushOrigin() const
2120 Q_D(const QPainter);
2122 qWarning("QPainter::brushOrigin: Painter not active");
2125 return QPointF(d->state->brushOrigin).toPoint();
2129 \fn void QPainter::setBrushOrigin(const QPointF &position)
2131 Sets the brush origin to \a position.
2133 The brush origin specifies the (0, 0) coordinate of the painter's
2136 Note that while the brushOrigin() was necessary to adopt the
2137 parent's background for a widget in Qt 3, this is no longer the
2138 case since the Qt 4 painter doesn't paint the background unless
2139 you explicitly tell it to do so by setting the widget's \l
2140 {QWidget::autoFillBackground}{autoFillBackground} property to
2143 \sa brushOrigin(), {QPainter#Settings}{Settings}
2146 void QPainter::setBrushOrigin(const QPointF &p)
2149 #ifdef QT_DEBUG_DRAW
2150 if (qt_show_painter_debug_output)
2151 printf("QPainter::setBrushOrigin(), (%.2f,%.2f)\n", p.x(), p.y());
2155 qWarning("QPainter::setBrushOrigin: Painter not active");
2159 d->state->brushOrigin = p;
2162 d->extended->brushOriginChanged();
2166 d->state->dirtyFlags |= QPaintEngine::DirtyBrushOrigin;
2170 \fn void QPainter::setBrushOrigin(const QPoint &position)
2173 Sets the brush's origin to the given \a position.
2177 \fn void QPainter::setBrushOrigin(int x, int y)
2181 Sets the brush's origin to point (\a x, \a y).
2185 \enum QPainter::CompositionMode
2187 Defines the modes supported for digital image compositing.
2188 Composition modes are used to specify how the pixels in one image,
2189 the source, are merged with the pixel in another image, the
2192 Please note that the bitwise raster operation modes, denoted with
2193 a RasterOp prefix, are only natively supported in the X11 and
2194 raster paint engines. This means that the only way to utilize
2195 these modes on the Mac is via a QImage. The RasterOp denoted blend
2196 modes are \e not supported for pens and brushes with alpha
2197 components. Also, turning on the QPainter::Antialiasing render
2198 hint will effectively disable the RasterOp modes.
2201 \image qpainter-compositionmode1.png
2202 \image qpainter-compositionmode2.png
2204 The most common type is SourceOver (often referred to as just
2205 alpha blending) where the source pixel is blended on top of the
2206 destination pixel in such a way that the alpha component of the
2207 source defines the translucency of the pixel.
2209 When the paint device is a QImage, the image format must be set to
2210 \l {QImage::Format}{Format_ARGB32Premultiplied} or
2211 \l {QImage::Format}{Format_ARGB32} for the composition modes to have
2212 any effect. For performance the premultiplied version is the preferred
2215 When a composition mode is set it applies to all painting
2216 operator, pens, brushes, gradients and pixmap/image drawing.
2218 \value CompositionMode_SourceOver This is the default mode. The
2219 alpha of the source is used to blend the pixel on top of the
2222 \value CompositionMode_DestinationOver The alpha of the
2223 destination is used to blend it on top of the source pixels. This
2224 mode is the inverse of CompositionMode_SourceOver.
2226 \value CompositionMode_Clear The pixels in the destination are
2227 cleared (set to fully transparent) independent of the source.
2229 \value CompositionMode_Source The output is the source
2230 pixel. (This means a basic copy operation and is identical to
2231 SourceOver when the source pixel is opaque).
2233 \value CompositionMode_Destination The output is the destination
2234 pixel. This means that the blending has no effect. This mode is
2235 the inverse of CompositionMode_Source.
2237 \value CompositionMode_SourceIn The output is the source, where
2238 the alpha is reduced by that of the destination.
2240 \value CompositionMode_DestinationIn The output is the
2241 destination, where the alpha is reduced by that of the
2242 source. This mode is the inverse of CompositionMode_SourceIn.
2244 \value CompositionMode_SourceOut The output is the source, where
2245 the alpha is reduced by the inverse of destination.
2247 \value CompositionMode_DestinationOut The output is the
2248 destination, where the alpha is reduced by the inverse of the
2249 source. This mode is the inverse of CompositionMode_SourceOut.
2251 \value CompositionMode_SourceAtop The source pixel is blended on
2252 top of the destination, with the alpha of the source pixel reduced
2253 by the alpha of the destination pixel.
2255 \value CompositionMode_DestinationAtop The destination pixel is
2256 blended on top of the source, with the alpha of the destination
2257 pixel is reduced by the alpha of the destination pixel. This mode
2258 is the inverse of CompositionMode_SourceAtop.
2260 \value CompositionMode_Xor The source, whose alpha is reduced with
2261 the inverse of the destination alpha, is merged with the
2262 destination, whose alpha is reduced by the inverse of the source
2263 alpha. CompositionMode_Xor is not the same as the bitwise Xor.
2265 \value CompositionMode_Plus Both the alpha and color of the source
2266 and destination pixels are added together.
2268 \value CompositionMode_Multiply The output is the source color
2269 multiplied by the destination. Multiplying a color with white
2270 leaves the color unchanged, while multiplying a color
2271 with black produces black.
2273 \value CompositionMode_Screen The source and destination colors
2274 are inverted and then multiplied. Screening a color with white
2275 produces white, whereas screening a color with black leaves the
2278 \value CompositionMode_Overlay Multiplies or screens the colors
2279 depending on the destination color. The destination color is mixed
2280 with the source color to reflect the lightness or darkness of the
2283 \value CompositionMode_Darken The darker of the source and
2284 destination colors is selected.
2286 \value CompositionMode_Lighten The lighter of the source and
2287 destination colors is selected.
2289 \value CompositionMode_ColorDodge The destination color is
2290 brightened to reflect the source color. A black source color
2291 leaves the destination color unchanged.
2293 \value CompositionMode_ColorBurn The destination color is darkened
2294 to reflect the source color. A white source color leaves the
2295 destination color unchanged.
2297 \value CompositionMode_HardLight Multiplies or screens the colors
2298 depending on the source color. A light source color will lighten
2299 the destination color, whereas a dark source color will darken the
2302 \value CompositionMode_SoftLight Darkens or lightens the colors
2303 depending on the source color. Similar to
2304 CompositionMode_HardLight.
2306 \value CompositionMode_Difference Subtracts the darker of the
2307 colors from the lighter. Painting with white inverts the
2308 destination color, whereas painting with black leaves the
2309 destination color unchanged.
2311 \value CompositionMode_Exclusion Similar to
2312 CompositionMode_Difference, but with a lower contrast. Painting
2313 with white inverts the destination color, whereas painting with
2314 black leaves the destination color unchanged.
2316 \value RasterOp_SourceOrDestination Does a bitwise OR operation on
2317 the source and destination pixels (src OR dst).
2319 \value RasterOp_SourceAndDestination Does a bitwise AND operation
2320 on the source and destination pixels (src AND dst).
2322 \value RasterOp_SourceXorDestination Does a bitwise XOR operation
2323 on the source and destination pixels (src XOR dst).
2325 \value RasterOp_NotSourceAndNotDestination Does a bitwise NOR
2326 operation on the source and destination pixels ((NOT src) AND (NOT
2329 \value RasterOp_NotSourceOrNotDestination Does a bitwise NAND
2330 operation on the source and destination pixels ((NOT src) OR (NOT
2333 \value RasterOp_NotSourceXorDestination Does a bitwise operation
2334 where the source pixels are inverted and then XOR'ed with the
2335 destination ((NOT src) XOR dst).
2337 \value RasterOp_NotSource Does a bitwise operation where the
2338 source pixels are inverted (NOT src).
2340 \value RasterOp_NotSourceAndDestination Does a bitwise operation
2341 where the source is inverted and then AND'ed with the destination
2342 ((NOT src) AND dst).
2344 \value RasterOp_SourceAndNotDestination Does a bitwise operation
2345 where the source is AND'ed with the inverted destination pixels
2346 (src AND (NOT dst)).
2348 \sa compositionMode(), setCompositionMode(), {QPainter#Composition
2349 Modes}{Composition Modes}, {Image Composition Example}
2353 Sets the composition mode to the given \a mode.
2355 \warning Only a QPainter operating on a QImage fully supports all
2356 composition modes. The RasterOp modes are supported for X11 as
2357 described in compositionMode().
2359 \sa compositionMode()
2361 void QPainter::setCompositionMode(CompositionMode mode)
2365 qWarning("QPainter::setCompositionMode: Painter not active");
2368 if (d->state->composition_mode == mode)
2371 d->state->composition_mode = mode;
2372 d->extended->compositionModeChanged();
2376 if (mode >= QPainter::RasterOp_SourceOrDestination) {
2377 if (!d->engine->hasFeature(QPaintEngine::RasterOpModes)) {
2378 qWarning("QPainter::setCompositionMode: "
2379 "Raster operation modes not supported on device");
2382 } else if (mode >= QPainter::CompositionMode_Plus) {
2383 if (!d->engine->hasFeature(QPaintEngine::BlendModes)) {
2384 qWarning("QPainter::setCompositionMode: "
2385 "Blend modes not supported on device");
2388 } else if (!d->engine->hasFeature(QPaintEngine::PorterDuff)) {
2389 if (mode != CompositionMode_Source && mode != CompositionMode_SourceOver) {
2390 qWarning("QPainter::setCompositionMode: "
2391 "PorterDuff modes not supported on device");
2396 d->state->composition_mode = mode;
2397 d->state->dirtyFlags |= QPaintEngine::DirtyCompositionMode;
2401 Returns the current composition mode.
2403 \sa CompositionMode, setCompositionMode()
2405 QPainter::CompositionMode QPainter::compositionMode() const
2407 Q_D(const QPainter);
2409 qWarning("QPainter::compositionMode: Painter not active");
2410 return QPainter::CompositionMode_SourceOver;
2412 return d->state->composition_mode;
2416 Returns the current background brush.
2418 \sa setBackground(), {QPainter#Settings}{Settings}
2421 const QBrush &QPainter::background() const
2423 Q_D(const QPainter);
2425 qWarning("QPainter::background: Painter not active");
2426 return d->fakeState()->brush;
2428 return d->state->bgBrush;
2433 Returns true if clipping has been set; otherwise returns false.
2435 \sa setClipping(), {QPainter#Clipping}{Clipping}
2438 bool QPainter::hasClipping() const
2440 Q_D(const QPainter);
2442 qWarning("QPainter::hasClipping: Painter not active");
2445 return d->state->clipEnabled && d->state->clipOperation != Qt::NoClip;
2450 Enables clipping if \a enable is true, or disables clipping if \a
2453 \sa hasClipping(), {QPainter#Clipping}{Clipping}
2456 void QPainter::setClipping(bool enable)
2459 #ifdef QT_DEBUG_DRAW
2460 if (qt_show_painter_debug_output)
2461 printf("QPainter::setClipping(), enable=%s, was=%s\n",
2462 enable ? "on" : "off",
2463 hasClipping() ? "on" : "off");
2466 qWarning("QPainter::setClipping: Painter not active, state will be reset by begin");
2470 if (hasClipping() == enable)
2473 // we can't enable clipping if we don't have a clip
2475 && (d->state->clipInfo.isEmpty() || d->state->clipInfo.last().operation == Qt::NoClip))
2477 d->state->clipEnabled = enable;
2480 d->extended->clipEnabledChanged();
2484 d->state->dirtyFlags |= QPaintEngine::DirtyClipEnabled;
2485 d->updateState(d->state);
2490 Returns the currently set clip region. Note that the clip region
2491 is given in logical coordinates.
2493 \warning QPainter does not store the combined clip explicitly as
2494 this is handled by the underlying QPaintEngine, so the path is
2495 recreated on demand and transformed to the current logical
2496 coordinate system. This is potentially an expensive operation.
2498 \sa setClipRegion(), clipPath(), setClipping()
2501 QRegion QPainter::clipRegion() const
2503 Q_D(const QPainter);
2505 qWarning("QPainter::clipRegion: Painter not active");
2510 bool lastWasNothing = true;
2513 const_cast<QPainter *>(this)->d_ptr->updateInvMatrix();
2515 // ### Falcon: Use QPainterPath
2516 for (int i=0; i<d->state->clipInfo.size(); ++i) {
2517 const QPainterClipInfo &info = d->state->clipInfo.at(i);
2518 switch (info.clipType) {
2520 case QPainterClipInfo::RegionClip: {
2521 QTransform matrix = (info.matrix * d->invMatrix);
2522 if (lastWasNothing) {
2523 region = info.region * matrix;
2524 lastWasNothing = false;
2527 if (info.operation == Qt::IntersectClip)
2528 region &= info.region * matrix;
2529 else if (info.operation == Qt::NoClip) {
2530 lastWasNothing = true;
2533 region = info.region * matrix;
2537 case QPainterClipInfo::PathClip: {
2538 QTransform matrix = (info.matrix * d->invMatrix);
2539 if (lastWasNothing) {
2540 region = QRegion((info.path * matrix).toFillPolygon().toPolygon(),
2541 info.path.fillRule());
2542 lastWasNothing = false;
2545 if (info.operation == Qt::IntersectClip) {
2546 region &= QRegion((info.path * matrix).toFillPolygon().toPolygon(),
2547 info.path.fillRule());
2548 } else if (info.operation == Qt::NoClip) {
2549 lastWasNothing = true;
2552 region = QRegion((info.path * matrix).toFillPolygon().toPolygon(),
2553 info.path.fillRule());
2558 case QPainterClipInfo::RectClip: {
2559 QTransform matrix = (info.matrix * d->invMatrix);
2560 if (lastWasNothing) {
2561 region = QRegion(info.rect) * matrix;
2562 lastWasNothing = false;
2565 if (info.operation == Qt::IntersectClip) {
2566 // Use rect intersection if possible.
2567 if (matrix.type() <= QTransform::TxScale)
2568 region &= matrix.mapRect(info.rect);
2570 region &= matrix.map(QRegion(info.rect));
2571 } else if (info.operation == Qt::NoClip) {
2572 lastWasNothing = true;
2575 region = QRegion(info.rect) * matrix;
2580 case QPainterClipInfo::RectFClip: {
2581 QTransform matrix = (info.matrix * d->invMatrix);
2582 if (lastWasNothing) {
2583 region = QRegion(info.rectf.toRect()) * matrix;
2584 lastWasNothing = false;
2587 if (info.operation == Qt::IntersectClip) {
2588 // Use rect intersection if possible.
2589 if (matrix.type() <= QTransform::TxScale)
2590 region &= matrix.mapRect(info.rectf.toRect());
2592 region &= matrix.map(QRegion(info.rectf.toRect()));
2593 } else if (info.operation == Qt::NoClip) {
2594 lastWasNothing = true;
2597 region = QRegion(info.rectf.toRect()) * matrix;
2607 extern QPainterPath qt_regionToPath(const QRegion ®ion);
2610 Returns the currently clip as a path. Note that the clip path is
2611 given in logical coordinates.
2613 \warning QPainter does not store the combined clip explicitly as
2614 this is handled by the underlying QPaintEngine, so the path is
2615 recreated on demand and transformed to the current logical
2616 coordinate system. This is potentially an expensive operation.
2618 \sa setClipPath(), clipRegion(), setClipping()
2620 QPainterPath QPainter::clipPath() const
2622 Q_D(const QPainter);
2624 // ### Since we do not support path intersections and path unions yet,
2625 // we just use clipRegion() here...
2627 qWarning("QPainter::clipPath: Painter not active");
2628 return QPainterPath();
2631 // No clip, return empty
2632 if (d->state->clipInfo.size() == 0) {
2633 return QPainterPath();
2636 // Update inverse matrix, used below.
2638 const_cast<QPainter *>(this)->d_ptr->updateInvMatrix();
2640 // For the simple case avoid conversion.
2641 if (d->state->clipInfo.size() == 1
2642 && d->state->clipInfo.at(0).clipType == QPainterClipInfo::PathClip) {
2643 QTransform matrix = (d->state->clipInfo.at(0).matrix * d->invMatrix);
2644 return d->state->clipInfo.at(0).path * matrix;
2646 } else if (d->state->clipInfo.size() == 1
2647 && d->state->clipInfo.at(0).clipType == QPainterClipInfo::RectClip) {
2648 QTransform matrix = (d->state->clipInfo.at(0).matrix * d->invMatrix);
2650 path.addRect(d->state->clipInfo.at(0).rect);
2651 return path * matrix;
2653 // Fallback to clipRegion() for now, since we don't have isect/unite for paths
2654 return qt_regionToPath(clipRegion());
2660 Returns the bounding rectangle of the current clip if there is a clip;
2661 otherwise returns an empty rectangle. Note that the clip region is
2662 given in logical coordinates.
2664 The bounding rectangle is not guaranteed to be tight.
2666 \sa setClipRect(), setClipPath(), setClipRegion()
2671 QRectF QPainter::clipBoundingRect() const
2673 Q_D(const QPainter);
2676 qWarning("QPainter::clipBoundingRect: Painter not active");
2680 // Accumulate the bounding box in device space. This is not 100%
2681 // precise, but it fits within the guarantee and it is reasonably
2684 for (int i=0; i<d->state->clipInfo.size(); ++i) {
2686 const QPainterClipInfo &info = d->state->clipInfo.at(i);
2688 if (info.clipType == QPainterClipInfo::RectClip)
2690 else if (info.clipType == QPainterClipInfo::RectFClip)
2692 else if (info.clipType == QPainterClipInfo::RegionClip)
2693 r = info.region.boundingRect();
2695 r = info.path.boundingRect();
2697 r = info.matrix.mapRect(r);
2701 else if (info.operation == Qt::IntersectClip)
2706 // Map the rectangle back into logical space using the inverse
2709 const_cast<QPainter *>(this)->d_ptr->updateInvMatrix();
2711 return d->invMatrix.mapRect(bounds);
2715 \fn void QPainter::setClipRect(const QRectF &rectangle, Qt::ClipOperation operation)
2717 Enables clipping, and sets the clip region to the given \a
2718 rectangle using the given clip \a operation. The default operation
2719 is to replace the current clip rectangle.
2721 Note that the clip rectangle is specified in logical (painter)
2724 \sa clipRegion(), setClipping(), {QPainter#Clipping}{Clipping}
2726 void QPainter::setClipRect(const QRectF &rect, Qt::ClipOperation op)
2731 if ((!d->state->clipEnabled && op != Qt::NoClip))
2732 op = Qt::ReplaceClip;
2735 qWarning("QPainter::setClipRect: Painter not active");
2738 qreal right = rect.x() + rect.width();
2739 qreal bottom = rect.y() + rect.height();
2740 qreal pts[] = { rect.x(), rect.y(),
2744 QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);
2745 d->state->clipEnabled = true;
2746 d->extended->clip(vp, op);
2747 if (op == Qt::ReplaceClip || op == Qt::NoClip)
2748 d->state->clipInfo.clear();
2749 d->state->clipInfo << QPainterClipInfo(rect, op, d->state->matrix);
2750 d->state->clipOperation = op;
2754 if (qreal(int(rect.top())) == rect.top()
2755 && qreal(int(rect.bottom())) == rect.bottom()
2756 && qreal(int(rect.left())) == rect.left()
2757 && qreal(int(rect.right())) == rect.right())
2759 setClipRect(rect.toRect(), op);
2763 if (rect.isEmpty()) {
2764 setClipRegion(QRegion(), op);
2770 setClipPath(path, op);
2774 \fn void QPainter::setClipRect(const QRect &rectangle, Qt::ClipOperation operation)
2777 Enables clipping, and sets the clip region to the given \a rectangle using the given
2780 void QPainter::setClipRect(const QRect &rect, Qt::ClipOperation op)
2785 qWarning("QPainter::setClipRect: Painter not active");
2789 if ((!d->state->clipEnabled && op != Qt::NoClip))
2790 op = Qt::ReplaceClip;
2793 d->state->clipEnabled = true;
2794 d->extended->clip(rect, op);
2795 if (op == Qt::ReplaceClip || op == Qt::NoClip)
2796 d->state->clipInfo.clear();
2797 d->state->clipInfo << QPainterClipInfo(rect, op, d->state->matrix);
2798 d->state->clipOperation = op;
2802 d->state->clipRegion = rect;
2803 d->state->clipOperation = op;
2804 if (op == Qt::NoClip || op == Qt::ReplaceClip)
2805 d->state->clipInfo.clear();
2806 d->state->clipInfo << QPainterClipInfo(rect, op, d->state->matrix);
2807 d->state->clipEnabled = true;
2808 d->state->dirtyFlags |= QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled;
2809 d->updateState(d->state);
2813 \fn void QPainter::setClipRect(int x, int y, int width, int height, Qt::ClipOperation operation)
2815 Enables clipping, and sets the clip region to the rectangle beginning at (\a x, \a y)
2816 with the given \a width and \a height.
2820 \fn void QPainter::setClipRegion(const QRegion ®ion, Qt::ClipOperation operation)
2822 Sets the clip region to the given \a region using the specified clip
2823 \a operation. The default clip operation is to replace the current
2826 Note that the clip region is given in logical coordinates.
2828 \sa clipRegion(), setClipRect(), {QPainter#Clipping}{Clipping}
2830 void QPainter::setClipRegion(const QRegion &r, Qt::ClipOperation op)
2833 #ifdef QT_DEBUG_DRAW
2834 QRect rect = r.boundingRect();
2835 if (qt_show_painter_debug_output)
2836 printf("QPainter::setClipRegion(), size=%d, [%d,%d,%d,%d]\n",
2837 r.rects().size(), rect.x(), rect.y(), rect.width(), rect.height());
2840 qWarning("QPainter::setClipRegion: Painter not active");
2844 if ((!d->state->clipEnabled && op != Qt::NoClip))
2845 op = Qt::ReplaceClip;
2848 d->state->clipEnabled = true;
2849 d->extended->clip(r, op);
2850 if (op == Qt::NoClip || op == Qt::ReplaceClip)
2851 d->state->clipInfo.clear();
2852 d->state->clipInfo << QPainterClipInfo(r, op, d->state->matrix);
2853 d->state->clipOperation = op;
2857 d->state->clipRegion = r;
2858 d->state->clipOperation = op;
2859 if (op == Qt::NoClip || op == Qt::ReplaceClip)
2860 d->state->clipInfo.clear();
2861 d->state->clipInfo << QPainterClipInfo(r, op, d->state->matrix);
2862 d->state->clipEnabled = true;
2863 d->state->dirtyFlags |= QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled;
2864 d->updateState(d->state);
2871 Sets the transformation matrix to \a matrix and enables transformations.
2873 \note It is advisable to use setWorldTransform() instead of this function to
2874 preserve the properties of perspective transformations.
2876 If \a combine is true, then \a matrix is combined with the current
2877 transformation matrix; otherwise \a matrix replaces the current
2878 transformation matrix.
2880 If \a matrix is the identity matrix and \a combine is false, this
2881 function calls setWorldMatrixEnabled(false). (The identity matrix is the
2882 matrix where QMatrix::m11() and QMatrix::m22() are 1.0 and the
2885 The following functions can transform the coordinate system without using
2894 They operate on the painter's worldMatrix() and are implemented like this:
2896 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 4
2898 Note that when using setWorldMatrix() function you should always have
2899 \a combine be true when you are drawing into a QPicture. Otherwise
2900 it may not be possible to replay the picture with additional
2901 transformations; using the translate(), scale(), etc. convenience
2904 For more information about the coordinate system, transformations
2905 and window-viewport conversion, see \l {Coordinate System}.
2907 \sa setWorldTransform(), QTransform
2910 void QPainter::setWorldMatrix(const QMatrix &matrix, bool combine)
2912 setWorldTransform(QTransform(matrix), combine);
2919 Returns the world transformation matrix.
2921 It is advisable to use worldTransform() because worldMatrix() does not
2922 preserve the properties of perspective transformations.
2924 \sa {QPainter#Coordinate Transformations}{Coordinate Transformations},
2928 const QMatrix &QPainter::worldMatrix() const
2930 Q_D(const QPainter);
2932 qWarning("QPainter::worldMatrix: Painter not active");
2933 return d->fakeState()->transform.toAffine();
2935 return d->state->worldMatrix.toAffine();
2941 Use setWorldTransform() instead.
2943 \sa setWorldTransform()
2946 void QPainter::setMatrix(const QMatrix &matrix, bool combine)
2948 setWorldTransform(QTransform(matrix), combine);
2954 Use worldTransform() instead.
2956 \sa worldTransform()
2959 const QMatrix &QPainter::matrix() const
2961 return worldMatrix();
2969 Returns the transformation matrix combining the current
2970 window/viewport and world transformation.
2972 It is advisable to use combinedTransform() instead of this
2973 function to preserve the properties of perspective transformations.
2975 \sa setWorldTransform(), setWindow(), setViewport()
2977 QMatrix QPainter::combinedMatrix() const
2979 return combinedTransform().toAffine();
2986 Returns the matrix that transforms from logical coordinates to
2987 device coordinates of the platform dependent paint device.
2989 \note It is advisable to use deviceTransform() instead of this
2990 function to preserve the properties of perspective transformations.
2992 This function is \e only needed when using platform painting
2993 commands on the platform dependent handle (Qt::HANDLE), and the
2994 platform does not do transformations nativly.
2996 The QPaintEngine::PaintEngineFeature enum can be queried to
2997 determine whether the platform performs the transformations or
3000 \sa worldMatrix(), QPaintEngine::hasFeature(),
3002 const QMatrix &QPainter::deviceMatrix() const
3004 Q_D(const QPainter);
3006 qWarning("QPainter::deviceMatrix: Painter not active");
3007 return d->fakeState()->transform.toAffine();
3009 return d->state->matrix.toAffine();
3015 Resets any transformations that were made using translate(), scale(),
3016 shear(), rotate(), setWorldMatrix(), setViewport() and
3019 It is advisable to use resetTransform() instead of this function
3020 to preserve the properties of perspective transformations.
3022 \sa {QPainter#Coordinate Transformations}{Coordinate
3026 void QPainter::resetMatrix()
3035 Enables transformations if \a enable is true, or disables
3036 transformations if \a enable is false. The world transformation
3037 matrix is not changed.
3039 \sa worldMatrixEnabled(), worldTransform(), {QPainter#Coordinate
3040 Transformations}{Coordinate Transformations}
3043 void QPainter::setWorldMatrixEnabled(bool enable)
3046 #ifdef QT_DEBUG_DRAW
3047 if (qt_show_painter_debug_output)
3048 printf("QPainter::setMatrixEnabled(), enable=%d\n", enable);
3052 qWarning("QPainter::setMatrixEnabled: Painter not active");
3055 if (enable == d->state->WxF)
3058 d->state->WxF = enable;
3065 Returns true if world transformation is enabled; otherwise returns
3068 \sa setWorldMatrixEnabled(), worldTransform(), {Coordinate System}
3071 bool QPainter::worldMatrixEnabled() const
3073 Q_D(const QPainter);
3075 qWarning("QPainter::worldMatrixEnabled: Painter not active");
3078 return d->state->WxF;
3084 Use setWorldMatrixEnabled() instead.
3086 \sa setWorldMatrixEnabled()
3089 void QPainter::setMatrixEnabled(bool enable)
3091 setWorldMatrixEnabled(enable);
3097 Use worldMatrixEnabled() instead
3099 \sa worldMatrixEnabled()
3102 bool QPainter::matrixEnabled() const
3104 return worldMatrixEnabled();
3108 Scales the coordinate system by (\a{sx}, \a{sy}).
3110 \sa setWorldTransform() {QPainter#Coordinate Transformations}{Coordinate
3114 void QPainter::scale(qreal sx, qreal sy)
3116 #ifdef QT_DEBUG_DRAW
3117 if (qt_show_painter_debug_output)
3118 printf("QPainter::scale(), sx=%f, sy=%f\n", sx, sy);
3122 qWarning("QPainter::scale: Painter not active");
3126 d->state->worldMatrix.scale(sx,sy);
3127 d->state->WxF = true;
3132 Shears the coordinate system by (\a{sh}, \a{sv}).
3134 \sa setWorldTransform(), {QPainter#Coordinate Transformations}{Coordinate
3138 void QPainter::shear(qreal sh, qreal sv)
3140 #ifdef QT_DEBUG_DRAW
3141 if (qt_show_painter_debug_output)
3142 printf("QPainter::shear(), sh=%f, sv=%f\n", sh, sv);
3146 qWarning("QPainter::shear: Painter not active");
3150 d->state->worldMatrix.shear(sh, sv);
3151 d->state->WxF = true;
3156 \fn void QPainter::rotate(qreal angle)
3158 Rotates the coordinate system the given \a angle clockwise.
3160 \sa setWorldTransform(), {QPainter#Coordinate Transformations}{Coordinate
3164 void QPainter::rotate(qreal a)
3166 #ifdef QT_DEBUG_DRAW
3167 if (qt_show_painter_debug_output)
3168 printf("QPainter::rotate(), angle=%f\n", a);
3172 qWarning("QPainter::rotate: Painter not active");
3176 d->state->worldMatrix.rotate(a);
3177 d->state->WxF = true;
3182 Translates the coordinate system by the given \a offset; i.e. the
3183 given \a offset is added to points.
3185 \sa setWorldTransform(), {QPainter#Coordinate Transformations}{Coordinate
3188 void QPainter::translate(const QPointF &offset)
3190 qreal dx = offset.x();
3191 qreal dy = offset.y();
3192 #ifdef QT_DEBUG_DRAW
3193 if (qt_show_painter_debug_output)
3194 printf("QPainter::translate(), dx=%f, dy=%f\n", dx, dy);
3198 qWarning("QPainter::translate: Painter not active");
3202 d->state->worldMatrix.translate(dx, dy);
3203 d->state->WxF = true;
3208 \fn void QPainter::translate(const QPoint &offset)
3211 Translates the coordinate system by the given \a offset.
3215 \fn void QPainter::translate(qreal dx, qreal dy)
3218 Translates the coordinate system by the vector (\a dx, \a dy).
3222 \fn void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation operation)
3224 Enables clipping, and sets the clip path for the painter to the
3225 given \a path, with the clip \a operation.
3227 Note that the clip path is specified in logical (painter)
3230 \sa clipPath(), clipRegion(), {QPainter#Clipping}{Clipping}
3233 void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation op)
3235 #ifdef QT_DEBUG_DRAW
3236 if (qt_show_painter_debug_output) {
3237 QRectF b = path.boundingRect();
3238 printf("QPainter::setClipPath(), size=%d, op=%d, bounds=[%.2f,%.2f,%.2f,%.2f]\n",
3239 path.elementCount(), op, b.x(), b.y(), b.width(), b.height());
3245 qWarning("QPainter::setClipPath: Painter not active");
3249 if ((!d->state->clipEnabled && op != Qt::NoClip))
3250 op = Qt::ReplaceClip;
3253 d->state->clipEnabled = true;
3254 d->extended->clip(path, op);
3255 if (op == Qt::NoClip || op == Qt::ReplaceClip)
3256 d->state->clipInfo.clear();
3257 d->state->clipInfo << QPainterClipInfo(path, op, d->state->matrix);
3258 d->state->clipOperation = op;
3262 d->state->clipPath = path;
3263 d->state->clipOperation = op;
3264 if (op == Qt::NoClip || op == Qt::ReplaceClip)
3265 d->state->clipInfo.clear();
3266 d->state->clipInfo << QPainterClipInfo(path, op, d->state->matrix);
3267 d->state->clipEnabled = true;
3268 d->state->dirtyFlags |= QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipEnabled;
3269 d->updateState(d->state);
3273 Draws the outline (strokes) the path \a path with the pen specified
3276 \sa fillPath(), {QPainter#Drawing}{Drawing}
3278 void QPainter::strokePath(const QPainterPath &path, const QPen &pen)
3283 qWarning("QPainter::strokePath: Painter not active");
3291 const QGradient *g = qpen_brush(pen).gradient();
3292 if (!g || g->coordinateMode() == QGradient::LogicalMode) {
3293 d->extended->stroke(qtVectorPathForPath(path), pen);
3298 QBrush oldBrush = d->state->brush;
3299 QPen oldPen = d->state->pen;
3302 setBrush(Qt::NoBrush);
3312 Fills the given \a path using the given \a brush. The outline is
3315 Alternatively, you can specify a QColor instead of a QBrush; the
3316 QBrush constructor (taking a QColor argument) will automatically
3317 create a solid pattern brush.
3321 void QPainter::fillPath(const QPainterPath &path, const QBrush &brush)
3326 qWarning("QPainter::fillPath: Painter not active");
3334 const QGradient *g = brush.gradient();
3335 if (!g || g->coordinateMode() == QGradient::LogicalMode) {
3336 d->extended->fill(qtVectorPathForPath(path), brush);
3341 QBrush oldBrush = d->state->brush;
3342 QPen oldPen = d->state->pen;
3355 Draws the given painter \a path using the current pen for outline
3356 and the current brush for filling.
3360 \o \inlineimage qpainter-path.png
3362 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 5
3365 \sa {painting/painterpaths}{the Painter Paths
3366 example},{painting/deform}{the Vector Deformation example}
3368 void QPainter::drawPath(const QPainterPath &path)
3370 #ifdef QT_DEBUG_DRAW
3371 QRectF pathBounds = path.boundingRect();
3372 if (qt_show_painter_debug_output)
3373 printf("QPainter::drawPath(), size=%d, [%.2f,%.2f,%.2f,%.2f]\n",
3374 path.elementCount(),
3375 pathBounds.x(), pathBounds.y(), pathBounds.width(), pathBounds.height());
3381 qWarning("QPainter::drawPath: Painter not active");
3386 d->extended->drawPath(path);
3389 d->updateState(d->state);
3391 if (d->engine->hasFeature(QPaintEngine::PainterPaths) && d->state->emulationSpecifier == 0) {
3392 d->engine->drawPath(path);
3394 d->draw_helper(path);
3399 \fn void QPainter::drawLine(const QLineF &line)
3401 Draws a line defined by \a line.
3405 \o \inlineimage qpainter-line.png
3407 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 6
3410 \sa drawLines(), drawPolyline(), {Coordinate System}
3414 \fn void QPainter::drawLine(const QLine &line)
3417 Draws a line defined by \a line.
3421 \fn void QPainter::drawLine(const QPoint &p1, const QPoint &p2)
3424 Draws a line from \a p1 to \a p2.
3428 \fn void QPainter::drawLine(const QPointF &p1, const QPointF &p2)
3431 Draws a line from \a p1 to \a p2.
3435 \fn void QPainter::drawLine(int x1, int y1, int x2, int y2)
3438 Draws a line from (\a x1, \a y1) to (\a x2, \a y2) and sets the
3439 current pen position to (\a x2, \a y2).
3443 \fn void QPainter::drawRect(const QRectF &rectangle)
3445 Draws the current \a rectangle with the current pen and brush.
3447 A filled rectangle has a size of \a{rectangle}.size(). A stroked
3448 rectangle has a size of \a{rectangle}.size() plus the pen width.
3452 \o \inlineimage qpainter-rectangle.png
3454 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 7
3457 \sa drawRects(), drawPolygon(), {Coordinate System}
3461 \fn void QPainter::drawRect(const QRect &rectangle)
3465 Draws the current \a rectangle with the current pen and brush.
3469 \fn void QPainter::drawRect(int x, int y, int width, int height)
3473 Draws a rectangle with upper left corner at (\a{x}, \a{y}) and
3474 with the given \a width and \a height.
3478 \fn void QPainter::drawRects(const QRectF *rectangles, int rectCount)
3480 Draws the first \a rectCount of the given \a rectangles using the
3481 current pen and brush.
3485 void QPainter::drawRects(const QRectF *rects, int rectCount)
3487 #ifdef QT_DEBUG_DRAW
3488 if (qt_show_painter_debug_output)
3489 printf("QPainter::drawRects(), count=%d\n", rectCount);
3494 qWarning("QPainter::drawRects: Painter not active");
3502 d->extended->drawRects(rects, rectCount);
3506 d->updateState(d->state);
3508 if (!d->state->emulationSpecifier) {
3509 d->engine->drawRects(rects, rectCount);
3513 if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
3514 && d->state->matrix.type() == QTransform::TxTranslate) {
3515 for (int i=0; i<rectCount; ++i) {
3516 QRectF r(rects[i].x() + d->state->matrix.dx(),
3517 rects[i].y() + d->state->matrix.dy(),
3520 d->engine->drawRects(&r, 1);
3523 if (d->state->brushNeedsResolving() || d->state->penNeedsResolving()) {
3524 for (int i=0; i<rectCount; ++i) {
3525 QPainterPath rectPath;
3526 rectPath.addRect(rects[i]);
3527 d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
3530 QPainterPath rectPath;
3531 for (int i=0; i<rectCount; ++i)
3532 rectPath.addRect(rects[i]);
3533 d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
3539 \fn void QPainter::drawRects(const QRect *rectangles, int rectCount)
3542 Draws the first \a rectCount of the given \a rectangles using the
3543 current pen and brush.
3545 void QPainter::drawRects(const QRect *rects, int rectCount)
3547 #ifdef QT_DEBUG_DRAW
3548 if (qt_show_painter_debug_output)
3549 printf("QPainter::drawRects(), count=%d\n", rectCount);
3554 qWarning("QPainter::drawRects: Painter not active");
3562 d->extended->drawRects(rects, rectCount);
3566 d->updateState(d->state);
3568 if (!d->state->emulationSpecifier) {
3569 d->engine->drawRects(rects, rectCount);
3573 if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
3574 && d->state->matrix.type() == QTransform::TxTranslate) {
3575 for (int i=0; i<rectCount; ++i) {
3576 QRectF r(rects[i].x() + d->state->matrix.dx(),
3577 rects[i].y() + d->state->matrix.dy(),
3581 d->engine->drawRects(&r, 1);
3584 if (d->state->brushNeedsResolving() || d->state->penNeedsResolving()) {
3585 for (int i=0; i<rectCount; ++i) {
3586 QPainterPath rectPath;
3587 rectPath.addRect(rects[i]);
3588 d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
3591 QPainterPath rectPath;
3592 for (int i=0; i<rectCount; ++i)
3593 rectPath.addRect(rects[i]);
3595 d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
3601 \fn void QPainter::drawRects(const QVector<QRectF> &rectangles)
3604 Draws the given \a rectangles using the current pen and brush.
3608 \fn void QPainter::drawRects(const QVector<QRect> &rectangles)
3612 Draws the given \a rectangles using the current pen and brush.
3616 \fn void QPainter::drawPoint(const QPointF &position)
3618 Draws a single point at the given \a position using the current
3621 \sa {Coordinate System}
3625 \fn void QPainter::drawPoint(const QPoint &position)
3628 Draws a single point at the given \a position using the current
3632 /*! \fn void QPainter::drawPoint(int x, int y)
3636 Draws a single point at position (\a x, \a y).
3640 Draws the first \a pointCount points in the array \a points using
3641 the current pen's color.
3643 \sa {Coordinate System}
3645 void QPainter::drawPoints(const QPointF *points, int pointCount)
3647 #ifdef QT_DEBUG_DRAW
3648 if (qt_show_painter_debug_output)
3649 printf("QPainter::drawPoints(), count=%d\n", pointCount);
3654 qWarning("QPainter::drawPoints: Painter not active");
3658 if (pointCount <= 0)
3662 d->extended->drawPoints(points, pointCount);
3666 d->updateState(d->state);
3668 if (!d->state->emulationSpecifier) {
3669 d->engine->drawPoints(points, pointCount);
3673 if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
3674 && d->state->matrix.type() == QTransform::TxTranslate) {
3675 // ### use drawPoints function
3676 for (int i=0; i<pointCount; ++i) {
3677 QPointF pt(points[i].x() + d->state->matrix.dx(),
3678 points[i].y() + d->state->matrix.dy());
3679 d->engine->drawPoints(&pt, 1);
3682 QPen pen = d->state->pen;
3683 bool flat_pen = pen.capStyle() == Qt::FlatCap;
3686 pen.setCapStyle(Qt::SquareCap);
3690 for (int i=0; i<pointCount; ++i) {
3691 path.moveTo(points[i].x(), points[i].y());
3692 path.lineTo(points[i].x() + 0.0001, points[i].y());
3694 d->draw_helper(path, QPainterPrivate::StrokeDraw);
3703 Draws the first \a pointCount points in the array \a points using
3704 the current pen's color.
3707 void QPainter::drawPoints(const QPoint *points, int pointCount)
3709 #ifdef QT_DEBUG_DRAW
3710 if (qt_show_painter_debug_output)
3711 printf("QPainter::drawPoints(), count=%d\n", pointCount);
3716 qWarning("QPainter::drawPoints: Painter not active");
3720 if (pointCount <= 0)
3724 d->extended->drawPoints(points, pointCount);
3728 d->updateState(d->state);
3730 if (!d->state->emulationSpecifier) {
3731 d->engine->drawPoints(points, pointCount);
3735 if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
3736 && d->state->matrix.type() == QTransform::TxTranslate) {
3737 // ### use drawPoints function
3738 for (int i=0; i<pointCount; ++i) {
3739 QPointF pt(points[i].x() + d->state->matrix.dx(),
3740 points[i].y() + d->state->matrix.dy());
3741 d->engine->drawPoints(&pt, 1);
3744 QPen pen = d->state->pen;
3745 bool flat_pen = (pen.capStyle() == Qt::FlatCap);
3748 pen.setCapStyle(Qt::SquareCap);
3752 for (int i=0; i<pointCount; ++i) {
3753 path.moveTo(points[i].x(), points[i].y());
3754 path.lineTo(points[i].x() + 0.0001, points[i].y());
3756 d->draw_helper(path, QPainterPrivate::StrokeDraw);
3763 \fn void QPainter::drawPoints(const QPolygonF &points)
3767 Draws the points in the vector \a points.
3771 \fn void QPainter::drawPoints(const QPolygon &points)
3775 Draws the points in the vector \a points.
3779 \fn void QPainter::drawPoints(const QPolygon &polygon, int index,
3785 Draws \a count points in the vector \a polygon starting on \a index
3786 using the current pen.
3788 Use drawPoints() combined with QPolygon::constData() instead.
3791 QPainter painter(this);
3792 painter.drawPoints(polygon, index, count);
3794 int pointCount = (count == -1) ? polygon.size() - index : count;
3796 QPainter painter(this);
3797 painter.drawPoints(polygon.constData() + index, pointCount);
3802 Sets the background mode of the painter to the given \a mode
3804 Qt::TransparentMode (the default) draws stippled lines and text
3805 without setting the background pixels. Qt::OpaqueMode fills these
3806 space with the current background color.
3808 Note that in order to draw a bitmap or pixmap transparently, you
3809 must use QPixmap::setMask().
3811 \sa backgroundMode(), setBackground(),
3812 {QPainter#Settings}{Settings}
3815 void QPainter::setBackgroundMode(Qt::BGMode mode)
3817 #ifdef QT_DEBUG_DRAW
3818 if (qt_show_painter_debug_output)
3819 printf("QPainter::setBackgroundMode(), mode=%d\n", mode);
3824 qWarning("QPainter::setBackgroundMode: Painter not active");
3827 if (d->state->bgMode == mode)
3830 d->state->bgMode = mode;
3832 d->checkEmulation();
3834 d->state->dirtyFlags |= QPaintEngine::DirtyBackgroundMode;
3839 Returns the current background mode.
3841 \sa setBackgroundMode(), {QPainter#Settings}{Settings}
3843 Qt::BGMode QPainter::backgroundMode() const
3845 Q_D(const QPainter);
3847 qWarning("QPainter::backgroundMode: Painter not active");
3848 return Qt::TransparentMode;
3850 return d->state->bgMode;
3857 Sets the painter's pen to have style Qt::SolidLine, width 0 and the
3861 void QPainter::setPen(const QColor &color)
3863 #ifdef QT_DEBUG_DRAW
3864 if (qt_show_painter_debug_output)
3865 printf("QPainter::setPen(), color=%04x\n", color.rgb());
3869 qWarning("QPainter::setPen: Painter not active");
3873 if (d->state->pen.style() == Qt::SolidLine
3874 && d->state->pen.widthF() == 0
3875 && d->state->pen.isSolid()
3876 && d->state->pen.color() == color)
3879 QPen pen(color.isValid() ? color : QColor(Qt::black), 0, Qt::SolidLine);
3881 d->state->pen = pen;
3883 d->extended->penChanged();
3885 d->state->dirtyFlags |= QPaintEngine::DirtyPen;
3889 Sets the painter's pen to be the given \a pen.
3891 The \a pen defines how to draw lines and outlines, and it also
3892 defines the text color.
3894 \sa pen(), {QPainter#Settings}{Settings}
3897 void QPainter::setPen(const QPen &pen)
3900 #ifdef QT_DEBUG_DRAW
3901 if (qt_show_painter_debug_output)
3902 printf("QPainter::setPen(), color=%04x, (brushStyle=%d) style=%d, cap=%d, join=%d\n",
3903 pen.color().rgb(), pen.brush().style(), pen.style(), pen.capStyle(), pen.joinStyle());
3907 qWarning("QPainter::setPen: Painter not active");
3911 if (d->state->pen == pen)
3914 d->state->pen = pen;
3917 d->checkEmulation();
3918 d->extended->penChanged();
3922 d->state->dirtyFlags |= QPaintEngine::DirtyPen;
3928 Sets the painter's pen to have the given \a style, width 0 and
3932 void QPainter::setPen(Qt::PenStyle style)
3936 qWarning("QPainter::setPen: Painter not active");
3940 if (d->state->pen.style() == style
3941 && (style == Qt::NoPen || (d->state->pen.widthF() == 0
3942 && d->state->pen.isSolid()
3943 && d->state->pen.color() == QColor(Qt::black))))
3946 // QPen(Qt::NoPen) is to avoid creating QPenData, including its brush (from the color)
3947 // Note that this works well as long as QPen(Qt::NoPen) returns a black, zero-width pen
3948 d->state->pen = (style == Qt::NoPen) ? QPen(Qt::NoPen) : QPen(Qt::black, 0, style);
3951 d->extended->penChanged();
3953 d->state->dirtyFlags |= QPaintEngine::DirtyPen;
3958 Returns the painter's current pen.
3960 \sa setPen(), {QPainter#Settings}{Settings}
3963 const QPen &QPainter::pen() const
3965 Q_D(const QPainter);
3967 qWarning("QPainter::pen: Painter not active");
3968 return d->fakeState()->pen;
3970 return d->state->pen;
3975 Sets the painter's brush to the given \a brush.
3977 The painter's brush defines how shapes are filled.
3979 \sa brush(), {QPainter#Settings}{Settings}
3982 void QPainter::setBrush(const QBrush &brush)
3984 #ifdef QT_DEBUG_DRAW
3985 if (qt_show_painter_debug_output)
3986 printf("QPainter::setBrush(), color=%04x, style=%d\n", brush.color().rgb(), brush.style());
3990 qWarning("QPainter::setBrush: Painter not active");
3994 if (d->state->brush.d == brush.d)
3998 d->state->brush = brush;
3999 d->checkEmulation();
4000 d->extended->brushChanged();
4004 d->state->brush = brush;
4005 d->state->dirtyFlags |= QPaintEngine::DirtyBrush;
4012 Sets the painter's brush to black color and the specified \a
4016 void QPainter::setBrush(Qt::BrushStyle style)
4020 qWarning("QPainter::setBrush: Painter not active");
4023 if (d->state->brush.style() == style &&
4024 (style == Qt::NoBrush
4025 || (style == Qt::SolidPattern && d->state->brush.color() == QColor(0, 0, 0))))
4027 d->state->brush = QBrush(Qt::black, style);
4029 d->extended->brushChanged();
4031 d->state->dirtyFlags |= QPaintEngine::DirtyBrush;
4035 Returns the painter's current brush.
4037 \sa QPainter::setBrush(), {QPainter#Settings}{Settings}
4040 const QBrush &QPainter::brush() const
4042 Q_D(const QPainter);
4044 qWarning("QPainter::brush: Painter not active");
4045 return d->fakeState()->brush;
4047 return d->state->brush;
4051 \fn void QPainter::setBackground(const QBrush &brush)
4053 Sets the background brush of the painter to the given \a brush.
4055 The background brush is the brush that is filled in when drawing
4056 opaque text, stippled lines and bitmaps. The background brush has
4057 no effect in transparent background mode (which is the default).
4059 \sa background(), setBackgroundMode(),
4060 {QPainter#Settings}{Settings}
4063 void QPainter::setBackground(const QBrush &bg)
4065 #ifdef QT_DEBUG_DRAW
4066 if (qt_show_painter_debug_output)
4067 printf("QPainter::setBackground(), color=%04x, style=%d\n", bg.color().rgb(), bg.style());
4072 qWarning("QPainter::setBackground: Painter not active");
4075 d->state->bgBrush = bg;
4077 d->state->dirtyFlags |= QPaintEngine::DirtyBackground;
4081 Sets the painter's font to the given \a font.
4083 This font is used by subsequent drawText() functions. The text
4084 color is the same as the pen color.
4086 If you set a font that isn't available, Qt finds a close match.
4087 font() will return what you set using setFont() and fontInfo() returns the
4088 font actually being used (which may be the same).
4090 \sa font(), drawText(), {QPainter#Settings}{Settings}
4093 void QPainter::setFont(const QFont &font)
4097 #ifdef QT_DEBUG_DRAW
4098 if (qt_show_painter_debug_output)
4099 printf("QPainter::setFont(), family=%s, pointSize=%d\n", font.family().toLatin1().constData(), font.pointSize());
4103 qWarning("QPainter::setFont: Painter not active");
4107 d->state->font = QFont(font.resolve(d->state->deviceFont), device());
4109 d->state->dirtyFlags |= QPaintEngine::DirtyFont;
4113 Returns the currently set font used for drawing text.
4115 \sa setFont(), drawText(), {QPainter#Settings}{Settings}
4117 const QFont &QPainter::font() const
4119 Q_D(const QPainter);
4121 qWarning("QPainter::font: Painter not active");
4122 return d->fakeState()->font;
4124 return d->state->font;
4130 Draws the given rectangle \a rect with rounded corners.
4132 The \a xRadius and \a yRadius arguments specify the radii
4133 of the ellipses defining the corners of the rounded rectangle.
4134 When \a mode is Qt::RelativeSize, \a xRadius and
4135 \a yRadius are specified in percentage of half the rectangle's
4136 width and height respectively, and should be in the range
4139 A filled rectangle has a size of rect.size(). A stroked rectangle
4140 has a size of rect.size() plus the pen width.
4144 \o \inlineimage qpainter-roundrect.png
4146 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 8
4149 \sa drawRect(), QPen
4151 void QPainter::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
4153 #ifdef QT_DEBUG_DRAW
4154 if (qt_show_painter_debug_output)
4155 printf("QPainter::drawRoundedRect(), [%.2f,%.2f,%.2f,%.2f]\n", rect.x(), rect.y(), rect.width(), rect.height());
4162 if (xRadius <= 0 || yRadius <= 0) { // draw normal rectangle
4168 d->extended->drawRoundedRect(rect, xRadius, yRadius, mode);
4173 path.addRoundedRect(rect, xRadius, yRadius, mode);
4178 \fn void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius,
4179 Qt::SizeMode mode = Qt::AbsoluteSize);
4183 Draws the given rectangle \a rect with rounded corners.
4187 \fn void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius,
4188 Qt::SizeMode mode = Qt::AbsoluteSize);
4192 Draws the given rectangle \a x, \a y, \a w, \a h with rounded corners.
4198 Draws a rectangle \a r with rounded corners.
4200 The \a xRnd and \a yRnd arguments specify how rounded the corners
4201 should be. 0 is angled corners, 99 is maximum roundedness.
4203 A filled rectangle has a size of r.size(). A stroked rectangle
4204 has a size of r.size() plus the pen width.
4206 \sa drawRoundedRect()
4208 void QPainter::drawRoundRect(const QRectF &r, int xRnd, int yRnd)
4210 drawRoundedRect(r, xRnd, yRnd, Qt::RelativeSize);
4215 \fn void QPainter::drawRoundRect(const QRect &r, int xRnd = 25, int yRnd = 25)
4220 Draws the rectangle \a r with rounded corners.
4226 \fn QPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
4230 Draws the rectangle \a x, \a y, \a w, \a h with rounded corners.
4234 \fn void QPainter::drawEllipse(const QRectF &rectangle)
4236 Draws the ellipse defined by the given \a rectangle.
4238 A filled ellipse has a size of \a{rectangle}.\l
4239 {QRect::size()}{size()}. A stroked ellipse has a size of
4240 \a{rectangle}.\l {QRect::size()}{size()} plus the pen width.
4244 \o \inlineimage qpainter-ellipse.png
4246 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 9
4249 \sa drawPie(), {Coordinate System}
4251 void QPainter::drawEllipse(const QRectF &r)
4253 #ifdef QT_DEBUG_DRAW
4254 if (qt_show_painter_debug_output)
4255 printf("QPainter::drawEllipse(), [%.2f,%.2f,%.2f,%.2f]\n", r.x(), r.y(), r.width(), r.height());
4262 QRectF rect(r.normalized());
4265 d->extended->drawEllipse(rect);
4269 d->updateState(d->state);
4270 if (d->state->emulationSpecifier) {
4271 if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
4272 && d->state->matrix.type() == QTransform::TxTranslate) {
4273 rect.translate(QPointF(d->state->matrix.dx(), d->state->matrix.dy()));
4276 path.addEllipse(rect);
4277 d->draw_helper(path, QPainterPrivate::StrokeAndFillDraw);
4282 d->engine->drawEllipse(rect);
4286 \fn QPainter::drawEllipse(const QRect &rectangle)
4290 Draws the ellipse defined by the given \a rectangle.
4292 void QPainter::drawEllipse(const QRect &r)
4294 #ifdef QT_DEBUG_DRAW
4295 if (qt_show_painter_debug_output)
4296 printf("QPainter::drawEllipse(), [%d,%d,%d,%d]\n", r.x(), r.y(), r.width(), r.height());
4303 QRect rect(r.normalized());
4306 d->extended->drawEllipse(rect);
4310 d->updateState(d->state);
4312 if (d->state->emulationSpecifier) {
4313 if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
4314 && d->state->matrix.type() == QTransform::TxTranslate) {
4315 rect.translate(QPoint(qRound(d->state->matrix.dx()), qRound(d->state->matrix.dy())));
4318 path.addEllipse(rect);
4319 d->draw_helper(path, QPainterPrivate::StrokeAndFillDraw);
4324 d->engine->drawEllipse(rect);
4328 \fn QPainter::drawEllipse(int x, int y, int width, int height)
4332 Draws the ellipse defined by the rectangle beginning at (\a{x},
4333 \a{y}) with the given \a width and \a height.
4339 \fn QPainter::drawEllipse(const QPointF ¢er, qreal rx, qreal ry)
4343 Draws the ellipse positioned at \a{center} with radii \a{rx} and \a{ry}.
4349 \fn QPainter::drawEllipse(const QPoint ¢er, int rx, int ry)
4353 Draws the ellipse positioned at \a{center} with radii \a{rx} and \a{ry}.
4357 \fn void QPainter::drawArc(const QRectF &rectangle, int startAngle, int spanAngle)
4359 Draws the arc defined by the given \a rectangle, \a startAngle and
4362 The \a startAngle and \a spanAngle must be specified in 1/16th of
4363 a degree, i.e. a full circle equals 5760 (16 * 360). Positive
4364 values for the angles mean counter-clockwise while negative values
4365 mean the clockwise direction. Zero degrees is at the 3 o'clock
4370 \o \inlineimage qpainter-arc.png
4372 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 10
4375 \sa drawPie(), drawChord(), {Coordinate System}
4378 void QPainter::drawArc(const QRectF &r, int a, int alen)
4380 #ifdef QT_DEBUG_DRAW
4381 if (qt_show_painter_debug_output)
4382 printf("QPainter::drawArc(), [%.2f,%.2f,%.2f,%.2f], angle=%d, sweep=%d\n",
4383 r.x(), r.y(), r.width(), r.height(), a/16, alen/16);
4390 QRectF rect = r.normalized();
4393 path.arcMoveTo(rect, a/16.0);
4394 path.arcTo(rect, a/16.0, alen/16.0);
4395 strokePath(path, d->state->pen);
4398 /*! \fn void QPainter::drawArc(const QRect &rectangle, int startAngle,
4403 Draws the arc defined by the given \a rectangle, \a startAngle and
4408 \fn void QPainter::drawArc(int x, int y, int width, int height,
4409 int startAngle, int spanAngle)
4413 Draws the arc defined by the rectangle beginning at (\a x, \a y)
4414 with the specified \a width and \a height, and the given \a
4415 startAngle and \a spanAngle.
4419 \fn void QPainter::drawPie(const QRectF &rectangle, int startAngle, int spanAngle)
4421 Draws a pie defined by the given \a rectangle, \a startAngle and
4424 The pie is filled with the current brush().
4426 The startAngle and spanAngle must be specified in 1/16th of a
4427 degree, i.e. a full circle equals 5760 (16 * 360). Positive values
4428 for the angles mean counter-clockwise while negative values mean
4429 the clockwise direction. Zero degrees is at the 3 o'clock
4434 \o \inlineimage qpainter-pie.png
4436 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 11
4439 \sa drawEllipse(), drawChord(), {Coordinate System}
4441 void QPainter::drawPie(const QRectF &r, int a, int alen)
4443 #ifdef QT_DEBUG_DRAW
4444 if (qt_show_painter_debug_output)
4445 printf("QPainter::drawPie(), [%.2f,%.2f,%.2f,%.2f], angle=%d, sweep=%d\n",
4446 r.x(), r.y(), r.width(), r.height(), a/16, alen/16);
4457 if (a < 0) a += (360*16);
4460 QRectF rect = r.normalized();
4463 path.moveTo(rect.center());
4464 path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a/16.0, alen/16.0);
4465 path.closeSubpath();
4471 \fn void QPainter::drawPie(const QRect &rectangle, int startAngle, int spanAngle)
4474 Draws a pie defined by the given \a rectangle, \a startAngle and
4479 \fn void QPainter::drawPie(int x, int y, int width, int height, int
4480 startAngle, int spanAngle)
4484 Draws the pie defined by the rectangle beginning at (\a x, \a y) with
4485 the specified \a width and \a height, and the given \a startAngle and
4490 \fn void QPainter::drawChord(const QRectF &rectangle, int startAngle, int spanAngle)
4492 Draws the chord defined by the given \a rectangle, \a startAngle and
4493 \a spanAngle. The chord is filled with the current brush().
4495 The startAngle and spanAngle must be specified in 1/16th of a
4496 degree, i.e. a full circle equals 5760 (16 * 360). Positive values
4497 for the angles mean counter-clockwise while negative values mean
4498 the clockwise direction. Zero degrees is at the 3 o'clock
4503 \o \inlineimage qpainter-chord.png
4505 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 12
4508 \sa drawArc(), drawPie(), {Coordinate System}
4510 void QPainter::drawChord(const QRectF &r, int a, int alen)
4512 #ifdef QT_DEBUG_DRAW
4513 if (qt_show_painter_debug_output)
4514 printf("QPainter::drawChord(), [%.2f,%.2f,%.2f,%.2f], angle=%d, sweep=%d\n",
4515 r.x(), r.y(), r.width(), r.height(), a/16, alen/16);
4522 QRectF rect = r.normalized();
4525 path.arcMoveTo(rect, a/16.0);
4526 path.arcTo(rect, a/16.0, alen/16.0);
4527 path.closeSubpath();
4531 \fn void QPainter::drawChord(const QRect &rectangle, int startAngle, int spanAngle)
4535 Draws the chord defined by the given \a rectangle, \a startAngle and
4540 \fn void QPainter::drawChord(int x, int y, int width, int height, int
4541 startAngle, int spanAngle)
4545 Draws the chord defined by the rectangle beginning at (\a x, \a y)
4546 with the specified \a width and \a height, and the given \a
4547 startAngle and \a spanAngle.
4552 Draws the first \a lineCount lines in the array \a lines
4553 using the current pen.
4555 \sa drawLine(), drawPolyline()
4557 void QPainter::drawLines(const QLineF *lines, int lineCount)
4559 #ifdef QT_DEBUG_DRAW
4560 if (qt_show_painter_debug_output)
4561 printf("QPainter::drawLines(), line count=%d\n", lineCount);
4566 if (!d->engine || lineCount < 1)
4570 d->extended->drawLines(lines, lineCount);
4574 d->updateState(d->state);
4576 uint lineEmulation = line_emulation(d->state->emulationSpecifier);
4578 if (lineEmulation) {
4579 if (lineEmulation == QPaintEngine::PrimitiveTransform
4580 && d->state->matrix.type() == QTransform::TxTranslate) {
4581 for (int i = 0; i < lineCount; ++i) {
4582 QLineF line = lines[i];
4583 line.translate(d->state->matrix.dx(), d->state->matrix.dy());
4584 d->engine->drawLines(&line, 1);
4587 QPainterPath linePath;
4588 for (int i = 0; i < lineCount; ++i) {
4589 linePath.moveTo(lines[i].p1());
4590 linePath.lineTo(lines[i].p2());
4592 d->draw_helper(linePath, QPainterPrivate::StrokeDraw);
4596 d->engine->drawLines(lines, lineCount);
4600 \fn void QPainter::drawLines(const QLine *lines, int lineCount)
4603 Draws the first \a lineCount lines in the array \a lines
4604 using the current pen.
4606 void QPainter::drawLines(const QLine *lines, int lineCount)
4608 #ifdef QT_DEBUG_DRAW
4609 if (qt_show_painter_debug_output)
4610 printf("QPainter::drawLine(), line count=%d\n", lineCount);
4615 if (!d->engine || lineCount < 1)
4619 d->extended->drawLines(lines, lineCount);
4623 d->updateState(d->state);
4625 uint lineEmulation = line_emulation(d->state->emulationSpecifier);
4627 if (lineEmulation) {
4628 if (lineEmulation == QPaintEngine::PrimitiveTransform
4629 && d->state->matrix.type() == QTransform::TxTranslate) {
4630 for (int i = 0; i < lineCount; ++i) {
4631 QLineF line = lines[i];
4632 line.translate(d->state->matrix.dx(), d->state->matrix.dy());
4633 d->engine->drawLines(&line, 1);
4636 QPainterPath linePath;
4637 for (int i = 0; i < lineCount; ++i) {
4638 linePath.moveTo(lines[i].p1());
4639 linePath.lineTo(lines[i].p2());
4641 d->draw_helper(linePath, QPainterPrivate::StrokeDraw);
4645 d->engine->drawLines(lines, lineCount);
4651 Draws the first \a lineCount lines in the array \a pointPairs
4652 using the current pen. The lines are specified as pairs of points
4653 so the number of entries in \a pointPairs must be at least \a
4656 void QPainter::drawLines(const QPointF *pointPairs, int lineCount)
4658 Q_ASSERT(sizeof(QLineF) == 2*sizeof(QPointF));
4660 drawLines((QLineF*)pointPairs, lineCount);
4666 Draws the first \a lineCount lines in the array \a pointPairs
4667 using the current pen.
4669 void QPainter::drawLines(const QPoint *pointPairs, int lineCount)
4671 Q_ASSERT(sizeof(QLine) == 2*sizeof(QPoint));
4673 drawLines((QLine*)pointPairs, lineCount);
4678 \fn void QPainter::drawLines(const QVector<QPointF> &pointPairs)
4681 Draws a line for each pair of points in the vector \a pointPairs
4682 using the current pen. If there is an odd number of points in the
4683 array, the last point will be ignored.
4687 \fn void QPainter::drawLines(const QVector<QPoint> &pointPairs)
4690 Draws a line for each pair of points in the vector \a pointPairs
4691 using the current pen.
4695 \fn void QPainter::drawLines(const QVector<QLineF> &lines)
4698 Draws the set of lines defined by the list \a lines using the
4699 current pen and brush.
4703 \fn void QPainter::drawLines(const QVector<QLine> &lines)
4706 Draws the set of lines defined by the list \a lines using the
4707 current pen and brush.
4711 Draws the polyline defined by the first \a pointCount points in \a
4712 points using the current pen.
4714 Note that unlike the drawPolygon() function the last point is \e
4715 not connected to the first, neither is the polyline filled.
4720 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 13
4723 \sa drawLines(), drawPolygon(), {Coordinate System}
4725 void QPainter::drawPolyline(const QPointF *points, int pointCount)
4727 #ifdef QT_DEBUG_DRAW
4728 if (qt_show_painter_debug_output)
4729 printf("QPainter::drawPolyline(), count=%d\n", pointCount);
4733 if (!d->engine || pointCount < 2)
4737 d->extended->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
4741 d->updateState(d->state);
4743 uint lineEmulation = line_emulation(d->state->emulationSpecifier);
4745 if (lineEmulation) {
4747 // if (lineEmulation == QPaintEngine::PrimitiveTransform
4748 // && d->state->matrix.type() == QTransform::TxTranslate) {
4750 QPainterPath polylinePath(points[0]);
4751 for (int i=1; i<pointCount; ++i)
4752 polylinePath.lineTo(points[i]);
4753 d->draw_helper(polylinePath, QPainterPrivate::StrokeDraw);
4756 d->engine->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
4763 Draws the polyline defined by the first \a pointCount points in \a
4764 points using the current pen.
4766 void QPainter::drawPolyline(const QPoint *points, int pointCount)
4768 #ifdef QT_DEBUG_DRAW
4769 if (qt_show_painter_debug_output)
4770 printf("QPainter::drawPolyline(), count=%d\n", pointCount);
4774 if (!d->engine || pointCount < 2)
4778 d->extended->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
4782 d->updateState(d->state);
4784 uint lineEmulation = line_emulation(d->state->emulationSpecifier);
4786 if (lineEmulation) {
4788 // if (lineEmulation == QPaintEngine::PrimitiveTransform
4789 // && d->state->matrix.type() == QTransform::TxTranslate) {
4791 QPainterPath polylinePath(points[0]);
4792 for (int i=1; i<pointCount; ++i)
4793 polylinePath.lineTo(points[i]);
4794 d->draw_helper(polylinePath, QPainterPrivate::StrokeDraw);
4797 d->engine->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
4802 \fn void QPainter::drawPolyline(const QPolygon &polygon, int index, int
4808 Draws the polyline defined by the \a count lines of the given \a
4809 polygon starting at \a index (\a index defaults to 0).
4811 Use drawPolyline() combined with QPolygon::constData() instead.
4814 QPainter painter(this);
4815 painter.drawPolyline(polygon, index, count);
4817 int pointCount = (count == -1) ? polygon.size() - index : count;
4819 QPainter painter(this);
4820 painter.drawPolyline(polygon.constData() + index, pointCount);
4825 \fn void QPainter::drawPolyline(const QPolygonF &points)
4829 Draws the polyline defined by the given \a points using the
4834 \fn void QPainter::drawPolyline(const QPolygon &points)
4838 Draws the polyline defined by the given \a points using the
4843 Draws the polygon defined by the first \a pointCount points in the
4844 array \a points using the current pen and brush.
4848 \o \inlineimage qpainter-polygon.png
4850 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 14
4853 The first point is implicitly connected to the last point, and the
4854 polygon is filled with the current brush().
4856 If \a fillRule is Qt::WindingFill, the polygon is filled using the
4857 winding fill algorithm. If \a fillRule is Qt::OddEvenFill, the
4858 polygon is filled using the odd-even fill algorithm. See
4859 \l{Qt::FillRule} for a more detailed description of these fill
4862 \sa drawConvexPolygon(), drawPolyline(), {Coordinate System}
4864 void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule)
4866 #ifdef QT_DEBUG_DRAW
4867 if (qt_show_painter_debug_output)
4868 printf("QPainter::drawPolygon(), count=%d\n", pointCount);
4873 if (!d->engine || pointCount < 2)
4877 d->extended->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
4881 d->updateState(d->state);
4883 uint emulationSpecifier = d->state->emulationSpecifier;
4885 if (emulationSpecifier) {
4886 QPainterPath polygonPath(points[0]);
4887 for (int i=1; i<pointCount; ++i)
4888 polygonPath.lineTo(points[i]);
4889 polygonPath.closeSubpath();
4890 polygonPath.setFillRule(fillRule);
4891 d->draw_helper(polygonPath);
4895 d->engine->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
4900 Draws the polygon defined by the first \a pointCount points in the
4903 void QPainter::drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule)
4905 #ifdef QT_DEBUG_DRAW
4906 if (qt_show_painter_debug_output)
4907 printf("QPainter::drawPolygon(), count=%d\n", pointCount);
4912 if (!d->engine || pointCount < 2)
4916 d->extended->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
4920 d->updateState(d->state);
4922 uint emulationSpecifier = d->state->emulationSpecifier;
4924 if (emulationSpecifier) {
4925 QPainterPath polygonPath(points[0]);
4926 for (int i=1; i<pointCount; ++i)
4927 polygonPath.lineTo(points[i]);
4928 polygonPath.closeSubpath();
4929 polygonPath.setFillRule(fillRule);
4930 d->draw_helper(polygonPath);
4934 d->engine->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
4937 /*! \fn void QPainter::drawPolygon(const QPolygonF &polygon, bool winding, int index = 0,
4942 Use drawPolygon() combined with QPolygonF::constData() instead.
4945 QPainter painter(this);
4946 painter.drawPolygon(polygon, winding, index, count);
4948 int pointCount = (count == -1) ? polygon.size() - index : count;
4949 int fillRule = winding ? Qt::WindingFill : Qt::OddEvenFill;
4951 QPainter painter(this);
4952 painter.drawPolygon( polygon.constData() + index, pointCount, fillRule);
4956 /*! \fn void QPainter::drawPolygon(const QPolygon &polygon, bool winding,
4957 int index = 0, int count = -1)
4962 Use drawPolygon() combined with QPolygon::constData() instead.
4965 QPainter painter(this);
4966 painter.drawPolygon(polygon, winding, index, count);
4968 int pointCount = (count == -1) ? polygon.size() - index : count;
4969 int fillRule = winding ? Qt::WindingFill : Qt::OddEvenFill;
4971 QPainter painter(this);
4972 painter.drawPolygon( polygon.constData() + index, pointCount, fillRule);
4976 /*! \fn void QPainter::drawPolygon(const QPolygonF &points, Qt::FillRule fillRule)
4980 Draws the polygon defined by the given \a points using the fill
4984 /*! \fn void QPainter::drawPolygon(const QPolygon &points, Qt::FillRule fillRule)
4988 Draws the polygon defined by the given \a points using the fill
4993 \fn void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)
4995 Draws the convex polygon defined by the first \a pointCount points
4996 in the array \a points using the current pen.
5000 \o \inlineimage qpainter-polygon.png
5002 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 15
5005 The first point is implicitly connected to the last point, and the
5006 polygon is filled with the current brush(). If the supplied
5007 polygon is not convex, i.e. it contains at least one angle larger
5008 than 180 degrees, the results are undefined.
5010 On some platforms (e.g. X11), the drawConvexPolygon() function can
5011 be faster than the drawPolygon() function.
5013 \sa drawPolygon(), drawPolyline(), {Coordinate System}
5017 \fn void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)
5020 Draws the convex polygon defined by the first \a pointCount points
5021 in the array \a points using the current pen.
5025 \fn void QPainter::drawConvexPolygon(const QPolygonF &polygon)
5029 Draws the convex polygon defined by \a polygon using the current
5034 \fn void QPainter::drawConvexPolygon(const QPolygon &polygon)
5037 Draws the convex polygon defined by \a polygon using the current
5042 \fn void QPainter::drawConvexPolygon(const QPolygonF &polygon, int
5048 Use drawConvexPolygon() combined with QPolygonF::constData()
5052 QPainter painter(this);
5053 painter.drawConvexPolygon(polygon, index, count);
5055 int pointCount = (count == -1) ? polygon.size() - index : count;
5057 QPainter painter(this);
5058 painter.drawConvexPolygon(polygon.constData() + index, pointCount);
5063 \fn void QPainter::drawConvexPolygon(const QPolygon &polygon, int
5069 Use drawConvexPolygon() combined with QPolygon::constData()
5073 QPainter painter(this);
5074 painter.drawConvexPolygon(polygon, index, count);
5076 int pointCount = (count == -1) ? polygon.size() - index : count;
5078 QPainter painter(this);
5079 painter.drawConvexPolygon(polygon.constData() + index, pointCount);
5083 void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)
5085 #ifdef QT_DEBUG_DRAW
5086 if (qt_show_painter_debug_output)
5087 printf("QPainter::drawConvexPolygon(), count=%d\n", pointCount);
5092 if (!d->engine || pointCount < 2)
5096 d->extended->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
5100 d->updateState(d->state);
5102 uint emulationSpecifier = d->state->emulationSpecifier;
5104 if (emulationSpecifier) {
5105 QPainterPath polygonPath(points[0]);
5106 for (int i=1; i<pointCount; ++i)
5107 polygonPath.lineTo(points[i]);
5108 polygonPath.closeSubpath();
5109 polygonPath.setFillRule(Qt::WindingFill);
5110 d->draw_helper(polygonPath);
5114 d->engine->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
5117 void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)
5119 #ifdef QT_DEBUG_DRAW
5120 if (qt_show_painter_debug_output)
5121 printf("QPainter::drawConvexPolygon(), count=%d\n", pointCount);
5126 if (!d->engine || pointCount < 2)
5130 d->extended->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
5134 d->updateState(d->state);
5136 uint emulationSpecifier = d->state->emulationSpecifier;
5138 if (emulationSpecifier) {
5139 QPainterPath polygonPath(points[0]);
5140 for (int i=1; i<pointCount; ++i)
5141 polygonPath.lineTo(points[i]);
5142 polygonPath.closeSubpath();
5143 polygonPath.setFillRule(Qt::WindingFill);
5144 d->draw_helper(polygonPath);
5148 d->engine->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
5151 static inline QPointF roundInDeviceCoordinates(const QPointF &p, const QTransform &m)
5153 return m.inverted().map(QPointF(m.map(p).toPoint()));
5157 \fn void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)
5159 Draws the rectangular portion \a source of the given \a pixmap
5160 into the given \a target in the paint device.
5162 \note The pixmap is scaled to fit the rectangle, if both the pixmap and rectangle size disagree.
5167 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 16
5170 If \a pixmap is a QBitmap it is drawn with the bits that are "set"
5171 using the pens color. If backgroundMode is Qt::OpaqueMode, the
5172 "unset" bits are drawn using the color of the background brush; if
5173 backgroundMode is Qt::TransparentMode, the "unset" bits are
5174 transparent. Drawing bitmaps with gradient or texture colors is
5179 void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
5181 #if defined QT_DEBUG_DRAW
5182 if (qt_show_painter_debug_output)
5183 printf("QPainter::drawPixmap(), p=[%.2f,%.2f], pix=[%d,%d]\n",
5185 pm.width(), pm.height());
5190 if (!d->engine || pm.isNull())
5194 qt_painter_thread_test(d->device->devType(), "drawPixmap()", true);
5198 d->extended->drawPixmap(p, pm);
5206 int h = pm.height();
5211 // Emulate opaque background for bitmaps
5212 if (d->state->bgMode == Qt::OpaqueMode && pm.isQBitmap()) {
5213 fillRect(QRectF(x, y, w, h), d->state->bgBrush.color());
5216 d->updateState(d->state);
5218 if ((d->state->matrix.type() > QTransform::TxTranslate
5219 && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
5220 || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
5221 || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
5224 // If there is no rotation involved we have to make sure we use the
5225 // antialiased and not the aliased coordinate system by rounding the coordinates.
5226 if (d->state->matrix.type() <= QTransform::TxScale) {
5227 const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
5232 setBackgroundMode(Qt::TransparentMode);
5233 setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
5234 QBrush brush(d->state->pen.color(), pm);
5237 setBrushOrigin(QPointF(0, 0));
5239 drawRect(pm.rect());
5242 if (!d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
5243 x += d->state->matrix.dx();
5244 y += d->state->matrix.dy();
5246 d->engine->drawPixmap(QRectF(x, y, w, h), pm, QRectF(0, 0, w, h));
5250 void QPainter::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
5252 #if defined QT_DEBUG_DRAW
5253 if (qt_show_painter_debug_output)
5254 printf("QPainter::drawPixmap(), target=[%.2f,%.2f,%.2f,%.2f], pix=[%d,%d], source=[%.2f,%.2f,%.2f,%.2f]\n",
5255 r.x(), r.y(), r.width(), r.height(),
5256 pm.width(), pm.height(),
5257 sr.x(), sr.y(), sr.width(), sr.height());
5261 if (!d->engine || pm.isNull())
5264 qt_painter_thread_test(d->device->devType(), "drawPixmap()", true);
5269 qreal w = r.width();
5270 qreal h = r.height();
5273 qreal sw = sr.width();
5274 qreal sh = sr.height();
5276 // Sanity-check clipping
5278 sw = pm.width() - sx;
5281 sh = pm.height() - sy;
5289 qreal w_ratio = sx * w/sw;
5297 qreal h_ratio = sy * h/sh;
5304 if (sw + sx > pm.width()) {
5305 qreal delta = sw - (pm.width() - sx);
5306 qreal w_ratio = delta * w/sw;
5311 if (sh + sy > pm.height()) {
5312 qreal delta = sh - (pm.height() - sy);
5313 qreal h_ratio = delta * h/sh;
5318 if (w == 0 || h == 0 || sw <= 0 || sh <= 0)
5322 d->extended->drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));
5326 // Emulate opaque background for bitmaps
5327 if (d->state->bgMode == Qt::OpaqueMode && pm.isQBitmap())
5328 fillRect(QRectF(x, y, w, h), d->state->bgBrush.color());
5330 d->updateState(d->state);
5332 if ((d->state->matrix.type() > QTransform::TxTranslate
5333 && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
5334 || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
5335 || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity))
5336 || ((sw != w || sh != h) && !d->engine->hasFeature(QPaintEngine::PixmapTransform)))
5339 // If there is no rotation involved we have to make sure we use the
5340 // antialiased and not the aliased coordinate system by rounding the coordinates.
5341 if (d->state->matrix.type() <= QTransform::TxScale) {
5342 const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
5347 if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
5355 scale(w / sw, h / sh);
5356 setBackgroundMode(Qt::TransparentMode);
5357 setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
5360 if (sw == pm.width() && sh == pm.height())
5361 brush = QBrush(d->state->pen.color(), pm);
5363 brush = QBrush(d->state->pen.color(), pm.copy(sx, sy, sw, sh));
5368 drawRect(QRectF(0, 0, sw, sh));
5371 if (!d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
5372 x += d->state->matrix.dx();
5373 y += d->state->matrix.dy();
5375 d->engine->drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));
5381 \fn void QPainter::drawPixmap(const QRect &target, const QPixmap &pixmap,
5382 const QRect &source)
5385 Draws the rectangular portion \a source of the given \a pixmap
5386 into the given \a target in the paint device.
5388 \note The pixmap is scaled to fit the rectangle, if both the pixmap and rectangle size disagree.
5392 \fn void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap,
5393 const QRectF &source)
5396 Draws the rectangular portion \a source of the given \a pixmap
5397 with its origin at the given \a point.
5401 \fn void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap,
5402 const QRect &source)
5406 Draws the rectangular portion \a source of the given \a pixmap
5407 with its origin at the given \a point.
5411 \fn void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap)
5414 Draws the given \a pixmap with its origin at the given \a point.
5418 \fn void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap)
5421 Draws the given \a pixmap with its origin at the given \a point.
5425 \fn void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap)
5429 Draws the given \a pixmap at position (\a{x}, \a{y}).
5433 \fn void QPainter::drawPixmap(const QRect &rectangle, const QPixmap &pixmap)
5436 Draws the given \a pixmap into the given \a rectangle.
5438 \note The pixmap is scaled to fit the rectangle, if both the pixmap and rectangle size disagree.
5442 \fn void QPainter::drawPixmap(int x, int y, int width, int height,
5443 const QPixmap &pixmap)
5447 Draws the \a pixmap into the rectangle at position (\a{x}, \a{y})
5448 with the given \a width and \a height.
5452 \fn void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pixmap,
5453 int sx, int sy, int sw, int sh)
5457 Draws the rectangular portion with the origin (\a{sx}, \a{sy}),
5458 width \a sw and height \a sh, of the given \a pixmap , at the
5459 point (\a{x}, \a{y}), with a width of \a w and a height of \a h.
5460 If sw or sh are equal to zero the width/height of the pixmap
5461 is used and adjusted by the offset sx/sy;
5465 \fn void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap,
5466 int sx, int sy, int sw, int sh)
5470 Draws a pixmap at (\a{x}, \a{y}) by copying a part of the given \a
5471 pixmap into the paint device.
5473 (\a{x}, \a{y}) specifies the top-left point in the paint device that is
5474 to be drawn onto. (\a{sx}, \a{sy}) specifies the top-left point in \a
5475 pixmap that is to be drawn. The default is (0, 0).
5477 (\a{sw}, \a{sh}) specifies the size of the pixmap that is to be drawn.
5478 The default, (0, 0) (and negative) means all the way to the
5479 bottom-right of the pixmap.
5482 void QPainter::drawImage(const QPointF &p, const QImage &image)
5486 if (!d->engine || image.isNull())
5490 d->extended->drawImage(p, image);
5497 int w = image.width();
5498 int h = image.height();
5500 d->updateState(d->state);
5502 if (((d->state->matrix.type() > QTransform::TxTranslate)
5503 && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
5504 || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
5505 || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
5508 // If there is no rotation involved we have to make sure we use the
5509 // antialiased and not the aliased coordinate system by rounding the coordinates.
5510 if (d->state->matrix.type() <= QTransform::TxScale) {
5511 const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
5516 setBackgroundMode(Qt::TransparentMode);
5517 setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
5518 QBrush brush(image);
5521 setBrushOrigin(QPointF(0, 0));
5523 drawRect(image.rect());
5528 if (d->state->matrix.type() == QTransform::TxTranslate
5529 && !d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
5530 x += d->state->matrix.dx();
5531 y += d->state->matrix.dy();
5534 d->engine->drawImage(QRectF(x, y, w, h), image, QRectF(0, 0, w, h), Qt::AutoColor);
5537 void QPainter::drawImage(const QRectF &targetRect, const QImage &image, const QRectF &sourceRect,
5538 Qt::ImageConversionFlags flags)
5542 if (!d->engine || image.isNull())
5545 qreal x = targetRect.x();
5546 qreal y = targetRect.y();
5547 qreal w = targetRect.width();
5548 qreal h = targetRect.height();
5549 qreal sx = sourceRect.x();
5550 qreal sy = sourceRect.y();
5551 qreal sw = sourceRect.width();
5552 qreal sh = sourceRect.height();
5554 // Sanity-check clipping
5556 sw = image.width() - sx;
5559 sh = image.height() - sy;
5567 qreal w_ratio = sx * w/sw;
5575 qreal h_ratio = sy * h/sh;
5582 if (sw + sx > image.width()) {
5583 qreal delta = sw - (image.width() - sx);
5584 qreal w_ratio = delta * w/sw;
5589 if (sh + sy > image.height()) {
5590 qreal delta = sh - (image.height() - sy);
5591 qreal h_ratio = delta * h/sh;
5596 if (w == 0 || h == 0 || sw <= 0 || sh <= 0)
5600 d->extended->drawImage(QRectF(x, y, w, h), image, QRectF(sx, sy, sw, sh), flags);
5604 d->updateState(d->state);
5606 if (((d->state->matrix.type() > QTransform::TxTranslate || (sw != w || sh != h))
5607 && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
5608 || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
5609 || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
5612 // If there is no rotation involved we have to make sure we use the
5613 // antialiased and not the aliased coordinate system by rounding the coordinates.
5614 if (d->state->matrix.type() <= QTransform::TxScale) {
5615 const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
5620 if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
5627 scale(w / sw, h / sh);
5628 setBackgroundMode(Qt::TransparentMode);
5629 setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
5630 QBrush brush(image);
5633 setBrushOrigin(QPointF(-sx, -sy));
5635 drawRect(QRectF(0, 0, sw, sh));
5640 if (d->state->matrix.type() == QTransform::TxTranslate
5641 && !d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
5642 x += d->state->matrix.dx();
5643 y += d->state->matrix.dy();
5646 d->engine->drawImage(QRectF(x, y, w, h), image, QRectF(sx, sy, sw, sh), flags);
5650 \fn void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs)
5652 Draws the glyphs represented by \a glyphs at \a position. The \a position gives the
5653 edge of the baseline for the string of glyphs. The glyphs will be retrieved from the font
5654 selected on \a glyphs and at offsets given by the positions in \a glyphs.
5658 \sa QGlyphRun::setRawFont(), QGlyphRun::setPositions(), QGlyphRun::setGlyphIndexes()
5660 #if !defined(QT_NO_RAWFONT)
5661 void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphRun)
5665 QRawFont font = glyphRun.rawFont();
5666 if (!font.isValid())
5669 QGlyphRunPrivate *glyphRun_d = QGlyphRunPrivate::get(glyphRun);
5671 const quint32 *glyphIndexes = glyphRun_d->glyphIndexData;
5672 const QPointF *glyphPositions = glyphRun_d->glyphPositionData;
5674 int count = qMin(glyphRun_d->glyphIndexDataSize, glyphRun_d->glyphPositionDataSize);
5675 QVarLengthArray<QFixedPoint, 128> fixedPointPositions(count);
5677 QRawFontPrivate *fontD = QRawFontPrivate::get(font);
5678 bool supportsTransformations;
5679 if (d->extended != 0) {
5680 supportsTransformations = d->extended->supportsTransformations(fontD->fontEngine->fontDef.pixelSize,
5683 supportsTransformations = d->engine->type() == QPaintEngine::CoreGraphics
5684 || d->state->matrix.isAffine();
5687 for (int i=0; i<count; ++i) {
5688 QPointF processedPosition = position + glyphPositions[i];
5689 if (!supportsTransformations)
5690 processedPosition = d->state->transform().map(processedPosition);
5691 fixedPointPositions[i] = QFixedPoint::fromPointF(processedPosition);
5694 d->drawGlyphs(glyphIndexes, fixedPointPositions.data(), count, font, glyphRun.overline(),
5695 glyphRun.underline(), glyphRun.strikeOut());
5698 void QPainterPrivate::drawGlyphs(const quint32 *glyphArray, QFixedPoint *positions,
5700 const QRawFont &font, bool overline, bool underline,
5707 QRawFontPrivate *fontD = QRawFontPrivate::get(font);
5708 QFontEngine *fontEngine = fontD->fontEngine;
5713 for (int i=0; i<glyphCount; ++i) {
5714 glyph_metrics_t gm = fontEngine->boundingBox(glyphArray[i]);
5715 if (i == 0 || leftMost > positions[i].x)
5716 leftMost = positions[i].x;
5718 // We don't support glyphs that do not share a common baseline. If this turns out to
5719 // be a relevant use case, then we need to find clusters of glyphs that share a baseline
5720 // and do a drawTextItemDecorations call per cluster.
5721 if (i == 0 || baseLine < positions[i].y)
5722 baseLine = positions[i].y;
5724 // We use the advance rather than the actual bounds to match the algorithm in drawText()
5725 if (i == 0 || rightMost < positions[i].x + gm.xoff)
5726 rightMost = positions[i].x + gm.xoff;
5729 QFixed width = rightMost - leftMost;
5731 if (extended != 0 && state->matrix.isAffine()) {
5732 QStaticTextItem staticTextItem;
5733 staticTextItem.color = state->pen.color();
5734 staticTextItem.font = state->font;
5735 staticTextItem.setFontEngine(fontEngine);
5736 staticTextItem.numGlyphs = glyphCount;
5737 staticTextItem.glyphs = reinterpret_cast<glyph_t *>(const_cast<glyph_t *>(glyphArray));
5738 staticTextItem.glyphPositions = positions;
5740 extended->drawStaticTextItem(&staticTextItem);
5742 QTextItemInt textItem;
5743 textItem.fontEngine = fontEngine;
5745 QVarLengthArray<QFixed, 128> advances(glyphCount);
5746 QVarLengthArray<QGlyphJustification, 128> glyphJustifications(glyphCount);
5747 QVarLengthArray<HB_GlyphAttributes, 128> glyphAttributes(glyphCount);
5748 qMemSet(glyphAttributes.data(), 0, glyphAttributes.size() * sizeof(HB_GlyphAttributes));
5749 qMemSet(advances.data(), 0, advances.size() * sizeof(QFixed));
5750 qMemSet(glyphJustifications.data(), 0, glyphJustifications.size() * sizeof(QGlyphJustification));
5752 textItem.glyphs.numGlyphs = glyphCount;
5753 textItem.glyphs.glyphs = reinterpret_cast<HB_Glyph *>(const_cast<quint32 *>(glyphArray));
5754 textItem.glyphs.offsets = positions;
5755 textItem.glyphs.advances_x = advances.data();
5756 textItem.glyphs.advances_y = advances.data();
5757 textItem.glyphs.justifications = glyphJustifications.data();
5758 textItem.glyphs.attributes = glyphAttributes.data();
5760 engine->drawTextItem(QPointF(0, 0), textItem);
5763 QTextItemInt::RenderFlags flags;
5765 flags |= QTextItemInt::Underline;
5767 flags |= QTextItemInt::Overline;
5769 flags |= QTextItemInt::StrikeOut;
5771 drawTextItemDecoration(q, QPointF(leftMost.toReal(), baseLine.toReal()),
5774 ? QTextCharFormat::SingleUnderline
5775 : QTextCharFormat::NoUnderline),
5776 flags, width.toReal(), QTextCharFormat());
5778 #endif // QT_NO_RAWFONT
5782 \fn void QPainter::drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText)
5786 Draws the \a staticText at the \a topLeftPosition.
5788 \note The y-position is used as the top of the font.
5793 \fn void QPainter::drawStaticText(int left, int top, const QStaticText &staticText)
5797 Draws the \a staticText at coordinates \a left and \a top.
5799 \note The y-position is used as the top of the font.
5803 \fn void QPainter::drawText(const QPointF &position, const QString &text)
5805 Draws the given \a text with the currently defined text direction,
5806 beginning at the given \a position.
5808 This function does not handle the newline character (\n), as it cannot
5809 break text into multiple lines, and it cannot display the newline character.
5810 Use the QPainter::drawText() overload that takes a rectangle instead
5811 if you want to draw multiple lines of text with the newline character, or
5812 if you want the text to be wrapped.
5814 By default, QPainter draws text anti-aliased.
5816 \note The y-position is used as the baseline of the font.
5819 void QPainter::drawText(const QPointF &p, const QString &str)
5821 drawText(p, str, 0, 0);
5827 Draws the given \a staticText at the given \a topLeftPosition.
5829 The text will be drawn using the font and the transformation set on the painter. If the
5830 font and/or transformation set on the painter are different from the ones used to initialize
5831 the layout of the QStaticText, then the layout will have to be recalculated. Use
5832 QStaticText::prepare() to initialize \a staticText with the font and transformation with which
5833 it will later be drawn.
5835 If \a topLeftPosition is not the same as when \a staticText was initialized, or when it was
5836 last drawn, then there will be a slight overhead when translating the text to its new position.
5838 \note If the painter's transformation is not affine, then \a staticText will be drawn using
5839 regular calls to drawText(), losing any potential for performance improvement.
5841 \note The y-position is used as the top of the font.
5845 void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText)
5848 if (!d->engine || staticText.text().isEmpty() || pen().style() == Qt::NoPen)
5851 QStaticTextPrivate *staticText_d =
5852 const_cast<QStaticTextPrivate *>(QStaticTextPrivate::get(&staticText));
5854 if (font() != staticText_d->font) {
5855 staticText_d->font = font();
5856 staticText_d->needsRelayout = true;
5859 // If we don't have an extended paint engine, or if the painter is projected,
5860 // we go through standard code path
5861 if (d->extended == 0 || !d->state->matrix.isAffine()) {
5862 staticText_d->paintText(topLeftPosition, this);
5866 bool supportsTransformations = d->extended->supportsTransformations(staticText_d->font.pixelSize(),
5868 if (supportsTransformations && !staticText_d->untransformedCoordinates) {
5869 staticText_d->untransformedCoordinates = true;
5870 staticText_d->needsRelayout = true;
5871 } else if (!supportsTransformations && staticText_d->untransformedCoordinates) {
5872 staticText_d->untransformedCoordinates = false;
5873 staticText_d->needsRelayout = true;
5876 // Don't recalculate entire layout because of translation, rather add the dx and dy
5877 // into the position to move each text item the correct distance.
5878 QPointF transformedPosition = topLeftPosition;
5879 if (!staticText_d->untransformedCoordinates)
5880 transformedPosition = transformedPosition * d->state->matrix;
5881 QTransform oldMatrix;
5883 // The translation has been applied to transformedPosition. Remove translation
5884 // component from matrix.
5885 if (d->state->matrix.isTranslating() && !staticText_d->untransformedCoordinates) {
5886 qreal m11 = d->state->matrix.m11();
5887 qreal m12 = d->state->matrix.m12();
5888 qreal m13 = d->state->matrix.m13();
5889 qreal m21 = d->state->matrix.m21();
5890 qreal m22 = d->state->matrix.m22();
5891 qreal m23 = d->state->matrix.m23();
5892 qreal m33 = d->state->matrix.m33();
5894 oldMatrix = d->state->matrix;
5895 d->state->matrix.setMatrix(m11, m12, m13,
5900 // If the transform is not identical to the text transform,
5901 // we have to relayout the text (for other transformations than plain translation)
5902 bool staticTextNeedsReinit = staticText_d->needsRelayout;
5903 if (!staticText_d->untransformedCoordinates && staticText_d->matrix != d->state->matrix) {
5904 staticText_d->matrix = d->state->matrix;
5905 staticTextNeedsReinit = true;
5908 // Recreate the layout of the static text because the matrix or font has changed
5909 if (staticTextNeedsReinit)
5910 staticText_d->init();
5912 if (transformedPosition != staticText_d->position) { // Translate to actual position
5913 QFixed fx = QFixed::fromReal(transformedPosition.x());
5914 QFixed fy = QFixed::fromReal(transformedPosition.y());
5915 QFixed oldX = QFixed::fromReal(staticText_d->position.x());
5916 QFixed oldY = QFixed::fromReal(staticText_d->position.y());
5917 for (int item=0; item<staticText_d->itemCount;++item) {
5918 QStaticTextItem *textItem = staticText_d->items + item;
5919 for (int i=0; i<textItem->numGlyphs; ++i) {
5920 textItem->glyphPositions[i].x += fx - oldX;
5921 textItem->glyphPositions[i].y += fy - oldY;
5923 textItem->userDataNeedsUpdate = true;
5926 staticText_d->position = transformedPosition;
5929 QPen oldPen = d->state->pen;
5930 QColor currentColor = oldPen.color();
5931 for (int i=0; i<staticText_d->itemCount; ++i) {
5932 QStaticTextItem *item = staticText_d->items + i;
5933 if (item->color.isValid() && currentColor != item->color) {
5934 setPen(item->color);
5935 currentColor = item->color;
5937 d->extended->drawStaticTextItem(item);
5939 qt_draw_decoration_for_glyphs(this, item->glyphs, item->glyphPositions,
5940 item->numGlyphs, item->fontEngine(), staticText_d->font,
5943 if (currentColor != oldPen.color())
5946 if (!staticText_d->untransformedCoordinates && oldMatrix.isTranslating())
5947 d->state->matrix = oldMatrix;
5953 void QPainter::drawText(const QPointF &p, const QString &str, int tf, int justificationPadding)
5955 #ifdef QT_DEBUG_DRAW
5956 if (qt_show_painter_debug_output)
5957 printf("QPainter::drawText(), pos=[%.2f,%.2f], str='%s'\n", p.x(), p.y(), str.toLatin1().constData());
5962 if (!d->engine || str.isEmpty() || pen().style() == Qt::NoPen)
5965 if (tf & Qt::TextBypassShaping) {
5966 // Skip harfbuzz complex shaping, shape using glyph advances only
5967 int len = str.length();
5968 int numGlyphs = len;
5969 QVarLengthGlyphLayoutArray glyphs(len);
5970 QFontEngine *fontEngine = d->state->font.d->engineForScript(QUnicodeTables::Common);
5971 if (!fontEngine->stringToCMap(str.data(), len, &glyphs, &numGlyphs, 0)) {
5972 glyphs.resize(numGlyphs);
5973 if (!fontEngine->stringToCMap(str.data(), len, &glyphs, &numGlyphs, 0))
5974 Q_ASSERT_X(false, Q_FUNC_INFO, "stringToCMap shouldn't fail twice");
5977 QTextItemInt gf(glyphs, &d->state->font, str.data(), len, fontEngine);
5978 drawTextItem(p, gf);
5982 QStackTextEngine engine(str, d->state->font);
5983 engine.option.setTextDirection(d->state->layoutDirection);
5984 if (tf & (Qt::TextForceLeftToRight|Qt::TextForceRightToLeft)) {
5985 engine.ignoreBidi = true;
5986 engine.option.setTextDirection((tf & Qt::TextForceLeftToRight) ? Qt::LeftToRight : Qt::RightToLeft);
5990 line.length = str.length();
5991 engine.shapeLine(line);
5993 int nItems = engine.layoutData->items.size();
5994 QVarLengthArray<int> visualOrder(nItems);
5995 QVarLengthArray<uchar> levels(nItems);
5996 for (int i = 0; i < nItems; ++i)
5997 levels[i] = engine.layoutData->items[i].analysis.bidiLevel;
5998 QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());
6000 if (justificationPadding > 0) {
6001 engine.option.setAlignment(Qt::AlignJustify);
6002 engine.forceJustification = true;
6003 // this works because justify() is only interested in the difference between width and textWidth
6004 line.width = justificationPadding;
6005 engine.justify(line);
6007 QFixed x = QFixed::fromReal(p.x());
6009 for (int i = 0; i < nItems; ++i) {
6010 int item = visualOrder[i];
6011 const QScriptItem &si = engine.layoutData->items.at(item);
6012 if (si.analysis.flags >= QScriptAnalysis::TabOrObject) {
6016 QFont f = engine.font(si);
6017 QTextItemInt gf(si, &f);
6018 gf.glyphs = engine.shapedGlyphs(&si);
6019 gf.chars = engine.layoutData->string.unicode() + si.position;
6020 gf.num_chars = engine.length(item);
6021 if (engine.forceJustification) {
6022 for (int j=0; j<gf.glyphs.numGlyphs; ++j)
6023 gf.width += gf.glyphs.effectiveAdvance(j);
6025 gf.width = si.width;
6027 gf.logClusters = engine.logClusters(&si);
6029 drawTextItem(QPointF(x.toReal(), p.y()), gf);
6035 void QPainter::drawText(const QRect &r, int flags, const QString &str, QRect *br)
6037 #ifdef QT_DEBUG_DRAW
6038 if (qt_show_painter_debug_output)
6039 printf("QPainter::drawText(), r=[%d,%d,%d,%d], flags=%d, str='%s'\n",
6040 r.x(), r.y(), r.width(), r.height(), flags, str.toLatin1().constData());
6045 if (!d->engine || str.length() == 0 || pen().style() == Qt::NoPen)
6049 d->updateState(d->state);
6052 qt_format_text(d->state->font, r, flags, 0, str, br ? &bounds : 0, 0, 0, 0, this);
6054 *br = bounds.toAlignedRect();
6058 \fn void QPainter::drawText(const QPoint &position, const QString &text)
6062 Draws the given \a text with the currently defined text direction,
6063 beginning at the given \a position.
6065 By default, QPainter draws text anti-aliased.
6067 \note The y-position is used as the baseline of the font.
6072 \fn void QPainter::drawText(const QRectF &rectangle, int flags, const QString &text, QRectF *boundingRect)
6075 Draws the given \a text within the provided \a rectangle.
6079 \o \inlineimage qpainter-text.png
6081 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 17
6084 The \a boundingRect (if not null) is set to the what the bounding rectangle
6085 should be in order to enclose the whole text. The \a flags argument is a bitwise
6086 OR of the following flags:
6098 \o Qt::TextSingleLine
6099 \o Qt::TextExpandTabs
6100 \o Qt::TextShowMnemonic
6102 \o Qt::TextIncludeTrailingSpaces
6105 \sa Qt::AlignmentFlag, Qt::TextFlag, boundingRect(), layoutDirection()
6107 By default, QPainter draws text anti-aliased.
6109 \note The y-coordinate of \a rectangle is used as the top of the font.
6111 void QPainter::drawText(const QRectF &r, int flags, const QString &str, QRectF *br)
6113 #ifdef QT_DEBUG_DRAW
6114 if (qt_show_painter_debug_output)
6115 printf("QPainter::drawText(), r=[%.2f,%.2f,%.2f,%.2f], flags=%d, str='%s'\n",
6116 r.x(), r.y(), r.width(), r.height(), flags, str.toLatin1().constData());
6121 if (!d->engine || str.length() == 0 || pen().style() == Qt::NoPen)
6125 d->updateState(d->state);
6127 qt_format_text(d->state->font, r, flags, 0, str, br, 0, 0, 0, this);
6131 \fn void QPainter::drawText(const QRect &rectangle, int flags, const QString &text, QRect *boundingRect)
6134 Draws the given \a text within the provided \a rectangle according
6135 to the specified \a flags. The \a boundingRect (if not null) is set to
6136 the what the bounding rectangle should be in order to enclose the whole text.
6138 By default, QPainter draws text anti-aliased.
6140 \note The y-coordinate of \a rectangle is used as the top of the font.
6144 \fn void QPainter::drawText(int x, int y, const QString &text)
6148 Draws the given \a text at position (\a{x}, \a{y}), using the painter's
6149 currently defined text direction.
6151 By default, QPainter draws text anti-aliased.
6153 \note The y-position is used as the baseline of the font.
6158 \fn void QPainter::drawText(int x, int y, int width, int height, int flags,
6159 const QString &text, QRect *boundingRect)
6163 Draws the given \a text within the rectangle with origin (\a{x},
6164 \a{y}), \a width and \a height.
6166 The \a boundingRect (if not null) is set to the actual bounding
6167 rectangle of the output. The \a flags argument is a bitwise OR of
6168 the following flags:
6179 \o Qt::TextSingleLine
6180 \o Qt::TextExpandTabs
6181 \o Qt::TextShowMnemonic
6185 By default, QPainter draws text anti-aliased.
6187 \note The y-position is used as the top of the font.
6189 \sa Qt::AlignmentFlag, Qt::TextFlag
6193 \fn void QPainter::drawText(const QRectF &rectangle, const QString &text,
6194 const QTextOption &option)
6197 Draws the given \a text in the \a rectangle specified using the \a option
6198 to control its positioning and orientation.
6200 By default, QPainter draws text anti-aliased.
6202 \note The y-coordinate of \a rectangle is used as the top of the font.
6204 void QPainter::drawText(const QRectF &r, const QString &text, const QTextOption &o)
6206 #ifdef QT_DEBUG_DRAW
6207 if (qt_show_painter_debug_output)
6208 printf("QPainter::drawText(), r=[%.2f,%.2f,%.2f,%.2f], str='%s'\n",
6209 r.x(), r.y(), r.width(), r.height(), text.toLatin1().constData());
6214 if (!d->engine || text.length() == 0 || pen().style() == Qt::NoPen)
6218 d->updateState(d->state);
6220 qt_format_text(d->state->font, r, 0, &o, text, 0, 0, 0, 0, this);
6224 \fn void QPainter::drawTextItem(int x, int y, const QTextItem &ti)
6231 \fn void QPainter::drawTextItem(const QPoint &p, const QTextItem &ti)
6236 Draws the text item \a ti at position \a p.
6240 \fn void QPainter::drawTextItem(const QPointF &p, const QTextItem &ti)
6245 Draws the text item \a ti at position \a p.
6247 This method ignores the painters background mode and
6248 color. drawText and qt_format_text have to do it themselves, as
6249 only they know the extents of the complete string.
6251 It ignores the font set on the painter as the text item has one of its own.
6253 The underline and strikeout parameters of the text items font are
6254 ignored aswell. You'll need to pass in the correct flags to get
6255 underlining and strikeout.
6258 static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen)
6260 const qreal radiusBase = qMax(qreal(1), maxRadius);
6262 QString key = QLatin1Literal("WaveUnderline-")
6263 % pen.color().name()
6264 % HexString<qreal>(radiusBase);
6267 if (QPixmapCache::find(key, pixmap))
6270 const qreal halfPeriod = qMax(qreal(2), qreal(radiusBase * 1.61803399)); // the golden ratio
6271 const int width = qCeil(100 / (2 * halfPeriod)) * (2 * halfPeriod);
6272 const int radius = qFloor(radiusBase);
6279 while (xs < width) {
6282 path.quadTo(xs - halfPeriod / 2, ys, xs, 0);
6285 pixmap = QPixmap(width, radius * 2);
6286 pixmap.fill(Qt::transparent);
6289 wavePen.setCapStyle(Qt::SquareCap);
6291 // This is to protect against making the line too fat, as happens on Mac OS X
6292 // due to it having a rather thick width for the regular underline.
6293 const qreal maxPenWidth = .8 * radius;
6294 if (wavePen.widthF() > maxPenWidth)
6295 wavePen.setWidth(maxPenWidth);
6297 QPainter imgPainter(&pixmap);
6298 imgPainter.setPen(wavePen);
6299 imgPainter.setRenderHint(QPainter::Antialiasing);
6300 imgPainter.translate(0, radius);
6301 imgPainter.drawPath(path);
6304 QPixmapCache::insert(key, pixmap);
6309 static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QFontEngine *fe,
6310 QTextCharFormat::UnderlineStyle underlineStyle,
6311 QTextItem::RenderFlags flags, qreal width,
6312 const QTextCharFormat &charFormat)
6314 if (underlineStyle == QTextCharFormat::NoUnderline
6315 && !(flags & (QTextItem::StrikeOut | QTextItem::Overline)))
6318 const QPen oldPen = painter->pen();
6319 const QBrush oldBrush = painter->brush();
6320 painter->setBrush(Qt::NoBrush);
6322 pen.setStyle(Qt::SolidLine);
6323 pen.setWidthF(fe->lineThickness().toReal());
6324 pen.setCapStyle(Qt::FlatCap);
6326 QLineF line(pos.x(), pos.y(), pos.x() + qFloor(width), pos.y());
6328 const qreal underlineOffset = fe->underlinePosition().toReal();
6329 // deliberately ceil the offset to avoid the underline coming too close to
6330 // the text above it.
6331 const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
6332 const qreal underlinePos = pos.y() + qCeil(underlineOffset) - aliasedCoordinateDelta;
6334 if (underlineStyle == QTextCharFormat::SpellCheckUnderline) {
6335 underlineStyle = QTextCharFormat::SpellCheckUnderline; // ### Qt5 QTextCharFormat::UnderlineStyle(QApplication::style()->styleHint(QStyle::SH_SpellCheckUnderlineStyle));
6338 if (underlineStyle == QTextCharFormat::WaveUnderline) {
6340 painter->translate(0, pos.y() + 1);
6342 QColor uc = charFormat.underlineColor();
6346 // Adapt wave to underlineOffset or pen width, whatever is larger, to make it work on all platforms
6347 const QPixmap wave = generateWavyPixmap(qMax(underlineOffset, pen.widthF()), pen);
6348 const int descent = (int) fe->descent().toReal();
6350 painter->setBrushOrigin(painter->brushOrigin().x(), 0);
6351 painter->fillRect(pos.x(), 0, qCeil(width), qMin(wave.height(), descent), wave);
6353 } else if (underlineStyle != QTextCharFormat::NoUnderline) {
6354 QLineF underLine(line.x1(), underlinePos, line.x2(), underlinePos);
6356 QColor uc = charFormat.underlineColor();
6360 pen.setStyle((Qt::PenStyle)(underlineStyle));
6361 painter->setPen(pen);
6362 painter->drawLine(underLine);
6365 pen.setStyle(Qt::SolidLine);
6366 pen.setColor(oldPen.color());
6368 if (flags & QTextItem::StrikeOut) {
6369 QLineF strikeOutLine = line;
6370 strikeOutLine.translate(0., - fe->ascent().toReal() / 3.);
6371 painter->setPen(pen);
6372 painter->drawLine(strikeOutLine);
6375 if (flags & QTextItem::Overline) {
6376 QLineF overLine = line;
6377 overLine.translate(0., - fe->ascent().toReal());
6378 painter->setPen(pen);
6379 painter->drawLine(overLine);
6382 painter->setPen(oldPen);
6383 painter->setBrush(oldBrush);
6386 Q_GUI_EXPORT void qt_draw_decoration_for_glyphs(QPainter *painter, const glyph_t *glyphArray,
6387 const QFixedPoint *positions, int glyphCount,
6388 QFontEngine *fontEngine, const QFont &font,
6389 const QTextCharFormat &charFormat)
6391 if (!(font.underline() || font.strikeOut() || font.overline()))
6397 for (int i=0; i<glyphCount; ++i) {
6398 glyph_metrics_t gm = fontEngine->boundingBox(glyphArray[i]);
6399 if (i == 0 || leftMost > positions[i].x)
6400 leftMost = positions[i].x;
6402 // We don't support glyphs that do not share a common baseline. If this turns out to
6403 // be a relevant use case, then we need to find clusters of glyphs that share a baseline
6404 // and do a drawTextItemDecorations call per cluster.
6405 if (i == 0 || baseLine < positions[i].y)
6406 baseLine = positions[i].y;
6408 // We use the advance rather than the actual bounds to match the algorithm in drawText()
6409 if (i == 0 || rightMost < positions[i].x + gm.xoff)
6410 rightMost = positions[i].x + gm.xoff;
6413 QFixed width = rightMost - leftMost;
6414 QTextItem::RenderFlags flags = 0;
6416 if (font.underline())
6417 flags |= QTextItem::Underline;
6418 if (font.overline())
6419 flags |= QTextItem::Overline;
6420 if (font.strikeOut())
6421 flags |= QTextItem::StrikeOut;
6423 drawTextItemDecoration(painter, QPointF(leftMost.toReal(), baseLine.toReal()),
6425 font.underline() ? QTextCharFormat::SingleUnderline
6426 : QTextCharFormat::NoUnderline, flags,
6427 width.toReal(), charFormat);
6430 void QPainter::drawTextItem(const QPointF &p, const QTextItem &_ti)
6432 #ifdef QT_DEBUG_DRAW
6433 if (qt_show_painter_debug_output)
6434 printf("QPainter::drawTextItem(), pos=[%.f,%.f], str='%s'\n",
6435 p.x(), p.y(), qPrintable(_ti.text()));
6444 qt_painter_thread_test(d->device->devType(),
6446 QFontDatabase::supportsThreadedFontRendering());
6449 QTextItemInt &ti = const_cast<QTextItemInt &>(static_cast<const QTextItemInt &>(_ti));
6451 if (!d->extended && d->state->bgMode == Qt::OpaqueMode) {
6452 QRectF rect(p.x(), p.y() - ti.ascent.toReal(), ti.width.toReal(), (ti.ascent + ti.descent + 1).toReal());
6453 fillRect(rect, d->state->bgBrush);
6456 if (pen().style() == Qt::NoPen)
6459 const RenderHints oldRenderHints = d->state->renderHints;
6460 if (!d->state->renderHints & QPainter::Antialiasing && d->state->matrix.type() >= QTransform::TxScale) {
6461 // draw antialias decoration (underline/overline/strikeout) with
6465 const QTransform &m = d->state->matrix;
6466 if (d->state->matrix.type() < QTransform::TxShear) {
6467 bool isPlain90DegreeRotation =
6468 (qFuzzyIsNull(m.m11())
6469 && qFuzzyIsNull(m.m12() - qreal(1))
6470 && qFuzzyIsNull(m.m21() + qreal(1))
6471 && qFuzzyIsNull(m.m22())
6474 (qFuzzyIsNull(m.m11() + qreal(1))
6475 && qFuzzyIsNull(m.m12())
6476 && qFuzzyIsNull(m.m21())
6477 && qFuzzyIsNull(m.m22() + qreal(1))
6480 (qFuzzyIsNull(m.m11())
6481 && qFuzzyIsNull(m.m12() + qreal(1))
6482 && qFuzzyIsNull(m.m21() - qreal(1))
6483 && qFuzzyIsNull(m.m22())
6486 aa = !isPlain90DegreeRotation;
6489 setRenderHint(QPainter::Antialiasing, true);
6493 d->updateState(d->state);
6495 if (!ti.glyphs.numGlyphs) {
6497 } else if (ti.fontEngine->type() == QFontEngine::Multi) {
6498 QFontEngineMulti *multi = static_cast<QFontEngineMulti *>(ti.fontEngine);
6500 const QGlyphLayout &glyphs = ti.glyphs;
6501 int which = glyphs.glyphs[0] >> 24;
6508 for (end = 0; end < ti.glyphs.numGlyphs; ++end) {
6509 const int e = glyphs.glyphs[end] >> 24;
6514 QTextItemInt ti2 = ti.midItem(multi->engine(which), start, end - start);
6516 // set the high byte to zero and calc the width
6517 for (i = start; i < end; ++i) {
6518 glyphs.glyphs[i] = glyphs.glyphs[i] & 0xffffff;
6519 ti2.width += ti.glyphs.effectiveAdvance(i);
6522 d->engine->drawTextItem(QPointF(x, y), ti2);
6524 // reset the high byte for all glyphs and advance to the next sub-string
6525 const int hi = which << 24;
6526 for (i = start; i < end; ++i) {
6527 glyphs.glyphs[i] = hi | glyphs.glyphs[i];
6529 x += ti2.width.toReal();
6536 QTextItemInt ti2 = ti.midItem(multi->engine(which), start, end - start);
6538 // set the high byte to zero and calc the width
6539 for (i = start; i < end; ++i) {
6540 glyphs.glyphs[i] = glyphs.glyphs[i] & 0xffffff;
6541 ti2.width += ti.glyphs.effectiveAdvance(i);
6545 d->extended->drawTextItem(QPointF(x, y), ti2);
6547 d->engine->drawTextItem(QPointF(x,y), ti2);
6549 // reset the high byte for all glyphs
6550 const int hi = which << 24;
6551 for (i = start; i < end; ++i)
6552 glyphs.glyphs[i] = hi | glyphs.glyphs[i];
6556 d->extended->drawTextItem(p, ti);
6558 d->engine->drawTextItem(p, ti);
6560 drawTextItemDecoration(this, p, ti.fontEngine, ti.underlineStyle, ti.flags, ti.width.toReal(),
6563 if (d->state->renderHints != oldRenderHints) {
6564 d->state->renderHints = oldRenderHints;
6566 d->extended->renderHintsChanged();
6568 d->state->dirtyFlags |= QPaintEngine::DirtyHints;
6573 \fn QRectF QPainter::boundingRect(const QRectF &rectangle, int flags, const QString &text)
6575 Returns the bounding rectangle of the \a text as it will appear
6576 when drawn inside the given \a rectangle with the specified \a
6577 flags using the currently set font(); i.e the function tells you
6578 where the drawText() function will draw when given the same
6581 If the \a text does not fit within the given \a rectangle using
6582 the specified \a flags, the function returns the required
6585 The \a flags argument is a bitwise OR of the following flags:
6594 \o Qt::TextSingleLine
6595 \o Qt::TextExpandTabs
6596 \o Qt::TextShowMnemonic
6598 \o Qt::TextIncludeTrailingSpaces
6600 If several of the horizontal or several of the vertical alignment
6601 flags are set, the resulting alignment is undefined.
6603 \sa drawText(), Qt::Alignment, Qt::TextFlag
6607 \fn QRect QPainter::boundingRect(const QRect &rectangle, int flags,
6608 const QString &text)
6612 Returns the bounding rectangle of the \a text as it will appear
6613 when drawn inside the given \a rectangle with the specified \a
6614 flags using the currently set font().
6618 \fn QRect QPainter::boundingRect(int x, int y, int w, int h, int flags,
6619 const QString &text);
6623 Returns the bounding rectangle of the given \a text as it will
6624 appear when drawn inside the rectangle beginning at the point
6625 (\a{x}, \a{y}) with width \a w and height \a h.
6627 QRect QPainter::boundingRect(const QRect &rect, int flags, const QString &str)
6630 return QRect(rect.x(),rect.y(), 0,0);
6632 drawText(rect, flags | Qt::TextDontPrint, str, &brect);
6638 QRectF QPainter::boundingRect(const QRectF &rect, int flags, const QString &str)
6641 return QRectF(rect.x(),rect.y(), 0,0);
6643 drawText(rect, flags | Qt::TextDontPrint, str, &brect);
6648 \fn QRectF QPainter::boundingRect(const QRectF &rectangle,
6649 const QString &text, const QTextOption &option)
6653 Instead of specifying flags as a bitwise OR of the
6654 Qt::AlignmentFlag and Qt::TextFlag, this overloaded function takes
6655 an \a option argument. The QTextOption class provides a
6656 description of general rich text properties.
6660 QRectF QPainter::boundingRect(const QRectF &r, const QString &text, const QTextOption &o)
6664 if (!d->engine || text.length() == 0)
6665 return QRectF(r.x(),r.y(), 0,0);
6668 qt_format_text(d->state->font, r, Qt::TextDontPrint, &o, text, &br, 0, 0, 0, this);
6673 \fn void QPainter::drawTiledPixmap(const QRectF &rectangle, const QPixmap &pixmap, const QPointF &position)
6675 Draws a tiled \a pixmap, inside the given \a rectangle with its
6676 origin at the given \a position.
6678 Calling drawTiledPixmap() is similar to calling drawPixmap()
6679 several times to fill (tile) an area with a pixmap, but is
6680 potentially much more efficient depending on the underlying window
6685 void QPainter::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &sp)
6687 #ifdef QT_DEBUG_DRAW
6688 if (qt_show_painter_debug_output)
6689 printf("QPainter::drawTiledPixmap(), target=[%.2f,%.2f,%.2f,%.2f], pix=[%d,%d], offset=[%.2f,%.2f]\n",
6690 r.x(), r.y(), r.width(), r.height(),
6691 pixmap.width(), pixmap.height(),
6696 if (!d->engine || pixmap.isNull() || r.isEmpty())
6700 qt_painter_thread_test(d->device->devType(), "drawTiledPixmap()", true);
6703 qreal sw = pixmap.width();
6704 qreal sh = pixmap.height();
6708 sx = qRound(sw) - qRound(-sx) % qRound(sw);
6710 sx = qRound(sx) % qRound(sw);
6712 sy = qRound(sh) - -qRound(sy) % qRound(sh);
6714 sy = qRound(sy) % qRound(sh);
6718 d->extended->drawTiledPixmap(r, pixmap, QPointF(sx, sy));
6722 if (d->state->bgMode == Qt::OpaqueMode && pixmap.isQBitmap())
6723 fillRect(r, d->state->bgBrush);
6725 d->updateState(d->state);
6726 if ((d->state->matrix.type() > QTransform::TxTranslate
6727 && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
6728 || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
6731 setBackgroundMode(Qt::TransparentMode);
6732 setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
6733 setBrush(QBrush(d->state->pen.color(), pixmap));
6736 // If there is no rotation involved we have to make sure we use the
6737 // antialiased and not the aliased coordinate system by rounding the coordinates.
6738 if (d->state->matrix.type() <= QTransform::TxScale) {
6739 const QPointF p = roundInDeviceCoordinates(r.topLeft(), d->state->matrix);
6741 if (d->state->matrix.type() <= QTransform::TxTranslate) {
6746 setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
6747 drawRect(QRectF(p, r.size()));
6749 setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
6758 if (d->state->matrix.type() == QTransform::TxTranslate
6759 && !d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
6760 x += d->state->matrix.dx();
6761 y += d->state->matrix.dy();
6764 d->engine->drawTiledPixmap(QRectF(x, y, r.width(), r.height()), pixmap, QPointF(sx, sy));
6768 \fn QPainter::drawTiledPixmap(const QRect &rectangle, const QPixmap &pixmap,
6769 const QPoint &position = QPoint())
6772 Draws a tiled \a pixmap, inside the given \a rectangle with its
6773 origin at the given \a position.
6777 \fn void QPainter::drawTiledPixmap(int x, int y, int width, int height, const
6778 QPixmap &pixmap, int sx, int sy);
6781 Draws a tiled \a pixmap in the specified rectangle.
6783 (\a{x}, \a{y}) specifies the top-left point in the paint device
6784 that is to be drawn onto; with the given \a width and \a
6785 height. (\a{sx}, \a{sy}) specifies the top-left point in the \a
6786 pixmap that is to be drawn; this defaults to (0, 0).
6789 #ifndef QT_NO_PICTURE
6792 \fn void QPainter::drawPicture(const QPointF &point, const QPicture &picture)
6794 Replays the given \a picture at the given \a point.
6796 The QPicture class is a paint device that records and replays
6797 QPainter commands. A picture serializes the painter commands to an
6798 IO device in a platform-independent format. Everything that can be
6799 painted on a widget or pixmap can also be stored in a picture.
6801 This function does exactly the same as QPicture::play() when
6802 called with \a point = QPoint(0, 0).
6807 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 18
6810 \sa QPicture::play()
6813 void QPainter::drawPicture(const QPointF &p, const QPicture &picture)
6821 d->updateState(d->state);
6825 const_cast<QPicture *>(&picture)->play(this);
6830 \fn void QPainter::drawPicture(const QPoint &point, const QPicture &picture)
6833 Replays the given \a picture at the given \a point.
6837 \fn void QPainter::drawPicture(int x, int y, const QPicture &picture)
6840 Draws the given \a picture at point (\a x, \a y).
6843 #endif // QT_NO_PICTURE
6846 \fn void QPainter::eraseRect(const QRectF &rectangle)
6848 Erases the area inside the given \a rectangle. Equivalent to
6850 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 19
6854 void QPainter::eraseRect(const QRectF &r)
6858 fillRect(r, d->state->bgBrush);
6861 static inline bool needsResolving(const QBrush &brush)
6863 Qt::BrushStyle s = brush.style();
6864 return ((s == Qt::LinearGradientPattern || s == Qt::RadialGradientPattern ||
6865 s == Qt::ConicalGradientPattern) &&
6866 brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode);
6870 \fn void QPainter::eraseRect(const QRect &rectangle)
6873 Erases the area inside the given \a rectangle.
6877 \fn void QPainter::eraseRect(int x, int y, int width, int height)
6880 Erases the area inside the rectangle beginning at (\a x, \a y)
6881 with the given \a width and \a height.
6886 \fn void QPainter::fillRect(int x, int y, int width, int height, Qt::BrushStyle style)
6889 Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
6890 width and \a height, using the brush \a style specified.
6896 \fn void QPainter::fillRect(const QRect &rectangle, Qt::BrushStyle style)
6899 Fills the given \a rectangle with the brush \a style specified.
6905 \fn void QPainter::fillRect(const QRectF &rectangle, Qt::BrushStyle style)
6908 Fills the given \a rectangle with the brush \a style specified.
6914 \fn void QPainter::fillRect(const QRectF &rectangle, const QBrush &brush)
6916 Fills the given \a rectangle with the \a brush specified.
6918 Alternatively, you can specify a QColor instead of a QBrush; the
6919 QBrush constructor (taking a QColor argument) will automatically
6920 create a solid pattern brush.
6924 void QPainter::fillRect(const QRectF &r, const QBrush &brush)
6932 const QGradient *g = brush.gradient();
6933 if (!g || g->coordinateMode() == QGradient::LogicalMode) {
6934 d->extended->fillRect(r, brush);
6939 QPen oldPen = pen();
6940 QBrush oldBrush = this->brush();
6942 if (brush.style() == Qt::SolidPattern) {
6943 d->colorBrush.setStyle(Qt::SolidPattern);
6944 d->colorBrush.setColor(brush.color());
6945 setBrush(d->colorBrush);
6956 \fn void QPainter::fillRect(const QRect &rectangle, const QBrush &brush)
6959 Fills the given \a rectangle with the specified \a brush.
6962 void QPainter::fillRect(const QRect &r, const QBrush &brush)
6970 const QGradient *g = brush.gradient();
6971 if (!g || g->coordinateMode() == QGradient::LogicalMode) {
6972 d->extended->fillRect(r, brush);
6977 QPen oldPen = pen();
6978 QBrush oldBrush = this->brush();
6980 if (brush.style() == Qt::SolidPattern) {
6981 d->colorBrush.setStyle(Qt::SolidPattern);
6982 d->colorBrush.setColor(brush.color());
6983 setBrush(d->colorBrush);
6996 \fn void QPainter::fillRect(const QRect &rectangle, const QColor &color)
6999 Fills the given \a rectangle with the \a color specified.
7003 void QPainter::fillRect(const QRect &r, const QColor &color)
7011 d->extended->fillRect(r, color);
7015 fillRect(r, QBrush(color));
7020 \fn void QPainter::fillRect(const QRectF &rectangle, const QColor &color)
7023 Fills the given \a rectangle with the \a color specified.
7027 void QPainter::fillRect(const QRectF &r, const QColor &color)
7035 d->extended->fillRect(r, color);
7039 fillRect(r, QBrush(color));
7043 \fn void QPainter::fillRect(int x, int y, int width, int height, const QBrush &brush)
7047 Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
7048 width and \a height, using the given \a brush.
7052 \fn void QPainter::fillRect(int x, int y, int width, int height, const QColor &color)
7056 Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
7057 width and \a height, using the given \a color.
7063 \fn void QPainter::fillRect(int x, int y, int width, int height, Qt::GlobalColor color)
7067 Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
7068 width and \a height, using the given \a color.
7074 \fn void QPainter::fillRect(const QRect &rectangle, Qt::GlobalColor color);
7078 Fills the given \a rectangle with the specified \a color.
7084 \fn void QPainter::fillRect(const QRectF &rectangle, Qt::GlobalColor color);
7088 Fills the given \a rectangle with the specified \a color.
7094 Sets the given render \a hint on the painter if \a on is true;
7095 otherwise clears the render hint.
7097 \sa setRenderHints(), renderHints(), {QPainter#Rendering
7098 Quality}{Rendering Quality}
7100 void QPainter::setRenderHint(RenderHint hint, bool on)
7102 #ifdef QT_DEBUG_DRAW
7103 if (qt_show_painter_debug_output)
7104 printf("QPainter::setRenderHint: hint=%x, %s\n", hint, on ? "on" : "off");
7108 static const bool antialiasingDisabled = qgetenv("QT_NO_ANTIALIASING").toInt();
7109 if (hint == QPainter::Antialiasing && antialiasingDisabled)
7113 setRenderHints(hint, on);
7119 Sets the given render \a hints on the painter if \a on is true;
7120 otherwise clears the render hints.
7122 \sa setRenderHint(), renderHints(), {QPainter#Rendering
7123 Quality}{Rendering Quality}
7126 void QPainter::setRenderHints(RenderHints hints, bool on)
7131 qWarning("QPainter::setRenderHint: Painter must be active to set rendering hints");
7136 d->state->renderHints |= hints;
7138 d->state->renderHints &= ~hints;
7141 d->extended->renderHintsChanged();
7143 d->state->dirtyFlags |= QPaintEngine::DirtyHints;
7147 Returns a flag that specifies the rendering hints that are set for
7150 \sa testRenderHint(), {QPainter#Rendering Quality}{Rendering Quality}
7152 QPainter::RenderHints QPainter::renderHints() const
7154 Q_D(const QPainter);
7159 return d->state->renderHints;
7163 \fn bool QPainter::testRenderHint(RenderHint hint) const
7166 Returns true if \a hint is set; otherwise returns false.
7168 \sa renderHints(), setRenderHint()
7172 Returns true if view transformation is enabled; otherwise returns
7175 \sa setViewTransformEnabled(), worldTransform()
7178 bool QPainter::viewTransformEnabled() const
7180 Q_D(const QPainter);
7182 qWarning("QPainter::viewTransformEnabled: Painter not active");
7185 return d->state->VxF;
7189 \fn void QPainter::setWindow(const QRect &rectangle)
7191 Sets the painter's window to the given \a rectangle, and enables
7192 view transformations.
7194 The window rectangle is part of the view transformation. The
7195 window specifies the logical coordinate system. Its sister, the
7196 viewport(), specifies the device coordinate system.
7198 The default window rectangle is the same as the device's
7201 \sa window(), viewTransformEnabled(), {Coordinate
7202 System#Window-Viewport Conversion}{Window-Viewport Conversion}
7206 \fn void QPainter::setWindow(int x, int y, int width, int height)
7209 Sets the painter's window to the rectangle beginning at (\a x, \a
7210 y) and the given \a width and \a height.
7213 void QPainter::setWindow(const QRect &r)
7215 #ifdef QT_DEBUG_DRAW
7216 if (qt_show_painter_debug_output)
7217 printf("QPainter::setWindow(), [%d,%d,%d,%d]\n", r.x(), r.y(), r.width(), r.height());
7223 qWarning("QPainter::setWindow: Painter not active");
7227 d->state->wx = r.x();
7228 d->state->wy = r.y();
7229 d->state->ww = r.width();
7230 d->state->wh = r.height();
7232 d->state->VxF = true;
7237 Returns the window rectangle.
7239 \sa setWindow(), setViewTransformEnabled()
7242 QRect QPainter::window() const
7244 Q_D(const QPainter);
7246 qWarning("QPainter::window: Painter not active");
7249 return QRect(d->state->wx, d->state->wy, d->state->ww, d->state->wh);
7253 \fn void QPainter::setViewport(const QRect &rectangle)
7255 Sets the painter's viewport rectangle to the given \a rectangle,
7256 and enables view transformations.
7258 The viewport rectangle is part of the view transformation. The
7259 viewport specifies the device coordinate system. Its sister, the
7260 window(), specifies the logical coordinate system.
7262 The default viewport rectangle is the same as the device's
7265 \sa viewport(), viewTransformEnabled() {Coordinate
7266 System#Window-Viewport Conversion}{Window-Viewport Conversion}
7270 \fn void QPainter::setViewport(int x, int y, int width, int height)
7273 Sets the painter's viewport rectangle to be the rectangle
7274 beginning at (\a x, \a y) with the given \a width and \a height.
7277 void QPainter::setViewport(const QRect &r)
7279 #ifdef QT_DEBUG_DRAW
7280 if (qt_show_painter_debug_output)
7281 printf("QPainter::setViewport(), [%d,%d,%d,%d]\n", r.x(), r.y(), r.width(), r.height());
7287 qWarning("QPainter::setViewport: Painter not active");
7291 d->state->vx = r.x();
7292 d->state->vy = r.y();
7293 d->state->vw = r.width();
7294 d->state->vh = r.height();
7296 d->state->VxF = true;
7301 Returns the viewport rectangle.
7303 \sa setViewport(), setViewTransformEnabled()
7306 QRect QPainter::viewport() const
7308 Q_D(const QPainter);
7310 qWarning("QPainter::viewport: Painter not active");
7313 return QRect(d->state->vx, d->state->vy, d->state->vw, d->state->vh);
7316 /*! \fn bool QPainter::hasViewXForm() const
7319 Use viewTransformEnabled() instead.
7322 /*! \fn bool QPainter::hasWorldXForm() const
7325 Use worldMatrixEnabled() instead.
7328 /*! \fn void QPainter::resetXForm()
7331 Use resetTransform() instead.
7334 /*! \fn void QPainter::setViewXForm(bool enabled)
7337 Use setViewTransformEnabled() instead.
7340 /*! \fn void QPainter::setWorldXForm(bool enabled)
7343 Use setWorldMatrixEnabled() instead.
7346 Enables view transformations if \a enable is true, or disables
7347 view transformations if \a enable is false.
7349 \sa viewTransformEnabled(), {Coordinate System#Window-Viewport
7350 Conversion}{Window-Viewport Conversion}
7353 void QPainter::setViewTransformEnabled(bool enable)
7355 #ifdef QT_DEBUG_DRAW
7356 if (qt_show_painter_debug_output)
7357 printf("QPainter::setViewTransformEnabled(), enable=%d\n", enable);
7363 qWarning("QPainter::setViewTransformEnabled: Painter not active");
7367 if (enable == d->state->VxF)
7370 d->state->VxF = enable;
7379 Please use QWidget::render() instead.
7381 Redirects all paint commands for the given paint \a device, to the
7382 \a replacement device. The optional point \a offset defines an
7383 offset within the source device.
7385 The redirection will not be effective until the begin() function
7386 has been called; make sure to call end() for the given \a
7387 device's painter (if any) before redirecting. Call
7388 restoreRedirected() to restore the previous redirection.
7390 \warning Making use of redirections in the QPainter API implies
7391 that QPainter::begin() and QPaintDevice destructors need to hold
7392 a mutex for a short period. This can impact performance. Use of
7393 QWidget::render is strongly encouraged.
7395 \sa redirected(), restoreRedirected()
7397 void QPainter::setRedirected(const QPaintDevice *device,
7398 QPaintDevice *replacement,
7399 const QPoint &offset)
7401 Q_ASSERT(device != 0);
7403 qWarning() << "QPainter::setRedirected(): ignoring call to deprecated function, use QWidget::render() instead";
7411 Using QWidget::render() obsoletes the use of this function.
7413 Restores the previous redirection for the given \a device after a
7414 call to setRedirected().
7416 \warning Making use of redirections in the QPainter API implies
7417 that QPainter::begin() and QPaintDevice destructors need to hold
7418 a mutex for a short period. This can impact performance. Use of
7419 QWidget::render is strongly encouraged.
7423 void QPainter::restoreRedirected(const QPaintDevice *device)
7425 qWarning() << "QPainter::restoreRedirected(): ignoring call to deprecated function, use QWidget::render() instead";
7433 Using QWidget::render() obsoletes the use of this function.
7435 Returns the replacement for given \a device. The optional out
7436 parameter \a offset returns the offset within the replaced device.
7438 \warning Making use of redirections in the QPainter API implies
7439 that QPainter::begin() and QPaintDevice destructors need to hold
7440 a mutex for a short period. This can impact performance. Use of
7441 QWidget::render is strongly encouraged.
7443 \sa setRedirected(), restoreRedirected()
7445 QPaintDevice *QPainter::redirected(const QPaintDevice *device, QPoint *offset)
7450 void qt_format_text(const QFont &fnt, const QRectF &_r,
7451 int tf, const QString& str, QRectF *brect,
7452 int tabstops, int *ta, int tabarraylen,
7455 qt_format_text(fnt, _r,
7457 tabstops, ta, tabarraylen,
7460 void qt_format_text(const QFont &fnt, const QRectF &_r,
7461 int tf, const QTextOption *option, const QString& str, QRectF *brect,
7462 int tabstops, int *ta, int tabarraylen,
7466 Q_ASSERT( !((tf & ~Qt::TextDontPrint)!=0 && option!=0) ); // we either have an option or flags
7469 tf |= option->alignment();
7470 if (option->wrapMode() != QTextOption::NoWrap)
7471 tf |= Qt::TextWordWrap;
7473 if (option->flags() & QTextOption::IncludeTrailingSpaces)
7474 tf |= Qt::TextIncludeTrailingSpaces;
7476 if (option->tabStop() >= 0 || !option->tabArray().isEmpty())
7477 tf |= Qt::TextExpandTabs;
7480 // we need to copy r here to protect against the case (&r == brect).
7483 bool dontclip = (tf & Qt::TextDontClip);
7484 bool wordwrap = (tf & Qt::TextWordWrap) || (tf & Qt::TextWrapAnywhere);
7485 bool singleline = (tf & Qt::TextSingleLine);
7486 bool showmnemonic = (tf & Qt::TextShowMnemonic);
7487 bool hidemnmemonic = (tf & Qt::TextHideMnemonic);
7489 Qt::LayoutDirection layout_direction;
7490 if (tf & Qt::TextForceLeftToRight)
7491 layout_direction = Qt::LeftToRight;
7492 else if (tf & Qt::TextForceRightToLeft)
7493 layout_direction = Qt::RightToLeft;
7495 layout_direction = option->textDirection();
7497 layout_direction = painter->layoutDirection();
7499 layout_direction = Qt::LeftToRight;
7501 tf = QGuiApplicationPrivate::visualAlignment(layout_direction, QFlag(tf));
7503 bool isRightToLeft = layout_direction == Qt::RightToLeft;
7504 bool expandtabs = ((tf & Qt::TextExpandTabs) &&
7505 (((tf & Qt::AlignLeft) && !isRightToLeft) ||
7506 ((tf & Qt::AlignRight) && isRightToLeft)));
7509 tf |= Qt::TextDontPrint;
7511 uint maxUnderlines = 0;
7512 int numUnderlines = 0;
7513 QVarLengthArray<int, 32> underlinePositions(1);
7515 QFontMetricsF fm(fnt);
7518 start_lengthVariant:
7519 bool hasMoreLengthVariants = false;
7520 // compatible behaviour to the old implementation. Replace
7522 int old_offset = offset;
7523 for (; offset < text.length(); offset++) {
7524 QChar chr = text.at(offset);
7525 if (chr == QLatin1Char('\r') || (singleline && chr == QLatin1Char('\n'))) {
7526 text[offset] = QLatin1Char(' ');
7527 } else if (chr == QLatin1Char('\n')) {
7528 text[offset] = QChar::LineSeparator;
7529 } else if (chr == QLatin1Char('&')) {
7531 } else if (chr == QLatin1Char('\t')) {
7533 text[offset] = QLatin1Char(' ');
7534 } else if (!tabarraylen && !tabstops) {
7535 tabstops = qRound(fm.width(QLatin1Char('x'))*8);
7537 } else if (chr == QChar(ushort(0x9c))) {
7538 // string with multiple length variants
7539 hasMoreLengthVariants = true;
7544 int length = offset - old_offset;
7545 if ((hidemnmemonic || showmnemonic) && maxUnderlines > 0) {
7546 underlinePositions.resize(maxUnderlines + 1);
7548 QChar *cout = text.data() + old_offset;
7552 if (*cin == QLatin1Char('&')) {
7558 if (*cin != QLatin1Char('&') && !hidemnmemonic)
7559 underlinePositions[numUnderlines++] = cout - text.data() - old_offset;
7568 // no need to do extra work for underlines if we don't paint
7569 if (tf & Qt::TextDontPrint)
7572 underlinePositions[numUnderlines] = -1;
7576 QString finalText = text.mid(old_offset, length);
7577 QStackTextEngine engine(finalText, fnt);
7579 engine.option = *option;
7582 if (engine.option.tabStop() < 0 && tabstops > 0)
7583 engine.option.setTabStop(tabstops);
7585 if (engine.option.tabs().isEmpty() && ta) {
7587 for (int i = 0; i < tabarraylen; i++)
7588 tabs.append(qreal(ta[i]));
7589 engine.option.setTabArray(tabs);
7592 engine.option.setTextDirection(layout_direction);
7593 if (tf & Qt::AlignJustify)
7594 engine.option.setAlignment(Qt::AlignJustify);
7596 engine.option.setAlignment(Qt::AlignLeft); // do not do alignment twice
7598 if (!option && (tf & Qt::TextWrapAnywhere))
7599 engine.option.setWrapMode(QTextOption::WrapAnywhere);
7601 if (tf & Qt::TextJustificationForced)
7602 engine.forceJustification = true;
7603 QTextLayout textLayout(&engine);
7604 textLayout.setCacheEnabled(true);
7605 textLayout.engine()->underlinePositions = underlinePositions.data();
7607 if (finalText.isEmpty()) {
7608 height = fm.height();
7610 tf |= Qt::TextDontPrint;
7612 qreal lineWidth = 0x01000000;
7613 if (wordwrap || (tf & Qt::TextJustificationForced))
7614 lineWidth = qMax<qreal>(0, r.width());
7616 tf |= Qt::TextIncludeTrailingSpaces;
7617 textLayout.engine()->ignoreBidi = bool(tf & Qt::TextDontPrint);
7618 textLayout.beginLayout();
7620 qreal leading = fm.leading();
7624 QTextLine l = textLayout.createLine();
7628 l.setLineWidth(lineWidth);
7630 l.setPosition(QPointF(0., height));
7631 height += l.height();
7632 width = qMax(width, l.naturalTextWidth());
7633 if (!dontclip && !brect && height >= r.height())
7636 textLayout.endLayout();
7641 if (tf & Qt::AlignBottom) {
7642 yoff = r.height() - height;
7643 } else if (tf & Qt::AlignVCenter) {
7644 yoff = (r.height() - height)/2;
7646 QTransform::TransformationType type = painter->transform().type();
7647 if (type <= QTransform::TxScale) {
7648 // do the rounding manually to work around inconsistencies
7649 // in the paint engines when drawing on floating point offsets
7650 const qreal scale = painter->transform().m22();
7652 yoff = -qRound(-yoff * scale) / scale;
7656 if (tf & Qt::AlignRight) {
7657 xoff = r.width() - width;
7658 } else if (tf & Qt::AlignHCenter) {
7659 xoff = (r.width() - width)/2;
7661 QTransform::TransformationType type = painter->transform().type();
7662 if (type <= QTransform::TxScale) {
7663 // do the rounding manually to work around inconsistencies
7664 // in the paint engines when drawing on floating point offsets
7665 const qreal scale = painter->transform().m11();
7667 xoff = qRound(xoff * scale) / scale;
7671 QRectF bounds = QRectF(r.x() + xoff, r.y() + yoff, width, height);
7673 if (hasMoreLengthVariants && !(tf & Qt::TextLongestVariant) && !r.contains(bounds)) {
7675 goto start_lengthVariant;
7680 if (!(tf & Qt::TextDontPrint)) {
7681 bool restore = false;
7682 if (!dontclip && !r.contains(bounds)) {
7685 painter->setClipRect(r, Qt::IntersectClip);
7688 for (int i = 0; i < textLayout.lineCount(); i++) {
7689 QTextLine line = textLayout.lineAt(i);
7691 qreal advance = line.horizontalAdvance();
7693 if (tf & Qt::AlignRight) {
7694 QTextEngine *eng = textLayout.engine();
7695 xoff = r.width() - advance -
7696 eng->leadingSpaceWidth(eng->lines[line.lineNumber()]).toReal();
7698 else if (tf & Qt::AlignHCenter)
7699 xoff = (r.width() - advance) / 2;
7701 line.draw(painter, QPointF(r.x() + xoff, r.y() + yoff));
7711 Sets the layout direction used by the painter when drawing text,
7712 to the specified \a direction.
7714 The default is Qt::LayoutDirectionAuto, which will implicitly determine the
7715 direction from the text drawn.
7717 \sa QTextOption::setTextDirection(), layoutDirection(), drawText(), {QPainter#Settings}{Settings}
7719 void QPainter::setLayoutDirection(Qt::LayoutDirection direction)
7723 d->state->layoutDirection = direction;
7727 Returns the layout direction used by the painter when drawing text.
7729 \sa QTextOption::textDirection(), setLayoutDirection(), drawText(), {QPainter#Settings}{Settings}
7731 Qt::LayoutDirection QPainter::layoutDirection() const
7733 Q_D(const QPainter);
7734 return d->state ? d->state->layoutDirection : Qt::LayoutDirectionAuto;
7737 QPainterState::QPainterState(const QPainterState *s)
7738 : brushOrigin(s->brushOrigin), font(s->font), deviceFont(s->deviceFont),
7739 pen(s->pen), brush(s->brush), bgBrush(s->bgBrush),
7740 clipRegion(s->clipRegion), clipPath(s->clipPath),
7741 clipOperation(s->clipOperation),
7742 renderHints(s->renderHints), clipInfo(s->clipInfo),
7743 worldMatrix(s->worldMatrix), matrix(s->matrix), redirectionMatrix(s->redirectionMatrix),
7744 wx(s->wx), wy(s->wy), ww(s->ww), wh(s->wh),
7745 vx(s->vx), vy(s->vy), vw(s->vw), vh(s->vh),
7746 opacity(s->opacity), WxF(s->WxF), VxF(s->VxF),
7747 clipEnabled(s->clipEnabled), bgMode(s->bgMode), painter(s->painter),
7748 layoutDirection(s->layoutDirection),
7749 composition_mode(s->composition_mode),
7750 emulationSpecifier(s->emulationSpecifier), changeFlags(0)
7752 dirtyFlags = s->dirtyFlags;
7755 QPainterState::QPainterState()
7756 : brushOrigin(0, 0), bgBrush(Qt::white), clipOperation(Qt::NoClip),
7758 wx(0), wy(0), ww(0), wh(0), vx(0), vy(0), vw(0), vh(0),
7759 opacity(1), WxF(false), VxF(false), clipEnabled(true),
7760 bgMode(Qt::TransparentMode), painter(0),
7761 layoutDirection(QGuiApplication::layoutDirection()),
7762 composition_mode(QPainter::CompositionMode_SourceOver),
7763 emulationSpecifier(0), changeFlags(0)
7768 QPainterState::~QPainterState()
7772 void QPainterState::init(QPainter *p) {
7773 bgBrush = Qt::white;
7774 bgMode = Qt::TransparentMode;
7778 wx = wy = ww = wh = 0;
7779 vx = vy = vw = vh = 0;
7782 brushOrigin = QPointF(0, 0);
7784 font = deviceFont = QFont();
7785 clipRegion = QRegion();
7786 clipPath = QPainterPath();
7787 clipOperation = Qt::NoClip;
7789 worldMatrix.reset();
7791 layoutDirection = QGuiApplication::layoutDirection();
7792 composition_mode = QPainter::CompositionMode_SourceOver;
7793 emulationSpecifier = 0;
7801 \fn void QPainter::setBackgroundColor(const QColor &color)
7803 Use setBackground() instead.
7807 \fn const QColor &QPainter::backgroundColor() const
7809 Use background() and QBrush::color() instead.
7812 QColor myColor = backgroundColor();
7814 QColor myColor = background().color();
7817 Note that the background can be a complex brush such as a texture
7822 \fn void QPainter::drawText(int x, int y, const QString &text, int pos, int length)
7825 Use drawText() combined with QString::mid() instead.
7828 QPainter painter(this);
7829 painter.drawText(x, y, text, pos, length);
7831 QPainter painter(this);
7832 painter.drawText(x, y, text.mid(pos, length));
7837 \fn void QPainter::drawText(const QPoint &point, const QString &text, int pos, int length)
7840 Use drawText() combined with QString::mid() instead.
7843 QPainter painter(this);
7844 painter.drawText(point, text, pos, length);
7846 QPainter painter(this);
7847 painter.drawText(point, text.mid(pos, length));
7852 \fn void QPainter::drawText(int x, int y, const QString &text, int length)
7855 Use drawText() combined with QString::left() instead.
7858 QPainter painter(this);
7859 painter.drawText(x, y, text, length);
7861 QPainter painter(this);
7862 painter.drawText(x, y, text.left(length));
7867 \fn void QPainter::drawText(const QPoint &point, const QString &text, int length)
7870 Use drawText() combined with QString::left() instead.
7873 QPainter painter(this);
7874 painter.drawText(point, text, length);
7876 QPainter painter(this);
7877 painter.drawText(point, text.left(length));
7882 \fn bool QPainter::begin(QPaintDevice *device, const QWidget *init)
7885 Use begin() instead.
7887 If the paint \a device is a QWidget, QPainter is initialized after
7888 the widget's settings automatically. Otherwise, you must call the
7889 initFrom() function to initialize the painters pen, background and
7890 font to the same as any given widget.
7893 QPainter painter(this);
7894 painter.begin(device, init);
7896 QPainter painter(this);
7897 painter.begin(device);
7898 painter.initFrom(init);
7903 \fn void QPainter::drawImage(const QRectF &target, const QImage &image, const QRectF &source,
7904 Qt::ImageConversionFlags flags)
7906 Draws the rectangular portion \a source of the given \a image
7907 into the \a target rectangle in the paint device.
7909 \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
7911 If the image needs to be modified to fit in a lower-resolution
7912 result (e.g. converting from 32-bit to 8-bit), use the \a flags to
7913 specify how you would prefer this to happen.
7918 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 20
7925 \fn void QPainter::drawImage(const QRect &target, const QImage &image, const QRect &source,
7926 Qt::ImageConversionFlags flags)
7929 Draws the rectangular portion \a source of the given \a image
7930 into the \a target rectangle in the paint device.
7932 \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
7936 \fn void QPainter::drawImage(const QPointF &point, const QImage &image)
7940 Draws the given \a image at the given \a point.
7944 \fn void QPainter::drawImage(const QPoint &point, const QImage &image)
7948 Draws the given \a image at the given \a point.
7952 \fn void QPainter::drawImage(const QPointF &point, const QImage &image, const QRectF &source,
7953 Qt::ImageConversionFlags flags = 0)
7957 Draws the rectangular portion \a source of the given \a image with
7958 its origin at the given \a point.
7962 \fn void QPainter::drawImage(const QPoint &point, const QImage &image, const QRect &source,
7963 Qt::ImageConversionFlags flags = 0)
7966 Draws the rectangular portion \a source of the given \a image with
7967 its origin at the given \a point.
7971 \fn void QPainter::drawImage(const QRectF &rectangle, const QImage &image)
7975 Draws the given \a image into the given \a rectangle.
7977 \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
7981 \fn void QPainter::drawImage(const QRect &rectangle, const QImage &image)
7985 Draws the given \a image into the given \a rectangle.
7987 \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
7991 \fn void QPainter::drawImage(int x, int y, const QImage &image,
7992 int sx, int sy, int sw, int sh,
7993 Qt::ImageConversionFlags flags)
7996 Draws an image at (\a{x}, \a{y}) by copying a part of \a image into
7999 (\a{x}, \a{y}) specifies the top-left point in the paint device that is
8000 to be drawn onto. (\a{sx}, \a{sy}) specifies the top-left point in \a
8001 image that is to be drawn. The default is (0, 0).
8003 (\a{sw}, \a{sh}) specifies the size of the image that is to be drawn.
8004 The default, (0, 0) (and negative) means all the way to the
8005 bottom-right of the image.
8009 \fn void QPainter::redirect(QPaintDevice *pdev, QPaintDevice *replacement)
8011 Use setRedirected() instead.
8015 \fn QPaintDevice *QPainter::redirect(QPaintDevice *pdev)
8017 Use redirected() instead.
8021 \fn QRect QPainter::boundingRect(const QRect &rectangle, int flags,
8022 const QString &text, int length)
8025 Returns the bounding rectangle for the given \a length of the \a
8026 text constrained by the provided \a rectangle.
8028 Use boundingRect() combined with QString::left() instead.
8031 QRect rectangle = boundingRect(rect, flags, text, length);
8033 QRect rectangle = boundingRect(rect, flags, text.left(length));
8038 \fn void QPainter::drawText(const QRect &rectangle, int flags, const QString &text,
8039 int length, QRect *br)
8042 Use drawText() combined with QString::left() instead.
8045 QPainter painter(this);
8046 painter.drawText(rectangle, flags, text, length, br );
8048 QPainter painter(this);
8049 painter.drawText(rectangle, flags, text.left(length), br );
8054 \fn QRect QPainter::boundingRect(int x, int y, int width, int height, int flags,
8055 const QString &text, int length);
8059 Returns the bounding rectangle for the given \a length of the \a
8060 text constrained by the rectangle that begins at point (\a{x},
8061 \a{y}) with the given \a width and \a height.
8063 Use boundingRect() combined with QString::left() instead.
8066 QRect rectangle = boundingRect(x, y, width, height, flags, text, length);
8068 QRect rectangle = boundingRect(x, y, width, height, flags, text.left(length));
8073 \fn void QPainter::drawText(int x, int y, int width, int height, int flags,
8074 const QString &text, int length, QRect *br)
8078 Use drawText() combined with QString::left() instead.
8081 QPainter painter(this);
8082 painter.drawText(x, y, width, height, flags, text, length, br );
8084 QPainter painter(this);
8085 painter.drawText(x, y, width, height, flags, text.left(length), br );
8091 \class QPaintEngineState
8094 \brief The QPaintEngineState class provides information about the
8095 active paint engine's current state.
8098 QPaintEngineState records which properties that have changed since
8099 the last time the paint engine was updated, as well as their
8102 Which properties that have changed can at any time be retrieved
8103 using the state() function. This function returns an instance of
8104 the QPaintEngine::DirtyFlags type which stores an OR combination
8105 of QPaintEngine::DirtyFlag values. The QPaintEngine::DirtyFlag
8106 enum defines whether a property has changed since the last update
8109 If a property is marked with a dirty flag, its current value can
8110 be retrieved using the corresponding get function:
8115 \header \o Property Flag \o Current Property Value
8116 \row \o QPaintEngine::DirtyBackground \o backgroundBrush()
8117 \row \o QPaintEngine::DirtyBackgroundMode \o backgroundMode()
8118 \row \o QPaintEngine::DirtyBrush \o brush()
8119 \row \o QPaintEngine::DirtyBrushOrigin \o brushOrigin()
8120 \row \o QPaintEngine::DirtyClipRegion \e or QPaintEngine::DirtyClipPath
8122 \row \o QPaintEngine::DirtyClipPath \o clipPath()
8123 \row \o QPaintEngine::DirtyClipRegion \o clipRegion()
8124 \row \o QPaintEngine::DirtyCompositionMode \o compositionMode()
8125 \row \o QPaintEngine::DirtyFont \o font()
8126 \row \o QPaintEngine::DirtyTransform \o transform()
8127 \row \o QPaintEngine::DirtyClipEnabled \o isClipEnabled()
8128 \row \o QPaintEngine::DirtyPen \o pen()
8129 \row \o QPaintEngine::DirtyHints \o renderHints()
8132 The QPaintEngineState class also provide the painter() function
8133 which returns a pointer to the painter that is currently updating
8136 An instance of this class, representing the current state of the
8137 active paint engine, is passed as argument to the
8138 QPaintEngine::updateState() function. The only situation in which
8139 you will have to use this class directly is when implementing your
8147 \fn QPaintEngine::DirtyFlags QPaintEngineState::state() const
8149 Returns a combination of flags identifying the set of properties
8150 that need to be updated when updating the paint engine's state
8151 (i.e. during a call to the QPaintEngine::updateState() function).
8153 \sa QPaintEngine::updateState()
8158 Returns the pen in the current paint engine state.
8160 This variable should only be used when the state() returns a
8161 combination which includes the QPaintEngine::DirtyPen flag.
8163 \sa state(), QPaintEngine::updateState()
8166 QPen QPaintEngineState::pen() const
8168 return static_cast<const QPainterState *>(this)->pen;
8172 Returns the brush in the current paint engine state.
8174 This variable should only be used when the state() returns a
8175 combination which includes the QPaintEngine::DirtyBrush flag.
8177 \sa state(), QPaintEngine::updateState()
8180 QBrush QPaintEngineState::brush() const
8182 return static_cast<const QPainterState *>(this)->brush;
8186 Returns the brush origin in the current paint engine state.
8188 This variable should only be used when the state() returns a
8189 combination which includes the QPaintEngine::DirtyBrushOrigin flag.
8191 \sa state(), QPaintEngine::updateState()
8194 QPointF QPaintEngineState::brushOrigin() const
8196 return static_cast<const QPainterState *>(this)->brushOrigin;
8200 Returns the background brush in the current paint engine state.
8202 This variable should only be used when the state() returns a
8203 combination which includes the QPaintEngine::DirtyBackground flag.
8205 \sa state(), QPaintEngine::updateState()
8208 QBrush QPaintEngineState::backgroundBrush() const
8210 return static_cast<const QPainterState *>(this)->bgBrush;
8214 Returns the background mode in the current paint engine
8217 This variable should only be used when the state() returns a
8218 combination which includes the QPaintEngine::DirtyBackgroundMode flag.
8220 \sa state(), QPaintEngine::updateState()
8223 Qt::BGMode QPaintEngineState::backgroundMode() const
8225 return static_cast<const QPainterState *>(this)->bgMode;
8229 Returns the font in the current paint engine
8232 This variable should only be used when the state() returns a
8233 combination which includes the QPaintEngine::DirtyFont flag.
8235 \sa state(), QPaintEngine::updateState()
8238 QFont QPaintEngineState::font() const
8240 return static_cast<const QPainterState *>(this)->font;
8247 Returns the matrix in the current paint engine
8250 \note It is advisable to use transform() instead of this function to
8251 preserve the properties of perspective transformations.
8253 This variable should only be used when the state() returns a
8254 combination which includes the QPaintEngine::DirtyTransform flag.
8256 \sa state(), QPaintEngine::updateState()
8259 QMatrix QPaintEngineState::matrix() const
8261 const QPainterState *st = static_cast<const QPainterState *>(this);
8263 return st->matrix.toAffine();
8269 Returns the matrix in the current paint engine state.
8271 This variable should only be used when the state() returns a
8272 combination which includes the QPaintEngine::DirtyTransform flag.
8274 \sa state(), QPaintEngine::updateState()
8278 QTransform QPaintEngineState::transform() const
8280 const QPainterState *st = static_cast<const QPainterState *>(this);
8287 Returns the clip operation in the current paint engine
8290 This variable should only be used when the state() returns a
8291 combination which includes either the QPaintEngine::DirtyClipPath
8292 or the QPaintEngine::DirtyClipRegion flag.
8294 \sa state(), QPaintEngine::updateState()
8297 Qt::ClipOperation QPaintEngineState::clipOperation() const
8299 return static_cast<const QPainterState *>(this)->clipOperation;
8305 Returns whether the coordinate of the fill have been specified
8306 as bounded by the current rendering operation and have to be
8307 resolved (about the currently rendered primitive).
8309 bool QPaintEngineState::brushNeedsResolving() const
8311 const QBrush &brush = static_cast<const QPainterState *>(this)->brush;
8312 return needsResolving(brush);
8319 Returns whether the coordinate of the stroke have been specified
8320 as bounded by the current rendering operation and have to be
8321 resolved (about the currently rendered primitive).
8323 bool QPaintEngineState::penNeedsResolving() const
8325 const QPen &pen = static_cast<const QPainterState *>(this)->pen;
8326 return needsResolving(pen.brush());
8330 Returns the clip region in the current paint engine state.
8332 This variable should only be used when the state() returns a
8333 combination which includes the QPaintEngine::DirtyClipRegion flag.
8335 \sa state(), QPaintEngine::updateState()
8338 QRegion QPaintEngineState::clipRegion() const
8340 return static_cast<const QPainterState *>(this)->clipRegion;
8344 Returns the clip path in the current paint engine state.
8346 This variable should only be used when the state() returns a
8347 combination which includes the QPaintEngine::DirtyClipPath flag.
8349 \sa state(), QPaintEngine::updateState()
8352 QPainterPath QPaintEngineState::clipPath() const
8354 return static_cast<const QPainterState *>(this)->clipPath;
8358 Returns whether clipping is enabled or not in the current paint
8361 This variable should only be used when the state() returns a
8362 combination which includes the QPaintEngine::DirtyClipEnabled
8365 \sa state(), QPaintEngine::updateState()
8368 bool QPaintEngineState::isClipEnabled() const
8370 return static_cast<const QPainterState *>(this)->clipEnabled;
8374 Returns the render hints in the current paint engine state.
8376 This variable should only be used when the state() returns a
8377 combination which includes the QPaintEngine::DirtyHints
8380 \sa state(), QPaintEngine::updateState()
8383 QPainter::RenderHints QPaintEngineState::renderHints() const
8385 return static_cast<const QPainterState *>(this)->renderHints;
8389 Returns the composition mode in the current paint engine state.
8391 This variable should only be used when the state() returns a
8392 combination which includes the QPaintEngine::DirtyCompositionMode
8395 \sa state(), QPaintEngine::updateState()
8398 QPainter::CompositionMode QPaintEngineState::compositionMode() const
8400 return static_cast<const QPainterState *>(this)->composition_mode;
8405 Returns a pointer to the painter currently updating the paint
8409 QPainter *QPaintEngineState::painter() const
8411 return static_cast<const QPainterState *>(this)->painter;
8418 Returns the opacity in the current paint engine state.
8421 qreal QPaintEngineState::opacity() const
8423 return static_cast<const QPainterState *>(this)->opacity;
8429 Sets the world transformation matrix.
8430 If \a combine is true, the specified \a transform is combined with
8431 the current matrix; otherwise it replaces the current matrix.
8433 \sa transform() setWorldTransform()
8436 void QPainter::setTransform(const QTransform &transform, bool combine )
8438 setWorldTransform(transform, combine);
8442 Returns the world transformation matrix.
8444 \sa worldTransform()
8447 const QTransform & QPainter::transform() const
8449 return worldTransform();
8454 Returns the matrix that transforms from logical coordinates to
8455 device coordinates of the platform dependent paint device.
8457 This function is \e only needed when using platform painting
8458 commands on the platform dependent handle (Qt::HANDLE), and the
8459 platform does not do transformations nativly.
8461 The QPaintEngine::PaintEngineFeature enum can be queried to
8462 determine whether the platform performs the transformations or
8465 \sa worldTransform(), QPaintEngine::hasFeature(),
8468 const QTransform & QPainter::deviceTransform() const
8470 Q_D(const QPainter);
8472 qWarning("QPainter::deviceTransform: Painter not active");
8473 return d->fakeState()->transform;
8475 return d->state->matrix;
8480 Resets any transformations that were made using translate(),
8481 scale(), shear(), rotate(), setWorldTransform(), setViewport()
8484 \sa {Coordinate Transformations}
8487 void QPainter::resetTransform()
8490 #ifdef QT_DEBUG_DRAW
8491 if (qt_show_painter_debug_output)
8492 printf("QPainter::resetMatrix()\n");
8495 qWarning("QPainter::resetMatrix: Painter not active");
8499 d->state->wx = d->state->wy = d->state->vx = d->state->vy = 0; // default view origins
8500 d->state->ww = d->state->vw = d->device->metric(QPaintDevice::PdmWidth);
8501 d->state->wh = d->state->vh = d->device->metric(QPaintDevice::PdmHeight);
8502 d->state->worldMatrix = QTransform();
8503 setMatrixEnabled(false);
8504 setViewTransformEnabled(false);
8506 d->extended->transformChanged();
8508 d->state->dirtyFlags |= QPaintEngine::DirtyTransform;
8512 Sets the world transformation matrix.
8513 If \a combine is true, the specified \a matrix is combined with the current matrix;
8514 otherwise it replaces the current matrix.
8516 \sa transform(), setTransform()
8519 void QPainter::setWorldTransform(const QTransform &matrix, bool combine )
8524 qWarning("QPainter::setWorldTransform: Painter not active");
8529 d->state->worldMatrix = matrix * d->state->worldMatrix; // combines
8531 d->state->worldMatrix = matrix; // set new matrix
8533 d->state->WxF = true;
8538 Returns the world transformation matrix.
8541 const QTransform & QPainter::worldTransform() const
8543 Q_D(const QPainter);
8545 qWarning("QPainter::worldTransform: Painter not active");
8546 return d->fakeState()->transform;
8548 return d->state->worldMatrix;
8552 Returns the transformation matrix combining the current
8553 window/viewport and world transformation.
8555 \sa setWorldTransform(), setWindow(), setViewport()
8558 QTransform QPainter::combinedTransform() const
8560 Q_D(const QPainter);
8562 qWarning("QPainter::combinedTransform: Painter not active");
8563 return QTransform();
8565 return d->state->worldMatrix * d->viewTransform();
8571 This function is used to draw \a pixmap, or a sub-rectangle of \a pixmap,
8572 at multiple positions with different scale, rotation and opacity. \a
8573 fragments is an array of \a fragmentCount elements specifying the
8574 parameters used to draw each pixmap fragment. The \a hints
8575 parameter can be used to pass in drawing hints.
8577 This function is potentially faster than multiple calls to drawPixmap(),
8578 since the backend can optimize state changes.
8580 \sa QPainter::PixmapFragment, QPainter::PixmapFragmentHint
8583 void QPainter::drawPixmapFragments(const PixmapFragment *fragments, int fragmentCount,
8584 const QPixmap &pixmap, PixmapFragmentHints hints)
8588 if (!d->engine || pixmap.isNull())
8592 for (int i = 0; i < fragmentCount; ++i) {
8593 QRectF sourceRect(fragments[i].sourceLeft, fragments[i].sourceTop,
8594 fragments[i].width, fragments[i].height);
8595 if (!(QRectF(pixmap.rect()).contains(sourceRect)))
8596 qWarning("QPainter::drawPixmapFragments - the source rect is not contained by the pixmap's rectangle");
8600 if (d->engine->isExtended()) {
8601 d->extended->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
8603 qreal oldOpacity = opacity();
8604 QTransform oldTransform = transform();
8606 for (int i = 0; i < fragmentCount; ++i) {
8607 QTransform transform = oldTransform;
8610 if (fragments[i].rotation == 0) {
8611 xOffset = fragments[i].x;
8612 yOffset = fragments[i].y;
8614 transform.translate(fragments[i].x, fragments[i].y);
8615 transform.rotate(fragments[i].rotation);
8617 setOpacity(oldOpacity * fragments[i].opacity);
8618 setTransform(transform);
8620 qreal w = fragments[i].scaleX * fragments[i].width;
8621 qreal h = fragments[i].scaleY * fragments[i].height;
8622 QRectF sourceRect(fragments[i].sourceLeft, fragments[i].sourceTop,
8623 fragments[i].width, fragments[i].height);
8624 drawPixmap(QRectF(-0.5 * w + xOffset, -0.5 * h + yOffset, w, h), pixmap, sourceRect);
8627 setOpacity(oldOpacity);
8628 setTransform(oldTransform);
8634 \class QPainter::PixmapFragment
8636 \brief This class is used in conjunction with the
8637 QPainter::drawPixmapFragments() function to specify how a pixmap, or
8638 sub-rect of a pixmap, is drawn.
8640 The \a sourceLeft, \a sourceTop, \a width and \a height variables are used
8641 as a source rectangle within the pixmap passed into the
8642 QPainter::drawPixmapFragments() function. The variables \a x, \a y, \a
8643 width and \a height are used to calculate the target rectangle that is
8644 drawn. \a x and \a y denotes the center of the target rectangle. The \a
8645 width and \a height in the target rectangle is scaled by the \a scaleX and
8646 \a scaleY values. The resulting target rectangle is then rotated \a
8647 rotation degrees around the \a x, \a y center point.
8649 \sa QPainter::drawPixmapFragments()
8655 This is a convenience function that returns a QPainter::PixmapFragment that is
8656 initialized with the \a pos, \a sourceRect, \a scaleX, \a scaleY, \a
8657 rotation, \a opacity parameters.
8660 QPainter::PixmapFragment QPainter::PixmapFragment::create(const QPointF &pos, const QRectF &sourceRect,
8661 qreal scaleX, qreal scaleY, qreal rotation,
8664 PixmapFragment fragment = {pos.x(), pos.y(), sourceRect.x(), sourceRect.y(), sourceRect.width(),
8665 sourceRect.height(), scaleX, scaleY, rotation, opacity};
8670 \variable QPainter::PixmapFragment::x
8671 \brief the x coordinate of center point in the target rectangle.
8675 \variable QPainter::PixmapFragment::y
8676 \brief the y coordinate of the center point in the target rectangle.
8680 \variable QPainter::PixmapFragment::sourceLeft
8681 \brief the left coordinate of the source rectangle.
8685 \variable QPainter::PixmapFragment::sourceTop
8686 \brief the top coordinate of the source rectangle.
8690 \variable QPainter::PixmapFragment::width
8692 \brief the width of the source rectangle and is used to calculate the width
8693 of the target rectangle.
8697 \variable QPainter::PixmapFragment::height
8699 \brief the height of the source rectangle and is used to calculate the
8700 height of the target rectangle.
8704 \variable QPainter::PixmapFragment::scaleX
8705 \brief the horizontal scale of the target rectangle.
8709 \variable QPainter::PixmapFragment::scaleY
8710 \brief the vertical scale of the target rectangle.
8714 \variable QPainter::PixmapFragment::rotation
8716 \brief the rotation of the target rectangle in degrees. The target
8717 rectangle is rotated after it has been scaled.
8721 \variable QPainter::PixmapFragment::opacity
8723 \brief the opacity of the target rectangle, where 0.0 is fully transparent
8724 and 1.0 is fully opaque.
8730 \enum QPainter::PixmapFragmentHint
8732 \value OpaqueHint Indicates that the pixmap fragments to be drawn are
8733 opaque. Opaque fragments are potentially faster to draw.
8735 \sa QPainter::drawPixmapFragments(), QPainter::PixmapFragment
8738 void qt_draw_helper(QPainterPrivate *p, const QPainterPath &path, QPainterPrivate::DrawOperation operation)
8740 p->draw_helper(path, operation);
8743 /*! \fn Display *QPaintDevice::x11Display() const
8744 Use QX11Info::display() instead.
8747 Display *display = widget->x11Display();
8749 Display *display = QX11Info::display();
8752 \sa QWidget::x11Info(), QX11Info::display()
8755 /*! \fn int QPaintDevice::x11Screen() const
8756 Use QX11Info::screen() instead.
8759 int screen = widget->x11Screen();
8761 int screen = widget->x11Info().screen();
8764 \sa QWidget::x11Info(), QPixmap::x11Info()
8767 /*! \fn void *QPaintDevice::x11Visual() const
8768 Use QX11Info::visual() instead.
8771 void *visual = widget->x11Visual();
8773 void *visual = widget->x11Info().visual();
8776 \sa QWidget::x11Info(), QPixmap::x11Info()
8779 /*! \fn int QPaintDevice::x11Depth() const
8780 Use QX11Info::depth() instead.
8783 int depth = widget->x11Depth();
8785 int depth = widget->x11Info().depth();
8788 \sa QWidget::x11Info(), QPixmap::x11Info()
8791 /*! \fn int QPaintDevice::x11Cells() const
8792 Use QX11Info::cells() instead.
8795 int cells = widget->x11Cells();
8797 int cells = widget->x11Info().cells();
8800 \sa QWidget::x11Info(), QPixmap::x11Info()
8803 /*! \fn Qt::HANDLE QPaintDevice::x11Colormap() const
8804 Use QX11Info::colormap() instead.
8807 unsigned long screen = widget->x11Colormap();
8809 unsigned long screen = widget->x11Info().colormap();
8812 \sa QWidget::x11Info(), QPixmap::x11Info()
8815 /*! \fn bool QPaintDevice::x11DefaultColormap() const
8816 Use QX11Info::defaultColormap() instead.
8819 bool isDefault = widget->x11DefaultColormap();
8821 bool isDefault = widget->x11Info().defaultColormap();
8824 \sa QWidget::x11Info(), QPixmap::x11Info()
8827 /*! \fn bool QPaintDevice::x11DefaultVisual() const
8828 Use QX11Info::defaultVisual() instead.
8831 bool isDefault = widget->x11DefaultVisual();
8833 bool isDefault = widget->x11Info().defaultVisual();
8836 \sa QWidget::x11Info(), QPixmap::x11Info()
8839 /*! \fn void *QPaintDevice::x11AppVisual(int screen)
8840 Use QX11Info::visual() instead.
8843 void *visual = QPaintDevice::x11AppVisual(screen);
8845 void *visual = qApp->x11Info(screen).visual();
8848 \sa QWidget::x11Info(), QPixmap::x11Info()
8851 /*! \fn Qt::HANDLE QPaintDevice::x11AppColormap(int screen)
8852 Use QX11Info::colormap() instead.
8855 unsigned long colormap = QPaintDevice::x11AppColormap(screen);
8857 unsigned long colormap = qApp->x11Info(screen).colormap();
8860 \sa QWidget::x11Info(), QPixmap::x11Info()
8863 /*! \fn Display *QPaintDevice::x11AppDisplay()
8864 Use QX11Info::display() instead.
8867 Display *display = QPaintDevice::x11AppDisplay();
8869 Display *display = qApp->x11Info().display();
8872 \sa QWidget::x11Info(), QPixmap::x11Info()
8875 /*! \fn int QPaintDevice::x11AppScreen()
8876 Use QX11Info::screen() instead.
8879 int screen = QPaintDevice::x11AppScreen();
8881 int screen = qApp->x11Info().screen();
8884 \sa QWidget::x11Info(), QPixmap::x11Info()
8887 /*! \fn int QPaintDevice::x11AppDepth(int screen)
8888 Use QX11Info::depth() instead.
8891 int depth = QPaintDevice::x11AppDepth(screen);
8893 int depth = qApp->x11Info(screen).depth();
8896 \sa QWidget::x11Info(), QPixmap::x11Info()
8899 /*! \fn int QPaintDevice::x11AppCells(int screen)
8900 Use QX11Info::cells() instead.
8903 int cells = QPaintDevice::x11AppCells(screen);
8905 int cells = qApp->x11Info(screen).cells();
8908 \sa QWidget::x11Info(), QPixmap::x11Info()
8911 /*! \fn Qt::HANDLE QPaintDevice::x11AppRootWindow(int screen)
8912 Use QX11Info::appRootWindow() instead.
8915 unsigned long window = QPaintDevice::x11AppRootWindow(screen);
8917 unsigned long window = qApp->x11Info(screen).appRootWindow();
8920 \sa QWidget::x11Info(), QPixmap::x11Info()
8923 /*! \fn bool QPaintDevice::x11AppDefaultColormap(int screen)
8924 Use QX11Info::defaultColormap() instead.
8927 bool isDefault = QPaintDevice::x11AppDefaultColormap(screen);
8929 bool isDefault = qApp->x11Info(screen).defaultColormap();
8932 \sa QWidget::x11Info(), QPixmap::x11Info()
8935 /*! \fn bool QPaintDevice::x11AppDefaultVisual(int screen)
8936 Use QX11Info::defaultVisual() instead.
8939 bool isDefault = QPaintDevice::x11AppDefaultVisual(screen);
8941 bool isDefault = qApp->x11Info(screen).defaultVisual();
8944 \sa QWidget::x11Info(), QPixmap::x11Info()
8947 /*! \fn void QPaintDevice::x11SetAppDpiX(int dpi, int screen)
8948 Use QX11Info::setAppDpiX() instead.
8951 /*! \fn void QPaintDevice::x11SetAppDpiY(int dpi, int screen)
8952 Use QX11Info::setAppDpiY() instead.
8955 /*! \fn int QPaintDevice::x11AppDpiX(int screen)
8956 Use QX11Info::appDpiX() instead.
8959 bool isDefault = QPaintDevice::x11AppDpiX(screen);
8961 bool isDefault = qApp->x11Info(screen).appDpiX();
8964 \sa QWidget::x11Info(), QPixmap::x11Info()
8967 /*! \fn int QPaintDevice::x11AppDpiY(int screen)
8968 Use QX11Info::appDpiY() instead.
8971 bool isDefault = QPaintDevice::x11AppDpiY(screen);
8973 bool isDefault = qApp->x11Info(screen).appDpiY();
8976 \sa QWidget::x11Info(), QPixmap::x11Info()
8979 /*! \fn HDC QPaintDevice::getDC() const
8983 /*! \fn void QPaintDevice::releaseDC(HDC) const
8987 /*! \fn QWSDisplay *QPaintDevice::qwsDisplay()