QPainterPrivate Class Reference

#include <qpainter_p.h>

Collaboration diagram for QPainterPrivate:

[legend]List of all members.

---

Detailed Description

Definition at line 108 of file qpainter_p.h.

Public Types
enum	TransformationCodes
enum	DrawOperation
Public Member Functions
	QPainterPrivate (QPainter *painter)
	~QPainterPrivate ()
void	updateEmulationSpecifier (QPainterState *s)
void	updateState (QPainterState *state)
void	draw_helper (const QPainterPath &path, DrawOperation operation=StrokeAndFillDraw)
void	drawStretchToDevice (const QPainterPath &path, DrawOperation operation)
void	drawOpaqueBackground (const QPainterPath &path, DrawOperation operation)
void	updateMatrix ()
void	updateInvMatrix ()
void	init ()
int	rectSubtraction () const
QMatrix	viewMatrix () const
Public Attributes
QPainter *	q_ptr
QPoint	redirection_offset
QPainterState *	state
QVector< QPainterState * >	states
QMatrix	invMatrix
uint	txinv:1
QPaintDevice *	device
QPaintDevice *	original_device
QPaintEngine *	engine

---

Member Enumeration Documentation

enum QPainterPrivate::TransformationCodes

Definition at line 136 of file qpainter_p.h.

                             {
        TxNone = 0,
        TxTranslate = 1,
        TxScale = 2,
        TxRotShear = 3
    };

enum QPainterPrivate::DrawOperation

Definition at line 143 of file qpainter_p.h.

                       { StrokeDraw        = 0x1,
                         FillDraw          = 0x2,
                         StrokeAndFillDraw = 0x3
    };

---

Constructor & Destructor Documentation

QPainterPrivate::QPainterPrivate

(

QPainter *

painter

)

[inline]

Definition at line 112 of file qpainter_p.h.

References QVector< T >::back(), QVector< T >::push_back(), state, and states.

        : q_ptr(painter), txinv(0), device(0)
        , original_device(0), engine(0)
    {
        states.push_back(new QPainterState());
        state = states.back();
    }

Here is the call graph for this function:

QPainterPrivate::~QPainterPrivate

(

)

[inline]

Definition at line 120 of file qpainter_p.h.

References QVector< T >::at(), i, QVector< T >::size(), and states.

    {
        for (int i=0; i<states.size(); ++i)
            delete states.at(i);
    }

Here is the call graph for this function:

---

Member Function Documentation

void QPainterPrivate::updateEmulationSpecifier

(

QPainterState *

s

)

Definition at line 378 of file qpainter.cpp.

References alpha, QPaintEngine::AlphaBlend, QPaintEngine::BrushStroke, check_gradient(), QPaintEngine::ConicalGradientFill, Qt::ConicalGradientPattern, QPaintEngine::ConstantOpacity, QPaintEngine::DirtyBackgroundMode, QPaintEngine::DirtyBrush, QPaintEngine::DirtyHints, QPaintEngine::DirtyOpacity, QPaintEngine::DirtyPen, QPaintEngine::DirtyTransform, engine, QPaintEngine::hasFeature(), is_brush_transparent(), is_pen_transparent(), QPaintEngine::LinearGradientFill, Qt::LinearGradientPattern, QPaintEngine::MaskedBrush, QPainterState::opacity, Qt::OpaqueMode, QPaintEngine::PatternBrush, QPaintEngine::PatternTransform, QPaintEngine::PrimitiveTransform, qDebug(), QGradient_StretchToDevice, QPaintEngine_OpaqueBackground, QPaintEngine::RadialGradientFill, Qt::RadialGradientPattern, s, Qt::SolidPattern, state, Qt::TexturePattern, and TxTranslate.

Referenced by updateState().

