src/gui/painting/qpainter.cpp File Reference

#include <qdebug.h>
#include <qmutex.h>
#include "qbitmap.h"
#include "qimage.h"
#include "qpaintdevice.h"
#include "qpaintengine.h"
#include "qpainter.h"
#include "qpainter_p.h"
#include "qpainterpath.h"
#include "qpicture.h"
#include "qpixmapcache.h"
#include "qpolygon.h"
#include "qtextlayout.h"
#include "qwidget.h"
#include "qapplication.h"
#include "qstyle.h"
#include "qthread.h"
#include "qvarlengtharray.h"
#include <private/qfontengine_p.h>
#include <private/qpaintengine_p.h>
#include <private/qpainterpath_p.h>
#include <private/qtextengine_p.h>
#include <private/qwidget_p.h>
#include <math.h>

Include dependency graph for qpainter.cpp:

Go to the source code of this file.

Classes
struct	QPaintDeviceRedirection
Defines
#define	QGradient_StretchToDevice   0x10000000
#define	QPaintEngine_OpaqueBackground   0x40000000
Typedefs
typedef QList< QPaintDeviceRedirection >	QPaintDeviceRedirectionList
Functions
QPixmap	qt_pixmapForBrush (int style, bool invert)
void	qt_format_text (const QFont &font, const QRectF &_r, int tf, const QTextOption *option, const QString &str, QRectF *brect, int tabstops, int *tabarray, int tabarraylen, QPainter *painter)
static bool	check_gradient (const QBrush &brush)
static bool	is_brush_transparent (const QBrush &brush)
static bool	is_pen_transparent (const QPen &pen)
static uint	line_emulation (uint emulation)
void	qt_painter_tread_test ()
static QPainterPath	generateWavyPath (qreal minWidth, QPaintDevice *device)
static void	drawTextItemDecoration (QPainter *painter, const QPointF &pos, const QTextItemInt &ti)
void	qt_painter_removePaintDevice (QPaintDevice *dev)
void	qt_format_text (const QFont &fnt, const QRectF &_r, int tf, const QString &str, QRectF *brect, int tabstops, int *ta, int tabarraylen, QPainter *painter)

---

Define Documentation

#define QGradient_StretchToDevice   0x10000000

Definition at line 54 of file qpainter.cpp.

Referenced by QPainterPrivate::draw_helper(), line_emulation(), and QPainterPrivate::updateEmulationSpecifier().

#define QPaintEngine_OpaqueBackground   0x40000000

Definition at line 55 of file qpainter.cpp.

Referenced by QPainterPrivate::draw_helper(), line_emulation(), and QPainterPrivate::updateEmulationSpecifier().

---

Typedef Documentation

typedef QList<QPaintDeviceRedirection> QPaintDeviceRedirectionList

Definition at line 5729 of file qpainter.cpp.

---

Function Documentation

static bool check_gradient

(

const QBrush &

brush

)

[inline, static]

Definition at line 70 of file qpainter.cpp.

References Qt::ConicalGradientPattern, QGradient::coordinateMode(), QBrush::gradient(), Qt::LinearGradientPattern, Qt::RadialGradientPattern, QGradient::StretchToDeviceMode, and QBrush::style().

Referenced by QPainterPrivate::drawStretchToDevice(), and QPainterPrivate::updateEmulationSpecifier().

{
    switch (brush.style()) {
    case Qt::LinearGradientPattern:
    case Qt::RadialGradientPattern:
    case Qt::ConicalGradientPattern:
        if (brush.gradient()->coordinateMode() == QGradient::StretchToDeviceMode)
            return true;
    default:
        ;
    }
    return false;
}

Here is the call graph for this function:

static void drawTextItemDecoration	(	QPainter *	painter,
		const QPointF &	pos,
		const QTextItemInt &	ti
	)			[static]

Definition at line 4621 of file qpainter.cpp.