{
    bool alpha = false;
    bool linearGradient = false;
    bool radialGradient = false;
    bool conicalGradient = false;
    bool patternBrush = false;
    bool xform = false;

    bool skip = true;

    // Pen and brush properties (we have to check both if one changes because the
    // one that's unchanged can still be in a state which requires emulation)
    if (s->state() & QPaintEngine::DirtyPen ||
        s->state() & QPaintEngine::DirtyBrush) {
        // Check Brush stroke emulation
        if (!s->pen.isSolid() && !engine->hasFeature(QPaintEngine::BrushStroke))
            s->emulationSpecifier |= QPaintEngine::BrushStroke;
        else
            s->emulationSpecifier &= ~QPaintEngine::BrushStroke;

        skip = false;

        QBrush penBrush = s->pen.brush();
        alpha = (!penBrush.isOpaque() || !s->brush.isOpaque());
        linearGradient = ((penBrush.style() == Qt::LinearGradientPattern) ||
                           (s->brush.style() == Qt::LinearGradientPattern));
        radialGradient = ((penBrush.style() == Qt::RadialGradientPattern) ||
                           (s->brush.style() == Qt::RadialGradientPattern));
        conicalGradient = ((penBrush.style() == Qt::ConicalGradientPattern) ||
                            (s->brush.style() == Qt::ConicalGradientPattern));
        patternBrush = (((penBrush.style() > Qt::SolidPattern
                           && penBrush.style() < Qt::LinearGradientPattern)
                          || s->brush.style() == Qt::TexturePattern) ||
                         ((s->brush.style() > Qt::SolidPattern
                           && s->brush.style() < Qt::LinearGradientPattern)
                          || s->brush.style() == Qt::TexturePattern));

        if (((penBrush.style() == Qt::TexturePattern && penBrush.texture().hasAlpha())
             || (s->brush.style() == Qt::TexturePattern && s->brush.texture().hasAlpha()))
            && !engine->hasFeature(QPaintEngine::MaskedBrush))
            s->emulationSpecifier |= QPaintEngine::MaskedBrush;
        else
            s->emulationSpecifier &= ~QPaintEngine::MaskedBrush;
    }

    if (s->state() & (QPaintEngine::DirtyHints
                      | QPaintEngine::DirtyOpacity
                      | QPaintEngine::DirtyBackgroundMode)) {
        skip = false;
    }

    if (skip)
        return;

#if 0
    qDebug("QPainterPrivate::updateEmulationSpecifier, state=%p\n"
           " - alpha: %d\n"
           " - linearGradient: %d\n"
           " - radialGradient: %d\n"
           " - conicalGradient: %d\n"
           " - patternBrush: %d\n"
           " - hints: %x\n"
           " - xform: %d\n",
           s,
           alpha,
           linearGradient,
           radialGradient,
           conicalGradient,
           patternBrush,
           uint(s->renderHints),
           xform);
#endif

    // XForm properties
    if (s->state() & QPaintEngine::DirtyTransform) {
        xform = !s->matrix.isIdentity();
    } else if (s->txop >= TxTranslate) {
        xform = true;
    }

    // Check alphablending
    if (alpha && !engine->hasFeature(QPaintEngine::AlphaBlend))
        s->emulationSpecifier |= QPaintEngine::AlphaBlend;
    else
        s->emulationSpecifier &= ~QPaintEngine::AlphaBlend;

    // Linear gradient emulation
    if (linearGradient && !engine->hasFeature(QPaintEngine::LinearGradientFill))
        s->emulationSpecifier |= QPaintEngine::LinearGradientFill;
    else
        s->emulationSpecifier &= ~QPaintEngine::LinearGradientFill;

    // Radial gradient emulation
    if (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill))
        s->emulationSpecifier |= QPaintEngine::RadialGradientFill;
    else
        s->emulationSpecifier &= ~QPaintEngine::RadialGradientFill;

    // Conical gradient emulation
    if (conicalGradient && !engine->hasFeature(QPaintEngine::ConicalGradientFill))
        s->emulationSpecifier |= QPaintEngine::ConicalGradientFill;
    else
        s->emulationSpecifier &= ~QPaintEngine::ConicalGradientFill;

    // Pattern brushes
    if (patternBrush && !engine->hasFeature(QPaintEngine::PatternBrush))
        s->emulationSpecifier |= QPaintEngine::PatternBrush;
    else
        s->emulationSpecifier &= ~QPaintEngine::PatternBrush;

    // Pattern XForms
    if (patternBrush && xform && !engine->hasFeature(QPaintEngine::PatternTransform))
        s->emulationSpecifier |= QPaintEngine::PatternTransform;
    else
        s->emulationSpecifier &= ~QPaintEngine::PatternTransform;

    // Primitive XForms
    if (xform && !engine->hasFeature(QPaintEngine::PrimitiveTransform))
        s->emulationSpecifier |= QPaintEngine::PrimitiveTransform;
    else
        s->emulationSpecifier &= ~QPaintEngine::PrimitiveTransform;

    // Constant opacity
    if (state->opacity != 1 && !engine->hasFeature(QPaintEngine::ConstantOpacity))
        s->emulationSpecifier |= QPaintEngine::ConstantOpacity;
    else
        s->emulationSpecifier &= ~QPaintEngine::ConstantOpacity;

    bool gradientStretch = false;
    if (linearGradient || conicalGradient || radialGradient) {
        gradientStretch |= check_gradient(s->brush);
        gradientStretch |= check_gradient(s->pen.brush());
    }
    if (gradientStretch)
        s->emulationSpecifier |= QGradient_StretchToDevice;
    else
        s->emulationSpecifier &= ~QGradient_StretchToDevice;

    // Opaque backgrounds...
    if (s->bgMode == Qt::OpaqueMode &&
        (is_pen_transparent(s->pen) || is_brush_transparent(s->brush)))
        s->emulationSpecifier |= QPaintEngine_OpaqueBackground;
    else
        s->emulationSpecifier &= ~QPaintEngine_OpaqueBackground;
}