References QPainter::Antialiasing, QFontEngine::ascent(), QPainter::brush(), ceil, QPen::color(), QPainter::device(), QPainter::drawLine(), QPainter::drawPath(), QTextItemInt::flags, QTextItemInt::fontEngine, generateWavyPath(), int, QColor::isValid(), QFontEngine::lineThickness(), Qt::NoBrush, QTextCharFormat::NoUnderline, QTextItem::Overline, QPainter::pen(), QPainter::restore(), QPainter::save(), QPainter::setBrush(), QPen::setColor(), QPainter::setPen(), QPainter::setRenderHint(), QPen::setStyle(), QPen::setWidthF(), QStyle::SH_SpellCheckUnderlineStyle, Qt::SolidLine, QTextCharFormat::SpellCheckUnderline, QTextItem::StrikeOut, QApplication::style(), styleHint(), QFixed::toReal(), QLineF::translate(), QPainter::translate(), QTextItemInt::underlineColor, QFontEngine::underlinePosition(), QTextItemInt::underlineStyle, QTextCharFormat::WaveUnderline, QTextItemInt::width, QPointF::x(), and QPointF::y().

Referenced by QPainter::drawTextItem().

{
    QFontEngine *fe = ti.fontEngine;

    const QPen oldPen = painter->pen();
    const QBrush oldBrush = painter->brush();
    painter->setBrush(Qt::NoBrush);
    QPen pen = oldPen;
    pen.setStyle(Qt::SolidLine);
    pen.setWidthF(fe->lineThickness().toReal());

    QLineF line(pos.x(), pos.y(), pos.x() + ti.width.toReal(), pos.y());
    // deliberately ceil the offset to avoid the underline coming too close to
    // the text above it.
    const int underlinePos = int(ceil(pos.y()) + ceil(fe->underlinePosition().toReal()));

    QTextCharFormat::UnderlineStyle underlineStyle = ti.underlineStyle;
    if (underlineStyle == QTextCharFormat::SpellCheckUnderline) {
        underlineStyle = QTextCharFormat::UnderlineStyle(QApplication::style()->styleHint(QStyle::SH_SpellCheckUnderlineStyle));
    }

    if (underlineStyle == QTextCharFormat::WaveUnderline) {
        painter->save();
        painter->setRenderHint(QPainter::Antialiasing);
        painter->translate(pos.x(), underlinePos);

        if (ti.underlineColor.isValid())
            painter->setPen(ti.underlineColor);

        painter->drawPath(generateWavyPath(ti.width.toReal(), painter->device()));
        painter->restore();
    } else if (underlineStyle != QTextCharFormat::NoUnderline) {
        QLineF underLine(line.x1(), underlinePos, line.x2(), underlinePos);

        if (ti.underlineColor.isValid())
            pen.setColor(ti.underlineColor);

        pen.setStyle((Qt::PenStyle)(underlineStyle));
        painter->setPen(pen);
        painter->drawLine(underLine);
    }

    pen.setStyle(Qt::SolidLine);
    pen.setColor(oldPen.color());

    if (ti.flags & QTextItem::StrikeOut) {
        QLineF strikeOutLine = line;
        strikeOutLine.translate(0., - fe->ascent().toReal() / 3.);
        painter->drawLine(strikeOutLine);
    }

    if (ti.flags & QTextItem::Overline) {
        QLineF overLine = line;
        overLine.translate(0., - fe->ascent().toReal());
        painter->drawLine(overLine);
    }

    painter->setPen(oldPen);
    painter->setBrush(oldBrush);
}

Here is the call graph for this function:

static QPainterPath generateWavyPath	(	qreal	minWidth,
		QPaintDevice *	device
	)			[static]

Definition at line 4595 of file qpainter.cpp.

References i, QPaintDevice::logicalDpiY(), path, and qt_defaultDpi().

Referenced by drawTextItemDecoration().

{
    extern int qt_defaultDpi();
    QPainterPath path;

    bool up = true;
    const int radius = 2 * device->logicalDpiY() / qt_defaultDpi();
    qreal xs, ys;
    int i = 0;
    do {
        int endAngle     = up ? -180  : 180;

        xs = i*(2*radius);
        ys = 0;

        // we need to move to the start of the new arc to not have the path
        // be implicitly connected for us
        path.arcMoveTo(xs, ys, 2*radius, 2*radius, 0);
        path.arcTo(xs, ys, 2*radius, 2*radius, 0, endAngle);
        up = !up;
        ++i;
    } while (xs + radius < minWidth);

    return path;
}