Here is the call graph for this function:

void QPainterPrivate::updateState

(

QPainterState *

state

)

Definition at line 527 of file qpainter.cpp.

References QPaintEngine::AllDirty, QPainterState::changeFlags, QPaintEngine::clearDirty(), QPaintEngine::DirtyBackground, QPaintEngine::DirtyBackgroundMode, QPaintEngineState::dirtyFlags, engine, QPaintEngineState::painter(), QPainterState::painter, QPaintEngine::setDirty(), QPaintEngineState::state(), QPaintEngine::state, updateEmulationSpecifier(), and QPaintEngine::updateState().

Referenced by draw_helper(), and drawStretchToDevice().

{

    if (!newState) {
        engine->state = newState;

    } else if (newState->state() || engine->state!=newState) {

        // ### we might have to call QPainter::begin() here...
        if (!engine->state) {
            engine->state = newState;
            engine->setDirty(QPaintEngine::AllDirty);
        }

        if (engine->state->painter() != newState->painter)
            // ### this could break with clip regions vs paths.
            engine->setDirty(QPaintEngine::AllDirty);

        // Upon restore, revert all changes since last save
        else if (engine->state != newState)
            newState->dirtyFlags |= QPaintEngine::DirtyFlags(static_cast<QPainterState *>(engine->state)->changeFlags);

        // We need to store all changes made so that restore can deal with them
        else
            newState->changeFlags |= newState->dirtyFlags;

        updateEmulationSpecifier(newState);

        // Unset potential dirty background mode
        newState->dirtyFlags &= ~(QPaintEngine::DirtyBackgroundMode
                                  | QPaintEngine::DirtyBackground);

        engine->state = newState;
        engine->updateState(*newState);
        engine->clearDirty(QPaintEngine::AllDirty);
    }
}

Here is the call graph for this function:

void QPainterPrivate::draw_helper	(	const QPainterPath &	path,
		DrawOperation	operation = StrokeAndFillDraw
	)

Definition at line 121 of file qpainter.cpp.

References QPainter::Antialiasing, QPainterState::bgBrush, QPainterState::bgMode, QPainterState::bgOrigin, QRectF::bottom(), QPainterState::brush, QPen::capStyle(), ceil, QPainterState::clipInfo, QPainterPathStroker::createStroke(), device, QPaintEngine::drawImage(), drawOpaqueBackground(), drawStretchToDevice(), QPainterState::emulationSpecifier, engine, FillDraw, QImage::Format_ARGB32_Premultiplied, QPaintDevice::height(), image, int, QRectF::isEmpty(), QPainterPath::isEmpty(), QPen::joinStyle(), QRectF::left(), QMatrix::m11(), QMatrix::m22(), QPainterState::matrix, Qt::NoBrush, Qt::NoPen, QPainterState::opacity, Qt::OrderedAlphaDither, Qt::OrderedDither, original_device, p, path, QPainterState::pen, printf, QGradient_StretchToDevice, QPaintEngine_OpaqueBackground, redirection_offset, QPainterState::renderHints, QRectF::right(), QPainterPathStroker::setCapStyle(), QPainterPathStroker::setJoinStyle(), QPainterPathStroker::setWidth(), QList< T >::size(), QPainter::SmoothPixmapTransform, state, StrokeDraw, QPen::style(), QRectF::top(), QPainterState::txop, TxScale, updateState(), QPaintDevice::width(), QPen::widthF(), QPoint::x(), and QPoint::y().

{
#ifdef QT_DEBUG_DRAW
    if (qt_show_painter_debug_output) {
        printf("QPainter::drawHelper\n");
    }
#endif

    if (originalPath.isEmpty())
        return;

    if (state->emulationSpecifier == QGradient_StretchToDevice) {
        drawStretchToDevice(originalPath, op);
        return;
    } else if (state->emulationSpecifier & QPaintEngine_OpaqueBackground) {
        drawOpaqueBackground(originalPath, op);
        return;
    }

    Q_Q(QPainter);
    int devMinX = 0, devMaxX = 0, devMinY = 0, devMaxY = 0;

    qreal strokeOffsetX = 0, strokeOffsetY = 0;

    QPainterPath path = originalPath * state->matrix;
    QRectF pathBounds = path.boundingRect();
    QRectF strokeBounds;
    bool doStroke = (op & StrokeDraw) && (state->pen.style() != Qt::NoPen);
    if (doStroke) {
        qreal penWidth = state->pen.widthF();
        if (penWidth == 0) {
            strokeOffsetX = 1;
            strokeOffsetY = 1;
        } else {
            // In case of complex xform
            if (state->txop > TxScale) {
                QPainterPathStroker stroker;
                stroker.setWidth(penWidth);
                stroker.setJoinStyle(state->pen.joinStyle());
                stroker.setCapStyle(state->pen.capStyle());
                QPainterPath stroke = stroker.createStroke(originalPath);
                strokeBounds = (stroke * state->matrix).boundingRect();
            } else {
                strokeOffsetX = penWidth / 2.0 * state->matrix.m11();
                strokeOffsetY = penWidth / 2.0 * state->matrix.m22();
            }
        }
    }

    const qreal ROUND_UP_TRICK = 0.9999;
    if (!strokeBounds.isEmpty()) {
        devMinX = int(strokeBounds.left());
        devMaxX = int(strokeBounds.right() + ROUND_UP_TRICK);
        devMinY = int(strokeBounds.top());
        devMaxY = int(strokeBounds.bottom() + ROUND_UP_TRICK);
    } else {
        devMinX = int(pathBounds.left() - strokeOffsetX);
        devMaxX = int(pathBounds.right() + strokeOffsetX + ROUND_UP_TRICK);
        devMinY = int(pathBounds.top() - strokeOffsetY);
        devMaxY = int(pathBounds.bottom() + strokeOffsetY + ROUND_UP_TRICK);
    }

    QRect absPathRect(devMinX, devMinY, devMaxX - devMinX, devMaxY - devMinY);

    if (state->clipInfo.size() != 0) {
        QPainterPath clipPath = q->clipPath() * q->deviceMatrix();
        QRectF r = clipPath.boundingRect().intersected(absPathRect);
        absPathRect.setCoords((int) floor(r.left()), (int) floor(r.top()),
                              (int) ceil(r.right()), (int) ceil(r.bottom()));
    }
    absPathRect = absPathRect.intersected(QRect(0, 0, device->width(), device->height()));


//     qDebug("\nQPainterPrivate::draw_helper(), x=%d, y=%d, w=%d, h=%d",
//            devMinX, devMinY, device->width(), device->height());
//     qDebug() << " - matrix" << state->matrix;
//     qDebug() << " - originalPath.bounds" << originalPath.boundingRect();
//     qDebug() << " - path.bounds" << path.boundingRect();

    if (absPathRect.width() <= 0 || absPathRect.height() <= 0)
        return;

    QImage image(absPathRect.width(), absPathRect.height(), QImage::Format_ARGB32_Premultiplied);
    image.fill(0);

    QPainter p(&image);

    p.d_ptr->original_device = original_device;
    p.setOpacity(state->opacity);
    p.translate(-absPathRect.x(), -absPathRect.y());
    p.setMatrix(state->matrix, true);
    p.setPen(doStroke ? state->pen : QPen(Qt::NoPen));
    p.setBrush((op & FillDraw) ? state->brush : QBrush(Qt::NoBrush));
    p.setBackground(state->bgBrush);
    p.setBackgroundMode(state->bgMode);
    p.setBrushOrigin(state->bgOrigin);

    p.setRenderHint(QPainter::Antialiasing, state->renderHints & QPainter::Antialiasing);
    p.setRenderHint(QPainter::SmoothPixmapTransform,
                    state->renderHints & QPainter::SmoothPixmapTransform);

    p.drawPath(originalPath);

    p.end();

    q->save();
    q->setViewTransformEnabled(false);
    q->setMatrix(QMatrix(1, 0, 0, 1, -redirection_offset.x(), -redirection_offset.y()));
    updateState(state);
    engine->drawImage(absPathRect,
                 image,
                 QRectF(0, 0, absPathRect.width(), absPathRect.height()),
                 Qt::OrderedDither | Qt::OrderedAlphaDither);
    q->restore();
}