Here is the call graph for this function:

static bool is_brush_transparent

(

const QBrush &

brush

)

[inline, static]

Definition at line 84 of file qpainter.cpp.

References Qt::Dense1Pattern, Qt::DiagCrossPattern, QPixmap::isQBitmap(), s, QBrush::style(), QBrush::texture(), and Qt::TexturePattern.

Referenced by is_pen_transparent(), and QPainterPrivate::updateEmulationSpecifier().

                                                             {
    Qt::BrushStyle s = brush.style();
    return ((s >= Qt::Dense1Pattern && s <= Qt::DiagCrossPattern)
            || (s == Qt::TexturePattern && brush.texture().isQBitmap()));
}

Here is the call graph for this function:

static bool is_pen_transparent

(

const QPen &

pen

)

[inline, static]

Definition at line 90 of file qpainter.cpp.

References QPen::brush(), is_brush_transparent(), Qt::SolidLine, and QPen::style().

Referenced by QPainterPrivate::updateEmulationSpecifier().

                                                       {
    return pen.style() > Qt::SolidLine || is_brush_transparent(pen.brush());
}

Here is the call graph for this function:

static uint line_emulation

(

uint

emulation

)

[inline, static]

Definition at line 97 of file qpainter.cpp.

References QPaintEngine::AlphaBlend, QPaintEngine::Antialiasing, QPaintEngine::BrushStroke, QPaintEngine::ConstantOpacity, QPaintEngine::PrimitiveTransform, QGradient_StretchToDevice, and QPaintEngine_OpaqueBackground.

Referenced by QPainter::drawLines(), and QPainter::drawPolyline().

{
    return emulation & (QPaintEngine::PrimitiveTransform
                        | QPaintEngine::AlphaBlend
                        | QPaintEngine::Antialiasing
                        | QPaintEngine::BrushStroke
                        | QPaintEngine::ConstantOpacity
                        | QGradient_StretchToDevice
                        | QPaintEngine_OpaqueBackground);
}

void qt_format_text	(	const QFont &	fnt,
		const QRectF &	_r,
		int	tf,
		const QString &	str,
		QRectF *	brect,
		int	tabstops,
		int *	ta,
		int	tabarraylen,
		QPainter *	painter
	)

Definition at line 5822 of file qpainter.cpp.

References qt_format_text().

{
    qt_format_text(fnt, _r,
                    tf, 0, str, brect,
                    tabstops, ta, tabarraylen,
                    painter);
}

Here is the call graph for this function:

void qt_format_text	(	const QFont &	font,
		const QRectF &	_r,
		int	tf,
		const QTextOption *	option,
		const QString &	str,
		QRectF *	brect,
		int	tabstops,
		int *	tabarray,
		int	tabarraylen,
		QPainter *	painter
	)

Definition at line 5832 of file qpainter.cpp.

References Qt::AlignBottom, Qt::AlignHCenter, Qt::AlignLeft, Qt::AlignRight, Qt::AlignVCenter, QTextLayout::beginLayout(), QRectF::contains(), QTextLayout::createLine(), QString::data(), QTextLayout::endLayout(), QTextLayout::engine(), QRectF::height(), height, QFontMetricsF::height(), i, QTextEngine::ignoreBidi, Qt::IntersectClip, QString::isEmpty(), l, layout_direction, QPainter::layoutDirection(), QFontMetricsF::leading(), Qt::LeftToRight, QString::length(), QTextLayout::lineAt(), QTextLayout::lineCount(), QChar::LineSeparator, QTextEngine::option, qMax(), qRound(), QString::resize(), QPainter::restore(), Qt::RightToLeft, QPainter::save(), QTextLayout::setCacheEnabled(), QPainter::setClipRect(), QTextOption::setTextDirection(), QTextOption::setWrapMode(), QTextOption::textDirection(), Qt::TextDontClip, Qt::TextDontPrint, Qt::TextExpandTabs, Qt::TextHideMnemonic, Qt::TextIncludeTrailingSpaces, Qt::TextShowMnemonic, Qt::TextSingleLine, Qt::TextWordWrap, Qt::TextWrapAnywhere, QTextEngine::underlinePositions, QString::unicode(), QStyle::visualAlignment(), QRectF::width(), QFontMetricsF::width(), width, QTextOption::WrapAnywhere, QRectF::x(), and QRectF::y().

{
    // we need to copy r here to protect against the case (&r == brect).
    QRectF r(_r);

    bool dontclip  = (tf & Qt::TextDontClip);
    bool wordwrap  = (tf & Qt::TextWordWrap) || (tf & Qt::TextWrapAnywhere);
    bool singleline = (tf & Qt::TextSingleLine);
    bool showmnemonic = (tf & Qt::TextShowMnemonic);
    bool hidemnmemonic = (tf & Qt::TextHideMnemonic);

    Qt::LayoutDirection layout_direction;
    if(option)
        layout_direction = option->textDirection();
    else if (painter)
        layout_direction = painter->layoutDirection();
    else
        layout_direction = Qt::LeftToRight;

    tf = QStyle::visualAlignment(layout_direction, QFlag(tf));

    bool isRightToLeft = layout_direction == Qt::RightToLeft;
    bool expandtabs = ((tf & Qt::TextExpandTabs) &&
                        (((tf & Qt::AlignLeft) && !isRightToLeft) ||
                          ((tf & Qt::AlignRight) && isRightToLeft)));

    if (!painter)
        tf |= Qt::TextDontPrint;

    int maxUnderlines = 0;
    int numUnderlines = 0;
    int underlinePositionStack[32];
    int *underlinePositions = underlinePositionStack;

    QFontMetricsF fm(fnt);

    QString text = str;
    // compatible behaviour to the old implementation. Replace
    // tabs by spaces
    QChar *chr = text.data();
    const QChar *end = chr + str.length();
    bool has_tab = false;
    while (chr != end) {
        if (*chr == QLatin1Char('\r') || (singleline && *chr == QLatin1Char('\n'))) {
            *chr = QLatin1Char(' ');
        } else if (*chr == QLatin1Char('\n')) {
            *chr = QChar::LineSeparator;
        } else if (*chr == QLatin1Char('&')) {
            ++maxUnderlines;
        } else if (*chr == QLatin1Char('\t')) {
            has_tab = true;
        }
        ++chr;
    }
    if (has_tab) {
        if (!expandtabs) {
            chr = text.data();
            while (chr != end) {
                if (*chr == QLatin1Char('\t'))
                    *chr = QLatin1Char(' ');
                ++chr;
            }
        } else if (!tabarraylen && !tabstops) {
            tabstops = qRound(fm.width(QLatin1Char('x'))*8);
        }
    }

    if (hidemnmemonic || showmnemonic) {
        if (maxUnderlines > 32)
            underlinePositions = new int[maxUnderlines];
        QChar *cout = text.data();
        QChar *cin = cout;
        int l = str.length();
        while (l) {
            if (*cin == QLatin1Char('&')) {
                ++cin;
                --l;
                if (!l)
                    break;
                if (*cin != QLatin1Char('&') && !hidemnmemonic)
                    underlinePositions[numUnderlines++] = cout - text.unicode();
            }
            *cout = *cin;
            ++cout;
            ++cin;
            --l;
        }
        int newlen = cout - text.unicode();
        if (newlen != text.length())
            text.resize(newlen);
    }

    // no need to do extra work for underlines if we don't paint
    if (tf & Qt::TextDontPrint)
        numUnderlines = 0;

    underlinePositions[numUnderlines] = -1;
    qreal height = 0;
    qreal width = 0;

    QStackTextEngine engine(text, fnt);
    engine.option.setTextDirection(layout_direction);
    if (tf & Qt::TextWrapAnywhere)
        engine.option.setWrapMode(QTextOption::WrapAnywhere);
    QTextLayout textLayout(&engine);
    textLayout.setCacheEnabled(true);
    textLayout.engine()->underlinePositions = underlinePositions;

    if (text.isEmpty()) {
        height = fm.height();
        width = 0;
        tf |= Qt::TextDontPrint;
    } else {
        qreal lineWidth = wordwrap ? qMax<qreal>(0, r.width()) : 0x01000000;
        if(!wordwrap)
            tf |= Qt::TextIncludeTrailingSpaces;
        textLayout.engine()->ignoreBidi = (tf & Qt::TextDontPrint);
        textLayout.beginLayout();

        qreal leading = fm.leading();
        height = -leading;

        while (1) {
            QTextLine l = textLayout.createLine();
            if (!l.isValid())
                break;

            l.setLineWidth(lineWidth);
            height += leading;
            l.setPosition(QPointF(0., height));
            height += l.height();
            width = qMax(width, l.naturalTextWidth());
            if (!brect && height >= r.height())
                break;
        }
        textLayout.endLayout();
    }

    qreal yoff = 0;
    qreal xoff = 0;
    if (tf & Qt::AlignBottom)
        yoff = r.height() - height;
    else if (tf & Qt::AlignVCenter)
        yoff = (r.height() - height)/2;
    if (tf & Qt::AlignRight)
        xoff = r.width() - width;
    else if (tf & Qt::AlignHCenter)
        xoff = (r.width() - width)/2;
    QRectF bounds = QRectF(r.x() + xoff, r.y() + yoff, width, height);
    if (brect)
        *brect = bounds;

    if (!(tf & Qt::TextDontPrint)) {
        bool restore = false;
        if (!dontclip && !r.contains(bounds)) {
            restore = true;
            painter->save();
            painter->setClipRect(r, Qt::IntersectClip);
        }

        for (int i = 0; i < textLayout.lineCount(); i++) {
            QTextLine line = textLayout.lineAt(i);

            if (tf & Qt::AlignRight)
                xoff = r.width() - line.naturalTextWidth();
            else if (tf & Qt::AlignHCenter)
                xoff = (r.width() - line.naturalTextWidth())/2;

            line.draw(painter, QPointF(r.x() + xoff + line.x(), r.y() + yoff));
        }

        if (restore) {
            painter->restore();
        }
    }

    if (underlinePositions != underlinePositionStack)
        delete [] underlinePositions;
}