Here is the call graph for this function:

void QPainterPrivate::drawStretchToDevice	(	const QPainterPath &	path,
		DrawOperation	operation
	)

Definition at line 257 of file qpainter.cpp.

References QPainterState::brush, QPen::brush(), QPen::capStyle(), check_gradient(), QPainterPathStroker::createStroke(), QPaintEngine::drawPath(), engine, FillDraw, QPaintDevice::height(), QPen::joinStyle(), QPen::miterLimit(), Qt::NoBrush, Qt::NoPen, original_device, path, QPainterState::pen, QPainterPathStroker::setCapStyle(), QPainterPathStroker::setDashPattern(), QPainterPathStroker::setJoinStyle(), QPainterPathStroker::setMiterLimit(), QPainterPathStroker::setWidth(), state, StrokeDraw, QPen::style(), QBrush::style(), updateState(), QPaintDevice::width(), and QPen::widthF().

Referenced by draw_helper().

{
    Q_Q(QPainter);

    double sw = original_device->width();
    double sh = original_device->height();

    QMatrix inv(1.0/sw, 0, 0, 1.0/sh, 0, 0);

    QPen pen = state->pen;
    QBrush brush = state->brush;

    if ((op & FillDraw) && brush.style() == Qt::NoBrush) op = DrawOperation(op - FillDraw);
    if ((op & StrokeDraw) && pen.style() == Qt::NoPen) op = DrawOperation(op - StrokeDraw);

    q->scale(sw, sh);
    q->setPen(Qt::NoPen);
    updateState(state);

    // Draw the xformed fill if the brush is a stretch gradient.
    if ((op & FillDraw) && check_gradient(brush)) {
        engine->drawPath(path * inv);
        op = DrawOperation(op - FillDraw);
    }

    // Draw the xformed outline if the pen is a stretch gradient.
    if ((op & StrokeDraw) && check_gradient(pen.brush())) {
        q->setBrush(pen.brush());
        updateState(state);

        QPainterPathStroker stroker;
        stroker.setDashPattern(pen.style());
        stroker.setWidth(pen.widthF());
        stroker.setJoinStyle(pen.joinStyle());
        stroker.setCapStyle(pen.capStyle());
        stroker.setMiterLimit(pen.miterLimit());
        QPainterPath stroke = stroker.createStroke(path);

        engine->drawPath(stroke * inv);
        op = DrawOperation(op - StrokeDraw);
    }

    q->scale(1/sw, 1/sh);

    if (op & FillDraw) {
        updateState(state);
        engine->drawPath(path);
    }

    q->setPen(pen);

    if (op & StrokeDraw) {
        q->setBrush(Qt::NoBrush);
        updateState(state);
        engine->drawPath(path);
        q->setBrush(brush);
    }
}

Here is the call graph for this function:

void QPainterPrivate::drawOpaqueBackground	(	const QPainterPath &	path,
		DrawOperation	operation
	)

Definition at line 237 of file qpainter.cpp.

References QPainterState::bgBrush, QPainterState::brush, QBrush::color(), FillDraw, Qt::NoBrush, Qt::NoPen, Qt::OpaqueMode, path, QPainterState::pen, state, StrokeDraw, QPen::style(), QBrush::style(), Qt::TransparentMode, and QPen::width().

Referenced by draw_helper().

{
    Q_Q(QPainter);

    q->setBackgroundMode(Qt::TransparentMode);

    if (op & FillDraw && state->brush.style() != Qt::NoBrush) {
        q->fillPath(path, state->bgBrush.color());
        q->fillPath(path, state->brush);
    }

    if (op & StrokeDraw && state->pen.style() != Qt::NoPen) {
        q->strokePath(path, QPen(state->bgBrush.color(), state->pen.width()));
        q->strokePath(path, state->pen);
    }

    q->setBackgroundMode(Qt::OpaqueMode);
}

Here is the call graph for this function:

void QPainterPrivate::updateMatrix

(

)

Definition at line 323 of file qpainter.cpp.

References QPaintEngineState::dirtyFlags, QPaintEngine::DirtyTransform, QMatrix::dx(), QMatrix::dy(), QPoint::isNull(), QMatrix::m11(), QMatrix::m12(), QMatrix::m21(), QMatrix::m22(), QPainterState::matrix, redirection_offset, state, txinv, TxNone, QPainterState::txop, TxRotShear, TxScale, TxTranslate, viewMatrix(), QPainterState::VxF, QPainterState::worldMatrix, QPainterState::WxF, QPoint::x(), and QPoint::y().

{
    state->matrix = (state->WxF ? state->worldMatrix : QMatrix())
                    * (state->VxF ? viewMatrix() : QMatrix());

    txinv = false;                                // no inverted matrix
    state->txop  = TxNone;
    if (state->matrix.m12()==0.0 && state->matrix.m21()==0.0
        && state->matrix.m11() >= 0.0 && state->matrix.m22() >= 0.0) {
        if (state->matrix.m11()==1.0 && state->matrix.m22()==1.0) {
            if (state->matrix.dx()!=0.0 || state->matrix.dy()!=0.0)
                state->txop = TxTranslate;
        } else {
            state->txop = TxScale;
        }
    } else {
        state->txop = TxRotShear;
    }
    if (!redirection_offset.isNull()) {
        state->txop |= TxTranslate;
        state->WxF = true;
        // We want to translate in dev space so we do the adding of the redirection
        // offset manually.
        state->matrix = QMatrix(state->matrix.m11(), state->matrix.m12(),
                              state->matrix.m21(), state->matrix.m22(),
                              state->matrix.dx()-redirection_offset.x(),
                              state->matrix.dy()-redirection_offset.y());
    }
    state->dirtyFlags |= QPaintEngine::DirtyTransform;

//     printf("VxF=%d, WxF=%d\n", state->VxF, state->WxF);
//     qDebug() << " --- using matrix" << state->matrix << redirection_offset;
}

Here is the call graph for this function:

void QPainterPrivate::updateInvMatrix

(

)