Here is the call graph for this function:

void qt_painter_removePaintDevice

(

QPaintDevice *

dev

)

Definition at line 5809 of file qpainter.cpp.

References i.

Referenced by QPaintDevice::~QPaintDevice().

{
    QMutexLocker locker(globalRedirectionsMutex());
    if(QPaintDeviceRedirectionList *redirections = globalRedirections()) {
        for (int i = 0; i < redirections->size(); ) {
            if(redirections->at(i) == dev || redirections->at(i).replacement == dev)
                redirections->removeAt(i);
            else
                ++i;
        }
    }
}

void qt_painter_tread_test

(

)

Definition at line 4589 of file qpainter.cpp.

References QThread::currentThread(), qApp, and qWarning().

Referenced by QPainter::drawTextItem().

{
    if (QThread::currentThread() != qApp->thread())
        qWarning("QPainter: It is not safe to use text and fonts outside the GUI thread");
}

Here is the call graph for this function:

QPixmap qt_pixmapForBrush	(	int	style,
		bool	invert
	)

Definition at line 76 of file qbrush.cpp.

References QPixmapCache::find(), QImage::Format_MonoLSB, QBitmap::fromData(), QPixmapCache::insert(), key, QString::number(), and qt_patternForBrush().

Referenced by getPatternFill(), and QX11PaintEngine::updateBrush().

{
    QPixmap pm;
    QString key = QLatin1String("$qt-brush$") + QString::number(brushStyle)
                  + QString::number((int)invert);
    if (!QPixmapCache::find(key, pm)) {
        pm = QBitmap::fromData(QSize(8, 8), qt_patternForBrush(brushStyle, invert),
                               QImage::Format_MonoLSB);
        QPixmapCache::insert(key, pm);
    }

    return pm;
}

Here is the call graph for this function:

---