Definition at line 358 of file qpainter.cpp.

References invMatrix, m, state, txinv, QPainterState::vh, QPainterState::vw, QPainterState::vx, QPainterState::VxF, QPainterState::vy, QPainterState::wh, QPainterState::worldMatrix, QPainterState::ww, QPainterState::wx, QPainterState::WxF, and QPainterState::wy.

Referenced by QPainter::clipPath(), and QPainter::clipRegion().

{
    Q_ASSERT(txinv == false);
    txinv = true;                                // creating inverted matrix
    bool invertible;
    QMatrix m;
    if (state->VxF) {
        m.translate(state->vx, state->vy);
        m.scale(1.0*state->vw/state->ww, 1.0*state->vh/state->wh);
        m.translate(-state->wx, -state->wy);
    }
    if (state->WxF) {
        if (state->VxF)
            m = state->worldMatrix * m;
        else
            m = state->worldMatrix;
    }
    invMatrix = m.inverted(&invertible);                // invert matrix
}

void QPainterPrivate::init

(

)

Definition at line 317 of file qpainter.cpp.

References QPainterState::painter, and state.

Referenced by QPainter::QPainter().

{
    Q_Q(QPainter);
    state->painter = q;
}

int QPainterPrivate::rectSubtraction

(

)

const [inline]

Definition at line 159 of file qpainter_p.h.

References Qt::NoPen, QPainterState::pen, state, QPen::style(), and QPen::width().

                                {
        return state->pen.style() != Qt::NoPen && state->pen.width() == 0 ? 1 : 0;
    }

Here is the call graph for this function:

QMatrix QPainterPrivate::viewMatrix

(

)

const

Definition at line 109 of file qpainter.cpp.

References m, state, QPainterState::vh, QPainterState::vw, QPainterState::vx, QPainterState::VxF, QPainterState::vy, QPainterState::wh, QPainterState::ww, QPainterState::wx, and QPainterState::wy.

Referenced by updateMatrix().

{
    QMatrix m;
    if (state->VxF) {
        qreal scaleW = qreal(state->vw)/qreal(state->ww);
        qreal scaleH = qreal(state->vh)/qreal(state->wh);
        m.setMatrix(scaleW, 0, 0, scaleH, state->vx - state->wx*scaleW, state->vy - state->wy*scaleH);
    }
    return m;
}

---

Member Data Documentation

QPainter* QPainterPrivate::q_ptr

Definition at line 126 of file qpainter_p.h.

QPoint QPainterPrivate::redirection_offset

Definition at line 128 of file qpainter_p.h.

Referenced by draw_helper(), and updateMatrix().

QPainterState* QPainterPrivate::state

Definition at line 130 of file qpainter_p.h.

Referenced by draw_helper(), drawOpaqueBackground(), drawStretchToDevice(), init(), QPainterPrivate(), rectSubtraction(), updateEmulationSpecifier(), updateInvMatrix(), updateMatrix(), and viewMatrix().

QVector<QPainterState*> QPainterPrivate::states

Definition at line 131 of file qpainter_p.h.

Referenced by QPainterPrivate(), and ~QPainterPrivate().

QMatrix QPainterPrivate::invMatrix

Definition at line 133 of file qpainter_p.h.

Referenced by updateInvMatrix().

uint QPainterPrivate::txinv

Definition at line 134 of file qpainter_p.h.

Referenced by updateInvMatrix(), and updateMatrix().

QPaintDevice* QPainterPrivate::device

Definition at line 165 of file qpainter_p.h.

Referenced by draw_helper().

QPaintDevice* QPainterPrivate::original_device

Definition at line 166 of file qpainter_p.h.

Referenced by draw_helper(), and drawStretchToDevice().

QPaintEngine* QPainterPrivate::engine

Definition at line 167 of file qpainter_p.h.

Referenced by draw_helper(), drawStretchToDevice(), updateEmulationSpecifier(), and updateState().

---

The documentation for this class was generated from the following files:

• src/gui/painting/qpainter_p.h
• src/gui/painting/qpainter.cpp

---