QRasterPaintEngine Class Reference

#include <qpaintengine_raster_p.h>

Inheritance diagram for QRasterPaintEngine:

[legend]Collaboration diagram for QRasterPaintEngine:

[legend]List of all members.

---

Detailed Description

The QRasterPaintEngine class enables acceleration of painting operations using the available hardware.

Since:

4.2

Note that this functionality is only available in Qtopia Core.

In Qtopia Core, painting is a pure software implementation. But starting with Qtopia Core 4.2, it is possible to add an accelerated graphics driver to take advantage of available hardware resources.

The painting operations can be accelerated by deriving from the QRasterPaintEngine and QCustomRasterPaintDevice classes. Note that there are several other issues to be aware of; see the {Adding an Accelerated Graphics Driver in Qtopia Core} documentation for details.

See also:

QCustomRasterPaintDevice, QPaintEngine

Definition at line 55 of file qpaintengine_raster_p.h.

Public Member Functions
	QRasterPaintEngine ()
	~QRasterPaintEngine ()
bool	begin (QPaintDevice *device)
bool	end ()
void	updateState (const QPaintEngineState &state)
void	updateMatrix (const QMatrix &matrix)
void	updateClipRegion (const QRegion &region, Qt::ClipOperation op)
void	updateClipPath (const QPainterPath &path, Qt::ClipOperation op)
void	drawPath (const QPainterPath &path)
void	drawPolygon (const QPointF *points, int pointCount, PolygonDrawMode mode)
void	drawPolygon (const QPoint *points, int pointCount, PolygonDrawMode mode)
void	fillPath (const QPainterPath &path, QSpanData *fillData)
void	drawEllipse (const QRectF &rect)
void	drawRects (const QRect *rects, int rectCount)
void	drawRects (const QRectF *rects, int rectCount)
void	drawPixmap (const QRectF &r, const QPixmap &pm, const QRectF &sr)
void	drawImage (const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags falgs=Qt::AutoColor)
void	drawTiledPixmap (const QRectF &r, const QPixmap &pm, const QPointF &sr)
void	drawTextItem (const QPointF &p, const QTextItem &textItem)
void	drawLines (const QLine *line, int lineCount)
void	drawLines (const QLineF *line, int lineCount)
void	drawPoints (const QPointF *points, int pointCount)
void	setFlushOnEnd (bool flush)
void	flush (QPaintDevice *device, const QPoint &offset)
void	releaseBuffer ()
QSize	size () const
void	saveBuffer (const QString &s) const
Type	type () const
QPoint	coordinateOffset () const
Protected Member Functions
	QRasterPaintEngine (QRasterPaintEnginePrivate &d)
Private Member Functions
void	init ()
Related Functions
(Note that these are not member functions.)
	QSpan

---

Constructor & Destructor Documentation

QRasterPaintEngine::QRasterPaintEngine

(

)

Creates a raster based paint engine with the complete set of {QPaintEngine::PaintEngineFeature}{paint engine features and capabilities}.

Definition at line 580 of file qpaintengine_raster.cpp.

References init().

    : QPaintEngine(*(new QRasterPaintEnginePrivate),
                   QPaintEngine::PaintEngineFeatures(AllFeatures)
        )
{
    init();
}

Here is the call graph for this function:

QRasterPaintEngine::~QRasterPaintEngine

(

)

Destroys the paint engine.

Definition at line 638 of file qpaintengine_raster.cpp.

References d.

{
    Q_D(QRasterPaintEngine);

#if defined(Q_WS_WIN64)
    _aligned_free(d->rasterPoolBase);
#else
    free(d->rasterPoolBase);
#endif

    qt_ft_grays_raster.raster_done(*d->grayRaster);
    delete d->grayRaster;

    qt_ft_standard_raster.raster_done(*d->blackRaster);
    delete d->blackRaster;


    delete d->rasterBuffer;
    delete d->outlineMapper;
#ifdef Q_WS_WIN
    delete d->fontRasterBuffer;
#endif

    delete d->dashStroker;
}

QRasterPaintEngine::QRasterPaintEngine

(

QRasterPaintEnginePrivate &

d

)

[protected]

Definition at line 591 of file qpaintengine_raster.cpp.

References init().

    : QPaintEngine(dd, QPaintEngine::PaintEngineFeatures(AllFeatures))
{
    init();
}

Here is the call graph for this function:

---

Member Function Documentation

bool QRasterPaintEngine::begin

(

QPaintDevice *

device

)

[virtual]

Implements QPaintEngine.

Definition at line 667 of file qpaintengine_raster.cpp.

References Qt::black, BOOL, Qt::color0, Qt::color1, QInternal::CustomRaster, d, data, QPaintDevice::depth(), QPaintDevice::devType(), QPaintEngine::DirtyBrushOrigin, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_Mono, QImage::Format_MonoLSB, QImage::Format_RGB16, QImage::Format_RGB32, QPaintEngine::gccaps, QPaintDevice::height(), image, QInternal::Image, QRegion::isEmpty(), Qt::NoBrush, Qt::NoClip, QPaintEngine::PaintOutsidePaintEvent, QInternal::Pixmap, QPaintEngine::PorterDuff, qInitDrawhelperAsm(), qWarning(), QPaintEngine::setActive(), QPaintEngine::setDirty(), QPaintEngine::systemClip(), QPainterPrivate::TxNone, updateClipPath(), updateClipRegion(), QInternal::Widget, and QPaintDevice::width().

{
    Q_D(QRasterPaintEngine);

    // ####### move to QApp
    qInitDrawhelperAsm();
    d->deviceDepth = device->depth();
    d->antialiased = false;
    d->bilinear = false;
    d->mono_surface = false;
    d->fast_pen = true;
    d->int_xform = true;
    d->user_clip_enabled = false;
    d->opacity = 256;

    d->inverseScale = qreal(1);

#if defined(Q_WS_WIN)
    d->clear_type_text = false;
    QT_WA({
        UINT result;
        BOOL ok;
        ok = SystemParametersInfoW(SPI_GETFONTSMOOTHINGTYPE, 0, &result, 0);
        if (ok)
            d->clear_type_text = (result == FE_FONTSMOOTHINGCLEARTYPE);
    }, {
        UINT result;
        BOOL ok;
        ok = SystemParametersInfoA(SPI_GETFONTSMOOTHINGTYPE, 0, &result, 0);
        if (ok)
            d->clear_type_text = (result == FE_FONTSMOOTHINGCLEARTYPE);
    });
#endif

    d->rasterBuffer->init();

#if defined(Q_WS_WIN)
    d->fontRasterBuffer->setupHDC(d->clear_type_text);
#endif

    d->deviceRect = QRect(0, 0, device->width(), device->height());


    gccaps &= ~PorterDuff;

    // reset paintevent clip
    d->baseClip = QPainterPath();
    if (device->devType() == QInternal::Widget) {
        QRegion sysClip = systemClip();
        if (!sysClip.isEmpty()) {
            d->baseClip.addRegion(sysClip);
            d->deviceRect = sysClip.boundingRect();
            // Shift the baseclip to absolute
            d->baseClip = d->baseClip * QMatrix(1, 0, 0, 1,
                                                -d->deviceRect.x(),
                                                -d->deviceRect.y());
        }
        gccaps &= ~PaintOutsidePaintEvent;
    }
#if defined(Q_WS_QWS)
    else if (device->devType() == QInternal::Pixmap) {
        // Only embedded uses system clipping on pixmaps
        QRegion sysClip = systemClip();
        if (!sysClip.isEmpty())
            d->baseClip.addRegion(sysClip);
    }
#endif
    else {
        QRegion sysClip = systemClip();
        if (!sysClip.isEmpty()) {
            d->baseClip.addRegion(sysClip);
        }
    }

#if defined(Q_WS_WIN) || defined(Q_WS_QWS)
    if (device->devType() == QInternal::Pixmap) {
        QPixmap *pixmap = static_cast<QPixmap *>(device);
        if (pixmap->isNull()) {
            qWarning("Cannot paint on a null pixmap");
            return false;
        }
        QPixmapData *data = static_cast<QPixmap *>(device)->data;
        device = &data->image;
    }
#elif defined(Q_WS_MAC)
    if (device->devType() == QInternal::Pixmap) {
        QPixmap *pixmap = static_cast<QPixmap *>(device);
        if (pixmap->isNull()) {
            qWarning("Cannot paint on a null pixmap");
            return false;
        }
        d->rasterBuffer->prepare(pixmap);
    }
#endif

    if (device->devType() == QInternal::Image) {
        QImage *image = static_cast<QImage *>(device);
        int format = image->format();
        d->flushOnEnd = false;

        d->rasterBuffer->prepare(image);
        if (format == QImage::Format_MonoLSB) {
            d->mono_surface = true;
        } else if (format == QImage::Format_Mono) {
            d->mono_surface = true;
        } else if (format == QImage::Format_RGB32) {
            ;
        } else if (format == QImage::Format_ARGB32_Premultiplied) {
            gccaps |= PorterDuff;
        } else if (format == QImage::Format_ARGB32) {
            gccaps |= PorterDuff;
#ifdef Q_WS_QWS
        } else if (format == QImage::Format_RGB16) {
            ;
#endif
        } else {
            qWarning("QRasterPaintEngine::begin: Unsupported image format (%d)", format);
            return false;
        }
#ifdef Q_WS_QWS
    } else if (device->devType() == QInternal::CustomRaster) {
        QCustomRasterPaintDevice *dev = static_cast<QCustomRasterPaintDevice*>(device);
        d->rasterBuffer->prepare(dev);
#endif
    } else {
        d->rasterBuffer->prepare(d->deviceRect.width(), d->deviceRect.height());
    }

    d->rasterBuffer->resetClip();

    d->matrix = QMatrix();
    d->txop = QPainterPrivate::TxNone;

    d->outlineMapper->setMatrix(d->matrix, d->txop);
    d->outlineMapper->m_clipper.setBoundingRect(d->deviceRect.adjusted(-10, -10, 10, 10));

    if (device->depth() == 1) {
        d->pen = QPen(Qt::color1);
        d->brush = QBrush(Qt::color0);
    } else {
        d->pen = QPen(Qt::black);
        d->brush = QBrush(Qt::NoBrush);
    }

    d->penData.init(d->rasterBuffer, this);
    d->penData.setup(d->pen.brush(), d->opacity);
    d->stroker = &d->basicStroker;
    d->basicStroker.setClipRect(d->deviceRect);

    d->brushData.init(d->rasterBuffer, this);
    d->brushData.setup(d->brush, d->opacity);

#ifdef QT_EXPERIMENTAL_REGIONS
    updateClipRegion(QRegion(), Qt::NoClip);
#else
    updateClipPath(QPainterPath(), Qt::NoClip);
#endif

    setDirty(DirtyBrushOrigin);

    setActive(true);
    return true;
}

Here is the call graph for this function:

bool QRasterPaintEngine::end

(

)

[virtual]

Implements QPaintEngine.

Definition at line 834 of file qpaintengine_raster.cpp.

References d, flush(), and QPaintEngine::setActive().

Referenced by drawPoints().

{
    Q_D(QRasterPaintEngine);

    if (d->flushOnEnd)
        flush(d->pdev, QPoint());

    if (d->rasterBuffer->disabled_clip) {
        delete d->rasterBuffer->disabled_clip;
        d->rasterBuffer->disabled_clip = 0;
    }

    setActive(false);

#ifdef Q_WS_QWS
    qResetDrawhelper();
#endif

    return true;
}

Here is the call graph for this function:

void QRasterPaintEngine::updateState

(

const QPaintEngineState &

state

)

[virtual]

Implements QPaintEngine.

Definition at line 1011 of file qpaintengine_raster.cpp.

References QPainter::Antialiasing, QPaintEngineState::brush(), QPaintEngineState::brushOrigin(), QPaintEngineState::clipOperation(), QPaintEngineState::clipPath(), QPaintEngineState::clipRegion(), QPaintEngineState::compositionMode(), Qt::CustomDashLine, d, QPaintEngine::DirtyBrush, QPaintEngine::DirtyBrushOrigin, QPaintEngine::DirtyClipEnabled, QPaintEngine::DirtyClipPath, QPaintEngine::DirtyClipRegion, QPaintEngine::DirtyCompositionMode, QPaintEngine::DirtyHints, QPaintEngine::DirtyOpacity, QPaintEngine::DirtyPen, QPaintEngine::DirtyTransform, QPainterPath::fillRule(), flags, QPaintEngineState::isClipEnabled(), QPaintEngineState::matrix(), Qt::NoClip, Qt::NoPen, QPaintEngineState::opacity(), QPaintEngineState::pen(), qRound(), QPaintEngineState::renderHints(), QPainter::SmoothPixmapTransform, Qt::SolidLine, QPaintEngineState::state(), QPaintEngine::state, QPainterPath::toFillPolygon(), QPolygonF::toPolygon(), QPainterPrivate::TxTranslate, updateClipPath(), updateClipRegion(), and updateMatrix().

{
    Q_D(QRasterPaintEngine);

    QPaintEngine::DirtyFlags flags = state.state();

    bool update_fast_pen = false;

    if (flags & DirtyTransform) {
        update_fast_pen = true;
        updateMatrix(state.matrix());
    }

    if (flags & DirtyOpacity) {
        update_fast_pen = true;
        d->opacity = qRound(state.opacity() * 256.0);
        if (d->opacity > 256)
            d->opacity = 256;
        if (d->opacity < 0)
            d->opacity = 0;

        // Force update pen/brush as to get proper alpha colors propagated
        flags |= DirtyPen;
        flags |= DirtyBrush;
    }

    if (flags & DirtyPen) {
        update_fast_pen = true;
        d->pen = state.pen();

        if (d->pen.style() == Qt::CustomDashLine && d->pen.dashPattern().size() == 0)
            d->pen.setStyle(Qt::SolidLine);

        d->basicStroker.setJoinStyle(d->pen.joinStyle());
        d->basicStroker.setCapStyle(d->pen.capStyle());
        d->basicStroker.setMiterLimit(d->pen.miterLimit());

        qreal penWidth = d->pen.widthF();
        if (penWidth == 0)
            d->basicStroker.setStrokeWidth(1);
        else
            d->basicStroker.setStrokeWidth(penWidth);

        Qt::PenStyle pen_style = d->pen.style();
        if(pen_style == Qt::SolidLine) {
            d->stroker = &d->basicStroker;
        } else if (pen_style != Qt::NoPen) {
            if (!d->dashStroker)
                d->dashStroker = new QDashStroker(&d->basicStroker);
            if (penWidth == 0) {
                d->dashStroker->setClipRect(d->deviceRect);
            } else {
                QRectF clipRect = d->matrix.inverted().mapRect(QRectF(d->deviceRect));
                d->dashStroker->setClipRect(clipRect);
            }
            d->dashStroker->setDashPattern(d->pen.dashPattern());
            d->stroker = d->dashStroker;
        } else {
            d->stroker = 0;
        }
        d->penData.setup(pen_style == Qt::NoPen ? QBrush() : d->pen.brush(), d->opacity);
    }

    if (flags & (DirtyBrush|DirtyBrushOrigin)) {
        QBrush brush = state.brush();
        d->brush = brush;
        d->brushOffset = state.brushOrigin();
        d->brushData.setup(d->brush, d->opacity);
        d->brushData.setupMatrix((d->brushMatrix().inverted() * d->brush.matrix().inverted()).inverted(),
                                 d->txop, d->bilinear);
    }

    if (flags & (DirtyClipPath | DirtyClipRegion)) {
        d->user_clip_enabled = true;
        // If we're setting a clip, we kill the old clip
        if (d->rasterBuffer->disabled_clip) {
            delete d->rasterBuffer->disabled_clip;
            d->rasterBuffer->disabled_clip = 0;
        }
    }

    if (flags & DirtyClipPath) {
#ifdef QT_EXPERIMENTAL_REGIONS
        QPolygon polygon = state.clipPath().toFillPolygon().toPolygon();
        updateClipRegion(QRegion(polygon, state.clipPath().fillRule()),
                         state.clipOperation());
#else
        updateClipPath(state.clipPath(), state.clipOperation());

#endif
    } else if (flags & DirtyClipRegion) {
        updateClipRegion(state.clipRegion(), state.clipOperation());

    } else if (flags & DirtyClipEnabled) {

        if (state.isClipEnabled() != d->user_clip_enabled) {
            d->user_clip_enabled = state.isClipEnabled();

            // The tricky case... When we disable clipping we still do
            // system clip so we need to rasterize the system clip and
            // replace the current clip with it. Since people might
            // choose to set clipping to true later on we have to the
            // current one (in disabled_clip).
            if (!d->baseClip.isEmpty()) {
                if (!state.isClipEnabled()) { // save current clip for later
                    Q_ASSERT(!d->rasterBuffer->disabled_clip);
                    d->rasterBuffer->disabled_clip = d->rasterBuffer->clip;
                    d->rasterBuffer->clip = 0;
#ifdef QT_EXPERIMENTAL_REGIONS
                    updateClipRegion(QRegion(), Qt::NoClip);
#else
                    updateClipPath(QPainterPath(), Qt::NoClip);
#endif
                } else { // re-enable old clip
                    Q_ASSERT(d->rasterBuffer->disabled_clip);
                    d->rasterBuffer->resetClip();
                    d->rasterBuffer->clip = d->rasterBuffer->disabled_clip;
                    d->rasterBuffer->disabled_clip = 0;
                }
            } else {
                if (!state.isClipEnabled()) {
#ifdef QT_EXPERIMENTAL_REGIONS
                    updateClipRegion(QRegion(), Qt::NoClip);
#else
                    updateClipPath(QPainterPath(), Qt::NoClip);
#endif
                } else {
#ifdef QT_EXPERIMENTAL_REGIONS
                    updateClipRegion(state.clipRegion(), state.clipOperation());
#else
                    updateClipPath(state.clipPath(), state.clipOperation());
#endif
                }
            }
            d->penData.adjustSpanMethods();
            d->brushData.adjustSpanMethods();
        }
    }

    if (!d->mono_surface) {
        if (flags & DirtyHints) {
            update_fast_pen = true;
            d->antialiased = bool(state.renderHints() & QPainter::Antialiasing);
            d->bilinear = bool(state.renderHints() & QPainter::SmoothPixmapTransform);
            // propegate state to data's
            d->brushData.bilinear = d->penData.bilinear = d->bilinear;
            d->penData.adjustSpanMethods();
            d->brushData.adjustSpanMethods();

        }

        if (flags & DirtyCompositionMode) {
            d->rasterBuffer->compositionMode = state.compositionMode();
        }
    }

    if (update_fast_pen) {
        d->fast_pen = !d->antialiased
                      && (d->pen.widthF() == 0
                          || d->pen.widthF() <= 1 && d->txop <= QPainterPrivate::TxTranslate);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::updateMatrix

(

const QMatrix &

matrix

)

Definition at line 971 of file qpaintengine_raster.cpp.

References d, QMatrix::m11(), QMatrix::m12(), QMatrix::m21(), QMatrix::m22(), qMax(), QPainterPrivate::TxNone, QPainterPrivate::TxRotShear, QPainterPrivate::TxScale, and QPainterPrivate::TxTranslate.

Referenced by updateState().

{
    Q_D(QRasterPaintEngine);

    d->matrix = matrix;
    d->int_xform = false;
    if (d->matrix.m12() != 0 || d->matrix.m21() != 0) {
        d->txop = QPainterPrivate::TxRotShear;
    } else if (d->matrix.m11() != 1 || d->matrix.m22() != 1) {
        d->txop = QPainterPrivate::TxScale;
        d->int_xform = qreal(int(d->matrix.dx())) == d->matrix.dx()
                            && qreal(int(d->matrix.dy())) == d->matrix.dy()
                            && qreal(int(d->matrix.m11())) == d->matrix.m11()
                            && qreal(int(d->matrix.m22())) == d->matrix.m22();
    } else if (d->matrix.dx() != 0 || d->matrix.dy() != 0) {
        d->txop = QPainterPrivate::TxTranslate;
        d->int_xform = qreal(int(d->matrix.dx())) == d->matrix.dx()
                            && qreal(int(d->matrix.dy())) == d->matrix.dy();
    } else {
        d->txop = QPainterPrivate::TxNone;
        d->int_xform = true;
    }

    // 1/10000 == 0.0001, so we have good enough res to cover curves
    // that span the entire widget...
    d->inverseScale = qMax(1 / qMax( qMax(qAbs(matrix.m11()), qAbs(matrix.m22())),
                                     qMax(qAbs(matrix.m12()), qAbs(matrix.m21())) ),
                           qreal(0.0001));

    d->outlineMapper->setMatrix(d->matrix, d->txop);
    QMatrix penMatrix = (d->matrix.inverted()*d->pen.brush().matrix().inverted()).inverted();
    d->penData.setupMatrix(penMatrix,
                           d->txop, d->bilinear);
    QMatrix brushMatrix = (d->brushMatrix().inverted() * d->brush.matrix().inverted()).inverted();
    d->brushData.setupMatrix(brushMatrix, d->txop, d->bilinear);
}

Here is the call graph for this function:

void QRasterPaintEngine::updateClipRegion	(	const QRegion &	region,
		Qt::ClipOperation	op
	)

Definition at line 1177 of file qpaintengine_raster.cpp.

References d, Qt::IntersectClip, QRegion::isEmpty(), Qt::NoClip, p, qDebug(), Qt::ReplaceClip, QPaintEngine::systemClip(), Qt::UniteClip, and updateClipPath().

Referenced by begin(), and updateState().

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::updateClipRegion() op=" << op << r;
#endif

#ifdef QT_EXPERIMENTAL_REGIONS
    Q_D(QRasterPaintEngine);

    switch (op) {
    case Qt::NoClip:
        d->clipRegion = d->deviceRect;
        break;
    case Qt::IntersectClip:
        d->clipRegion &= d->matrix.map(r);
        break;
    case Qt::ReplaceClip:
        if (r.isEmpty())
            d->clipRegion = d->deviceRect;
        else
            d->clipRegion = d->matrix.map(r);
        break;
    case Qt::UniteClip:
        d->clipRegion |= d->matrix.map(r);
        break;
    default:
        break;
    }

    const QRegion sysClip = systemClip();
    if (!sysClip.isEmpty())
        d->clipRegion &= sysClip;

    if (!d->clipRegion.isEmpty() && d->clipRegion.rects().count() == 1) {
        d->setSimpleClip(d->clipRegion.boundingRect());
        return;
    }
#endif // QT_EXPERIMENTAL_REGIONS

    QPainterPath p;
    p.addRegion(r);
    updateClipPath(p, op);
}

Here is the call graph for this function:

void QRasterPaintEngine::updateClipPath	(	const QPainterPath &	path,
		Qt::ClipOperation	op
	)

Definition at line 1237 of file qpaintengine_raster.cpp.

References d, Qt::IntersectClip, Qt::NoClip, path, qDebug(), Qt::ReplaceClip, QPainterPrivate::TxNone, and Qt::UniteClip.

Referenced by begin(), updateClipRegion(), and updateState().

{
    Q_D(QRasterPaintEngine);
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::updateClipPath(), op="
             << op
             << path.boundingRect();
#endif
    d->updateClip_helper(path, op);

    // Reset the baseClip if the operation requires it.
    if (!d->baseClip.isEmpty()) {
        switch (op) {
        case Qt::UniteClip:
        case Qt::ReplaceClip:
        case Qt::NoClip:
            d->outlineMapper->setMatrix(QMatrix(), QPainterPrivate::TxNone);
            d->updateClip_helper(d->baseClip, Qt::IntersectClip);
            d->outlineMapper->setMatrix(d->matrix, d->txop);
            break;
        default:
            break;
        }
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawPath

(

const QPainterPath &

path

)

[virtual]

Reimplemented from QPaintEngine.

Definition at line 1402 of file qpaintengine_raster.cpp.

References d, fillPath(), QRectF::height(), path, qDebug(), QPainterPrivate::TxNone, QRectF::width(), width, Qt::WindingFill, QRectF::x(), and QRectF::y().

Referenced by drawPoints().

{
#ifdef QT_DEBUG_DRAW
    QRectF bounds = path.boundingRect();
    qDebug(" - QRasterPaintEngine::drawPath(), [%.2f, %.2f, %.2f, %.2f]",
           bounds.x(), bounds.y(), bounds.width(), bounds.height());
#endif
    if (path.isEmpty())
        return;

    Q_D(QRasterPaintEngine);

    if (d->brushData.blend) {
        d->outlineMapper->setMatrix(d->matrix, d->txop);
        fillPath(path, &d->brushData);
    }

    if (!d->penData.blend)
        return;

    {
        Q_ASSERT(d->stroker);
        qreal width = d->pen.widthF();
        d->outlineMapper->beginOutline(Qt::WindingFill);
        if (width == 0) {
            d->outlineMapper->setMatrix(QMatrix(), QPainterPrivate::TxNone);
            d->stroker->strokePath(path, d->outlineMapper, d->matrix);
        } else {
            d->outlineMapper->setMatrix(d->matrix, d->txop);
            d->stroker->strokePath(path, d->outlineMapper, QMatrix());
        }
        d->outlineMapper->endOutline();

        d->rasterize(d->outlineMapper->outline(), d->penData.blend, &d->penData, d->rasterBuffer);
        d->outlineMapper->setMatrix(d->matrix, d->txop);
    }

}

Here is the call graph for this function:

void QRasterPaintEngine::drawPolygon	(	const QPointF *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1444 of file qpaintengine_raster.cpp.

References d, drawLine_midpoint_dashed_i(), drawLine_midpoint_i(), Qt::FlatCap, i, LineDrawIncludeLastPixel, LineDrawNormal, Qt::OddEvenFill, p, QPaintEngine::PolylineMode, qDebug(), qFloor(), Qt::SolidLine, QPainterPrivate::TxNone, width, Qt::WindingFill, QPaintEngine::WindingMode, QPointF::x(), and QPointF::y().

Referenced by drawRects().

{
    Q_D(QRasterPaintEngine);
#ifdef QT_DEBUG_DRAW
    qDebug(" - QRasterPaintEngine::drawPolygon(), pointCount=%d", pointCount);
    for (int i=0; i<pointCount; ++i)
        qDebug() << "   - " << points[i];
#endif
    Q_ASSERT(pointCount >= 2);

    // Do the fill
    if (d->brushData.blend && mode != PolylineMode) {

        // Compose polygon fill..,
        d->outlineMapper->beginOutline(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
        d->outlineMapper->moveTo(*points);
        const QPointF *p = points;
        const QPointF *ep = points + pointCount - 1;
        do {
            d->outlineMapper->lineTo(*(++p));
        } while (p < ep);
        d->outlineMapper->endOutline();

        // scanconvert.
        d->rasterize(d->outlineMapper->outline(), d->brushData.blend, &d->brushData, d->rasterBuffer);
    }

    // Do the outline...
    if (d->penData.blend) {

        bool needs_closing = mode != PolylineMode && points[0] != points[pointCount-1];

        if (d->fast_pen && d->pen.brush().isOpaque()) {
            // Use fast path for 0 width /  trivial pens.

            QRect devRect(0, 0, d->deviceRect.width(), d->deviceRect.height());

            LineDrawMode mode_for_last = (d->pen.capStyle() != Qt::FlatCap
                                          ? LineDrawIncludeLastPixel
                                          : LineDrawNormal);
            int dashOffset = 0;

            // Draw all the line segments.
            for (int i=1; i<pointCount; ++i) {
                QPointF lp1 = points[i-1] * d->matrix;
                QPointF lp2 = points[i] * d->matrix;
                if (d->pen.style() == Qt::SolidLine) {
                    drawLine_midpoint_i(qFloor(lp1.x()), qFloor(lp1.y()),
                                        qFloor(lp2.x()), qFloor(lp2.y()),
                                        d->penData.blend, &d->penData,
                                        i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
                                        devRect);
                } else {
                    drawLine_midpoint_dashed_i(qFloor(lp1.x()), qFloor(lp1.y()),
                                               qFloor(lp2.x()), qFloor(lp2.y()),
                                               &d->pen,
                                               d->penData.blend, &d->penData,
                                               i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
                                               devRect, &dashOffset);
                }
            }

            // Polygons are implicitly closed.
            if (needs_closing) {
                QPointF lp1 = points[pointCount-1] * d->matrix;
                QPointF lp2 = points[0] * d->matrix;
                if (d->pen.style() == Qt::SolidLine) {
                    drawLine_midpoint_i(qFloor(lp1.x()), qFloor(lp1.y()),
                                        qFloor(lp2.x()), qFloor(lp2.y()),
                                        d->penData.blend, &d->penData,
                                        LineDrawIncludeLastPixel,
                                        devRect);
                } else {
                    drawLine_midpoint_dashed_i(qFloor(lp1.x()), qFloor(lp1.y()),
                                               qFloor(lp2.x()), qFloor(lp2.y()),
                                               &d->pen,
                                               d->penData.blend, &d->penData,
                                               LineDrawIncludeLastPixel,
                                               devRect, &dashOffset);
                }
            }

        } else {
            // fallback case for complex or transformed pens.
            qreal width = d->pen.widthF();
            d->outlineMapper->beginOutline(Qt::WindingFill);
            if (width == 0) {
                d->basicStroker.setStrokeWidth(1);
                d->outlineMapper->setMatrix(QMatrix(), QPainterPrivate::TxNone);
                d->stroker->strokePolygon(points, pointCount, needs_closing,
                                          d->outlineMapper, d->matrix);
            } else {
                d->basicStroker.setStrokeWidth(width);
                d->outlineMapper->setMatrix(d->matrix, d->txop);
                d->stroker->strokePolygon(points, pointCount, needs_closing,
                                          d->outlineMapper, QMatrix());
            }
            d->outlineMapper->endOutline();

            d->rasterize(d->outlineMapper->outline(), d->penData.blend, &d->penData, d->rasterBuffer);

            d->outlineMapper->setMatrix(d->matrix, d->txop);
        }
    }

}

Here is the call graph for this function:

void QRasterPaintEngine::drawPolygon	(	const QPoint *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1554 of file qpaintengine_raster.cpp.

References d, drawLine_midpoint_dashed_i(), drawLine_midpoint_i(), QPaintEngine::drawPolygon(), Qt::FlatCap, i, int, LineDrawIncludeLastPixel, LineDrawNormal, Qt::OddEvenFill, p, QPaintEngine::PolylineMode, qDebug(), Qt::SolidLine, Qt::WindingFill, QPaintEngine::WindingMode, x, and y.

{
    Q_D(QRasterPaintEngine);
    if (!(d->int_xform && d->fast_pen)) {
        // this calls the float version
        QPaintEngine::drawPolygon(points, pointCount, mode);
        return;
    }

#ifdef QT_DEBUG_DRAW
    qDebug(" - QRasterPaintEngine::drawPolygon(), pointCount=%d", pointCount);
    for (int i=0; i<pointCount; ++i)
        qDebug() << "   - " << points[i];
#endif
    Q_ASSERT(pointCount >= 2);

    // Do the fill
    if (d->brushData.blend && mode != PolylineMode) {

        // Compose polygon fill..,
        d->outlineMapper->beginOutline(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
        d->outlineMapper->moveTo(*points);
        const QPoint *p = points;
        const QPoint *ep = points + pointCount - 1;
        do {
            d->outlineMapper->lineTo(*(++p));
        } while (p < ep);
        d->outlineMapper->endOutline();

        // scanconvert.
        d->rasterize(d->outlineMapper->outline(), d->brushData.blend, &d->brushData, d->rasterBuffer);
    }

    // Do the outline...
    if (d->penData.blend) {

        bool needs_closing = mode != PolylineMode && points[0] != points[pointCount-1];

        QRect devRect(0, 0, d->deviceRect.width(), d->deviceRect.height());

        LineDrawMode mode_for_last = (d->pen.capStyle() != Qt::FlatCap
                                      ? LineDrawIncludeLastPixel
                                      : LineDrawNormal);

        int m11 = int(d->matrix.m11());
        int m22 = int(d->matrix.m22());
        int dx = int(d->matrix.dx());
        int dy = int(d->matrix.dy());

        int dashOffset = 0;

        // Draw all the line segments.
        for (int i=1; i<pointCount; ++i) {
            if (d->pen.style() == Qt::SolidLine)
                drawLine_midpoint_i(points[i-1].x() * m11 + dx, points[i-1].y() * m22 + dy,
                                    points[i].x() * m11 + dx, points[i].y() * m22 + dy,
                                    d->penData.blend, &d->penData,
                                    i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
                                    devRect);
            else
                drawLine_midpoint_dashed_i(points[i-1].x() * m11 + dx, points[i-1].y() * m22 + dy,
                                           points[i].x() * m11 + dx, points[i].y() * m22 + dy,
                                           &d->pen,
                                           d->penData.blend, &d->penData,
                                           i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
                                           devRect, &dashOffset);

        }

        // Polygons are implicitly closed.
        if (needs_closing) {
            if (d->pen.style() == Qt::SolidLine)
                drawLine_midpoint_i(points[pointCount-1].x() * m11 + dx, points[pointCount-1].y() * m22 + dy,
                                    points[0].x() * m11 + dx, points[0].y() * m22 + dy,
                                    d->penData.blend, &d->penData, LineDrawIncludeLastPixel,
                                    devRect);
            else
                drawLine_midpoint_dashed_i(points[pointCount-1].x() * m11 + dx, points[pointCount-1].y() * m22 + dy,
                                    points[0].x() * m11 + dx, points[0].y() * m22 + dy,
                                           &d->pen,
                                           d->penData.blend, &d->penData, LineDrawIncludeLastPixel,
                                           devRect, &dashOffset);
        }

    }

}

Here is the call graph for this function:

void QRasterPaintEngine::fillPath	(	const QPainterPath &	path,
		QSpanData *	fillData
	)

Definition at line 1266 of file qpaintengine_raster.cpp.

References QSpanData::blend, d, path, and qDebug().

Referenced by drawImage(), drawPath(), and drawTiledPixmap().

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " --- fillPath, bounds=" << path.boundingRect();
#endif

    if (!fillData->blend)
        return;

    Q_D(QRasterPaintEngine);
    d->rasterize(d->outlineMapper->convertPath(path), fillData->blend, fillData, d->rasterBuffer);
}

Here is the call graph for this function:

void QRasterPaintEngine::drawEllipse

(

const QRectF &

rect

)

[virtual]

Reimplemented from QPaintEngine.

Definition at line 2499 of file qpaintengine_raster.cpp.

References d, drawEllipse_midpoint_i(), QRectF::height(), i, int_dim, Qt::NoPen, qMax(), qt_curves_for_arc(), Qt::SolidLine, start, QPainterPrivate::TxNone, QPainterPrivate::TxScale, QRectF::width(), width, Qt::WindingFill, QRectF::x(), and QRectF::y().

{
    Q_D(QRasterPaintEngine);
    if (!d->brushData.blend && !d->penData.blend)
        return;

    const QRectF r = d->matrix.mapRect(rect);
    if (d->fast_pen
        && (d->pen.style() == Qt::SolidLine || d->pen.style() == Qt::NoPen)
        && qMax(r.width(), r.height()) < 128 // integer math breakdown
        && d->txop <= QPainterPrivate::TxScale) // no shear
    {
        const QRect devRect(0, 0, d->deviceRect.width(), d->deviceRect.height());
#ifdef QT_EXPERIMENTAL_REGIONS
        const QRect brect = QRect(int(r.x()), int(r.y()),
                                  int_dim(r.x(), r.width()),
                                  int_dim(r.y(), r.height()));
        const bool unclipped = qt_region_strictContains(d->clipRegion, brect);
        ProcessSpans penBlend;
        ProcessSpans brushBlend;
        if (unclipped) {
            penBlend = d->penData.unclipped_blend;
            brushBlend = d->brushData.unclipped_blend;
        } else {
            penBlend = d->penData.blend;
            brushBlend = d->brushData.blend;
        }
        drawEllipse_midpoint_i(brect, devRect, penBlend, brushBlend,
                               &d->penData, &d->brushData);
#else
        drawEllipse_midpoint_i(QRect(int(r.x()), int(r.y()),
                                     int_dim(r.x(), r.width()), int_dim(r.y(), r.height())),
                               devRect,
                               d->penData.blend, d->brushData.blend,
                               &d->penData, &d->brushData);
#endif
        return;
    }

    if (d->brushData.blend) {
        QPointF controlPoints[12];
        int point_count = 0;
        QPointF start = qt_curves_for_arc(rect, 0, 360, controlPoints, &point_count);

        Q_ASSERT(point_count == 12); // a perfect circle...

        d->outlineMapper->beginOutline(Qt::WindingFill);
        d->outlineMapper->moveTo(start);
        for (int i=0; i<point_count; i+=3) {
            d->outlineMapper->curveTo(controlPoints[i], controlPoints[i+1], controlPoints[i+2]);
        }
        d->outlineMapper->endOutline();

        d->rasterize(d->outlineMapper->outline(), d->brushData.blend, &d->brushData, d->rasterBuffer);
    }

    if (d->penData.blend) {
        qreal width = d->pen.widthF();
        d->outlineMapper->beginOutline(Qt::WindingFill);
        if (width == 0) {
            d->outlineMapper->setMatrix(QMatrix(), QPainterPrivate::TxNone);
            d->stroker->strokeEllipse(rect, d->outlineMapper, d->matrix);
        } else {
            d->outlineMapper->setMatrix(d->matrix, d->txop);
            d->stroker->strokeEllipse(rect, d->outlineMapper, QMatrix());
        }
        d->outlineMapper->endOutline();

        d->rasterize(d->outlineMapper->outline(), d->penData.blend, &d->penData, d->rasterBuffer);

        d->outlineMapper->setMatrix(d->matrix, d->txop);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawRects	(	const QRect *	rects,
		int	rectCount
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1335 of file qpaintengine_raster.cpp.

References d, drawPolygon(), QPaintEngine::drawRects(), fillRect(), QRect::height(), int, left(), QRect::normalized(), offset_x, offset_y, qDebug(), right(), QRect::translated(), QPainterPrivate::TxTranslate, QRect::width(), QPaintEngine::WindingMode, QRect::x(), and QRect::y().

{
#ifdef QT_DEBUG_DRAW
    qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
#endif
    Q_D(QRasterPaintEngine);
    if (!d->antialiased && d->txop <= QPainterPrivate::TxTranslate) {
        int offset_x = int(d->matrix.dx());
        int offset_y = int(d->matrix.dy());

        const QRect *lastRect = rects + rectCount;

        while (rects < lastRect) {

            QRect rect = rects->normalized();
            if (d->brushData.blend) {
                QRect r = rect.translated(offset_x, offset_y);
#ifdef QT_EXPERIMENTAL_REGIONS
                fillRect(r, d->clipRegion, &d->brushData);
#else
                fillRect(r, &d->brushData);
#endif
            }

            if (d->penData.blend) {
                ProcessSpans brush_blend = d->brushData.blend;
                d->brushData.blend = 0;
                int left = rect.x();
                int right = rect.x() + rect.width();
                int top = rect.y();
                int bottom = rect.y() + rect.height();
                QPoint pts[] = { QPoint(left, top),
                                 QPoint(right, top),
                                 QPoint(right, bottom),
                                 QPoint(left, bottom) };
                QRasterPaintEngine::drawPolygon(pts, 4, WindingMode);
                d->brushData.blend = brush_blend;
            }

            ++rects;
        }
    } else {
        QPaintEngine::drawRects(rects, rectCount);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawRects	(	const QRectF *	rects,
		int	rectCount
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1384 of file qpaintengine_raster.cpp.

References QPaintEngine::ConvexMode, drawPolygon(), i, and qDebug().

{
#ifdef QT_DEBUG_DRAW
    qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
#endif
    for (int i=0; i<rectCount; ++i) {
        const QRectF &rf = rects[i];
        QPointF pts[4] = { QPointF(rf.x(), rf.y()),
                           QPointF(rf.x() + rf.width(), rf.y()),
                           QPointF(rf.x() + rf.width(), rf.y() + rf.height()),
                           QPointF(rf.x(), rf.y() + rf.height()) };
        drawPolygon(pts, 4, ConvexMode);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawPixmap	(	const QRectF &	r,
		const QPixmap &	pixmap,
		const QRectF &	sr
	)			[virtual]

Implements QPaintEngine.

Definition at line 1645 of file qpaintengine_raster.cpp.

References d, QPixmap::data, QPixmap::depth(), drawImage(), QRectF::height(), qDebug(), qRound(), QRectF::size(), QPixmap::size(), QPixmap::toImage(), QRectF::topLeft(), QPainterPrivate::TxTranslate, QPixmap::width(), QRectF::width(), QRectF::x(), and QRectF::y().

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
#endif

    Q_D(QRasterPaintEngine);

    if (pixmap.depth() == 1) {
        if (d->txop <= QPainterPrivate::TxTranslate
            && r.size() == sr.size()
            && r.size() == pixmap.size()) {
            d->drawBitmap(r.topLeft() + QPointF(d->matrix.dx(), d->matrix.dy()), pixmap, &d->penData);
            return;
        } else {
            drawImage(r, d->rasterBuffer->colorizeBitmap(pixmap.toImage(), d->pen.color()), sr);
        }
    } else {
#if defined(Q_WS_MAC)
        if(CGContextRef ctx = macCGContext()) {
            const CGRect dest = CGRectMake(r.x(), r.y(), r.width(), r.height());
            QCFType<CGImageRef> subimage;
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
            if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
                const CGRect source = CGRectMake(sr.x(), sr.y(), sr.width(), sr.height());
                subimage = CGImageCreateWithImageInRect(pixmap.data->cg_data, source);
            } else
#endif
            {
                int sx = qRound(sr.x());
                int sy = qRound(sr.y());
                int sw = qRound(sr.width());
                int sh = qRound(sr.height());
                quint32 *pantherData = pixmap.data->pixels + (sy * pixmap.width() + sx);
                QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(0,
                                                                   pantherData, sw*sh*sizeof(uint),
                                                                   0);
                subimage = CGImageCreate(sw, sh, 8, 32, pixmap.width() * sizeof(uint),
                                QCFType<CGColorSpaceRef>(CGColorSpaceCreateDeviceRGB()),
                                kCGImageAlphaPremultipliedFirst, provider, 0, 0,
                                kCGRenderingIntentDefault);
            }
            HIViewDrawCGImage(ctx, &dest, subimage); //top left
        } else
#endif
            drawImage(r, pixmap.toImage(), sr);
    }

}

Here is the call graph for this function:

void QRasterPaintEngine::drawImage	(	const QRectF &	r,
		const QImage &	img,
		const QRectF &	sr,
		Qt::ImageConversionFlags	falgs = Qt::AutoColor
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1698 of file qpaintengine_raster.cpp.

References QSpanData::adjustSpanMethods(), TokenEngine::copy(), d, QImage::depth(), QSpanData::dx, QSpanData::dy, fillPath(), fillRect(), QRectF::height(), QSpanData::init(), QSpanData::initTexture(), path, qDebug(), QSpanData::setupMatrix(), QImage::size(), QSpanData::Texture, QRectF::toRect(), QRectF::translate(), QPainterPrivate::TxRotShear, QPainterPrivate::TxTranslate, QSpanData::type, QRectF::width(), QRectF::x(), and QRectF::y().

Referenced by drawPixmap().

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::drawImage(), r=" << r << " sr=" << sr << " image=" << img.size() << "depth=" << img.depth();
#endif

    Q_D(QRasterPaintEngine);
    QSpanData textureData;
    textureData.init(d->rasterBuffer, this);
    textureData.type = QSpanData::Texture;
    textureData.initTexture(&img, d->opacity);

    bool stretch_sr = r.width() != sr.width() || r.height() != sr.height();

    if (d->txop > QPainterPrivate::TxTranslate || stretch_sr) {
        QMatrix copy = d->matrix;
        copy.translate(r.x(), r.y());
        if (stretch_sr)
            copy.scale(r.width() / sr.width(), r.height() / sr.height());
        copy.translate(-sr.x(), -sr.y());
        textureData.setupMatrix(copy, QPainterPrivate::TxRotShear, d->bilinear);
  textureData.adjustSpanMethods();

        bool wasAntialiased = d->antialiased;
        if (!d->antialiased)
            d->antialiased = d->bilinear;
        QPainterPath path;
        path.addRect(r);
        fillPath(path, &textureData);
        d->antialiased = wasAntialiased;
    } else {
        textureData.dx = -(r.x() + d->matrix.dx()) + sr.x();
        textureData.dy = -(r.y() + d->matrix.dy()) + sr.y();

        QRectF rr = r;
        rr.translate(d->matrix.dx(), d->matrix.dy());
#ifdef QT_EXPERIMENTAL_REGIONS
        fillRect(rr.toRect(), d->clipRegion, &textureData);
#else
        fillRect(rr.toRect(), &textureData);
#endif
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawTiledPixmap	(	const QRectF &	r,
		const QPixmap &	pixmap,
		const QPointF &	sr
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1746 of file qpaintengine_raster.cpp.

References TokenEngine::copy(), d, QPixmap::depth(), QSpanData::dx, QSpanData::dy, fillPath(), fillRect(), image, QSpanData::init(), QSpanData::initTexture(), path, qDebug(), QSpanData::setupMatrix(), QPixmap::size(), QSpanData::Texture, TextureData::Tiled, QPixmap::toImage(), QRectF::toRect(), QRectF::translate(), QPainterPrivate::TxRotShear, QPainterPrivate::TxTranslate, QSpanData::type, QRectF::x(), QPointF::x(), QRectF::y(), and QPointF::y().

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::drawTiledPixmap(), r=" << r << "pixmap=" << pixmap.size();
#endif
    Q_D(QRasterPaintEngine);

    QImage image;
    if (pixmap.depth() == 1)
        image = d->rasterBuffer->colorizeBitmap(pixmap.toImage(), d->pen.color());
    else
        image = pixmap.toImage();

    QSpanData textureData;
    textureData.init(d->rasterBuffer, this);
    textureData.type = QSpanData::Texture;
    textureData.initTexture(&image, d->opacity, TextureData::Tiled);

    if (d->txop > QPainterPrivate::TxTranslate) {
        QMatrix copy = d->matrix;
        copy.translate(r.x(), r.y());
        copy.translate(-sr.x(), -sr.y());
        textureData.setupMatrix(copy, QPainterPrivate::TxRotShear, d->bilinear);

        bool wasAntialiased = d->antialiased;
        if (!d->antialiased)
            d->antialiased = d->bilinear;
        QPainterPath path;
        path.addRect(r);
        fillPath(path, &textureData);
        d->antialiased = wasAntialiased;
    } else {
        textureData.dx = -(r.x() + d->matrix.dx()) + sr.x();
        textureData.dy = -(r.y() + d->matrix.dy()) + sr.y();

        QRectF rr = r;
        rr.translate(d->matrix.dx(), d->matrix.dy());
#ifdef QT_EXPERIMENTAL_REGIONS
        fillRect(rr.toRect(), d->clipRegion, &textureData);
#else
        fillRect(rr.toRect(), &textureData);
#endif
    }

}

Here is the call graph for this function:

void QRasterPaintEngine::drawTextItem	(	const QPointF &	p,
		const QTextItem &	textItem
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 1952 of file qpaintengine_raster.cpp.

References QPaintEngine::drawTextItem(), and p.

{
    QPaintEngine::drawTextItem(p, textItem);
    // #####
}

Here is the call graph for this function:

void QRasterPaintEngine::drawLines	(	const QLine *	lines,
		int	lineCount
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 2338 of file qpaintengine_raster.cpp.

References d, drawLine_midpoint_dashed_i(), drawLine_midpoint_i(), Qt::FlatCap, i, int, l, LineDrawIncludeLastPixel, LineDrawNormal, qDebug(), Qt::SolidLine, QLineF::x1(), QLineF::x2(), QLineF::y1(), and QLineF::y2().

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::drawLine()";
#endif
    Q_D(QRasterPaintEngine);
    if (!d->penData.blend)
        return;
    if (d->fast_pen) {
        QRect bounds(0, 0, d->deviceRect.width(), d->deviceRect.height());
        LineDrawMode mode = d->pen.capStyle() == Qt::FlatCap
                            ? LineDrawNormal
                            : LineDrawIncludeLastPixel;

        int m11 = int(d->matrix.m11());
        int m22 = int(d->matrix.m22());
        int dx = int(d->matrix.dx());
        int dy = int(d->matrix.dy());
        for (int i=0; i<lineCount; ++i) {
            int dashOffset = 0;
            if (d->int_xform) {
                const QLine &l = lines[i];
                int x1 = l.x1() * m11 + dx;
                int y1 = l.y1() * m22 + dy;
                int x2 = l.x2() * m11 + dx;
                int y2 = l.y2() * m22 + dy;

#ifdef QT_EXPERIMENTAL_REGIONS
                const QRect brect(QPoint(x1, y1), QPoint(x2, y2));
                const bool unclipped = qt_region_strictContains(d->clipRegion,
                                                                brect);
                ProcessSpans penBlend;
                if (unclipped)
                    penBlend = d->penData.unclipped_blend;
                else
                    penBlend = d->penData.blend;
                if (d->pen.style() == Qt::SolidLine)
                    drawLine_midpoint_i(x1, y1, x2, y2,
                                        penBlend, &d->penData, mode, bounds);
                else
                    drawLine_midpoint_dashed_i(x1, y1, x2, y2,
                                               &d->pen, penBlend,
                                               &d->penData, mode, bounds,
                                               &dashOffset);
#else
                if (d->pen.style() == Qt::SolidLine)
                    drawLine_midpoint_i(x1, y1, x2, y2,
                                        d->penData.blend, &d->penData, mode, bounds);
                else
                    drawLine_midpoint_dashed_i(x1, y1, x2, y2,
                                               &d->pen, d->penData.blend,
                                               &d->penData, mode, bounds,
                                               &dashOffset);
#endif
            } else {
                QLineF line = lines[i] * d->matrix;
#ifdef QT_EXPERIMENTAL_REGIONS
                const QRect brect(QPoint(int(line.x1()), int(line.y1())),
                                  QPoint(int(line.x2()), int(line.y2())));
                const bool unclipped = qt_region_strictContains(d->clipRegion,
                                                                brect);
                ProcessSpans penBlend;
                if (unclipped)
                    penBlend = d->penData.unclipped_blend;
                else
                    penBlend = d->penData.blend;
                if (d->pen.style() == Qt::SolidLine)
                    drawLine_midpoint_i(int(line.x1()), int(line.y1()),
                                        int(line.x2()), int(line.y2()),
                                        penBlend, &d->penData, mode, bounds);
                else
                    drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
                                               int(line.x2()), int(line.y2()),
                                               &d->pen, penBlend,
                                               &d->penData, mode, bounds,
                                               &dashOffset);
#else
                if (d->pen.style() == Qt::SolidLine)
                    drawLine_midpoint_i(int(line.x1()), int(line.y1()),
                                        int(line.x2()), int(line.y2()),
                                        d->penData.blend, &d->penData, mode, bounds);
                else
                    drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
                                               int(line.x2()), int(line.y2()),
                                               &d->pen, d->penData.blend,
                                               &d->penData, mode, bounds,
                                               &dashOffset);
#endif
            }
        }
    } else {
        QPaintEngine::drawLines(lines, lineCount);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawLines	(	const QLineF *	lines,
		int	lineCount
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 2436 of file qpaintengine_raster.cpp.

References d, drawLine_midpoint_dashed_i(), drawLine_midpoint_i(), QPaintEngine::drawLines(), Qt::FlatCap, i, LineDrawIncludeLastPixel, LineDrawNormal, qDebug(), and Qt::SolidLine.

{
#ifdef QT_DEBUG_DRAW
    qDebug() << " - QRasterPaintEngine::drawLine()";
#endif
    Q_D(QRasterPaintEngine);
    if (!d->penData.blend)
        return;
    if (d->fast_pen) {
        QRect bounds(0, 0, d->deviceRect.width(), d->deviceRect.height());
        LineDrawMode mode = d->pen.capStyle() == Qt::FlatCap
                            ? LineDrawNormal
                            : LineDrawIncludeLastPixel;
        for (int i=0; i<lineCount; ++i) {
            QLineF line = lines[i] * d->matrix;
            int dashOffset = 0;
#ifdef QT_EXPERIMENTAL_REGIONS
            const QRect brect(QPoint(int(line.x1()), int(line.y1())),
                              QPoint(int(line.x2()), int(line.y2())));
            const bool unclipped = qt_region_strictContains(d->clipRegion,
                                                            brect);
            ProcessSpans penBlend;
            if (unclipped)
                penBlend = d->penData.unclipped_blend;
            else
                penBlend = d->penData.blend;
            if (d->pen.style() == Qt::SolidLine)
                drawLine_midpoint_i(brect.left(), brect.top(),
                                    brect.right(), brect.bottom(),
                                    penBlend, &d->penData, mode, bounds);
            else
                drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
                                           int(line.x2()), int(line.y2()),
                                           &d->pen,
                                           penBlend, &d->penData, mode,
                                           bounds, &dashOffset);
#else
            if (d->pen.style() == Qt::SolidLine)
                drawLine_midpoint_i(int(line.x1()), int(line.y1()),
                                    int(line.x2()), int(line.y2()),
                                    d->penData.blend, &d->penData, mode, bounds);
            else
                drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
                                           int(line.x2()), int(line.y2()),
                                           &d->pen,
                                           d->penData.blend, &d->penData, mode,
                                           bounds, &dashOffset);
#endif
        }
    } else {
        QPaintEngine::drawLines(lines, lineCount);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::drawPoints	(	const QPointF *	points,
		int	pointCount
	)			[virtual]

Reimplemented from QPaintEngine.

Definition at line 2276 of file qpaintengine_raster.cpp.

References QVarLengthArray< T, Prealloc >::constData(), d, drawPath(), end(), Qt::FlatCap, left(), Qt::NoBrush, path, qFloor(), right(), Qt::SquareCap, QPainterPrivate::TxTranslate, QT_FT_Span_::x, QPointF::x(), QPointF::y(), and QT_FT_Span_::y.

{
    Q_D(QRasterPaintEngine);

    double pw = d->pen.widthF();

    if (!d->fast_pen && (d->txop > QPainterPrivate::TxTranslate || pw > 1)) {
        QBrush oldBrush = d->brush;
        d->brush = Qt::NoBrush;

        bool flat_pen = d->pen.capStyle() == Qt::FlatCap;
        if (flat_pen)
            d->basicStroker.setCapStyle(Qt::SquareCap);

        const QPointF *end = points + pointCount;
        while (points < end) {
            QPainterPath path;
            path.moveTo(*points);
            path.lineTo(points->x() + 0.001, points->y());
            drawPath(path);
            ++points;
        }

        d->brush = oldBrush;

        if (flat_pen)
            d->basicStroker.setCapStyle(Qt::FlatCap);

    } else {
        if (!d->penData.blend)
            return;

        QVarLengthArray<QT_FT_Span, 4096> array(pointCount);

        QT_FT_Span span = { 0, 1, 0, 255 };
        const QPointF *end = points + pointCount;
        qreal trans_x, trans_y;
        int x, y;
        int left = 0;
        int right = d->deviceRect.width();
        int top = 0;
        int bottom = d->deviceRect.height();
        int count = 0;
        while (points < end) {
            d->matrix.map(points->x(), points->y(), &trans_x, &trans_y);
            x = qFloor(trans_x);
            y = qFloor(trans_y);
            if (x >= left && x < right && y >= top && y < bottom) {
                span.x = x;
                span.y = y;
                array[count++] = span;
            }
            ++points;
        }

        d->penData.blend(count, array.constData(), &d->penData);
    }
}

Here is the call graph for this function:

void QRasterPaintEngine::setFlushOnEnd

(

bool

flush

)

Definition at line 888 of file qpaintengine_raster.cpp.

References d.

Referenced by QRasterPaintDevice::QRasterPaintDevice().

{
    Q_D(QRasterPaintEngine);

    d->flushOnEnd = flushOnEnd;
}

void QRasterPaintEngine::flush	(	QPaintDevice *	device,
		const QPoint &	offset
	)

Definition at line 901 of file qpaintengine_raster.cpp.

References QVector< T >::at(), d, QPaintDevice::devType(), i, QRegion::isEmpty(), QRegion::rects(), QVector< T >::size(), QPaintEngine::systemClip(), QInternal::Widget, QPoint::x(), and QPoint::y().

Referenced by end().

{
    Q_D(QRasterPaintEngine);
    Q_ASSERT(device);

#if defined(Q_WS_WIN)
    if (!d->rasterBuffer->hdc())
        return;

    if (device->devType() == QInternal::Widget) {
        HDC hdc = device->getDC();

        QRegion sysClip = systemClip();
        if (sysClip.isEmpty()) {
            BitBlt(hdc, d->deviceRect.x() + offset.x(), d->deviceRect.y() + offset.y(),
                   d->deviceRect.width(), d->deviceRect.height(),
                   d->rasterBuffer->hdc(), 0, 0, SRCCOPY);
        } else {
            QVector<QRect> rects = sysClip.rects();
            for (int i=0; i<rects.size(); ++i) {
                QRect r = rects.at(i);
                BitBlt(hdc,
                       r.x() + offset.x(), r.y() + offset.y(), r.width(), r.height(),
                       d->rasterBuffer->hdc(), r.x() - d->deviceRect.x(), r.y() - d->deviceRect.y(),
                       SRCCOPY);
            }
        }

        device->releaseDC(hdc);
    }
#elif defined(Q_WS_MAC)
    extern CGContextRef qt_mac_cg_context(const QPaintDevice *); //qpaintdevice_mac.cpp
    extern void qt_mac_clip_cg(CGContextRef, const QRegion &, const QPoint *, CGAffineTransform *); //qpaintengine_mac.cpp
    if(CGContextRef ctx = qt_mac_cg_context(device)) {
        qt_mac_clip_cg(ctx, systemClip(), 0, 0);
        const CGRect source = CGRectMake(0, 0, d->deviceRect.width(), d->deviceRect.height());
        QCFType<CGImageRef> subimage;
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
            subimage = CGImageCreateWithImageInRect(d->rasterBuffer->m_data, source);
        } else
#endif
        {
            int dw = d->deviceRect.width();
            int dh = d->deviceRect.height();
            QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(
                                                            d->rasterBuffer->buffer(),
                                                            d->rasterBuffer->buffer(),
                                                            dw*dh*sizeof(uint), 0);
            subimage = CGImageCreate(dw, dh, 8, 32, d->rasterBuffer->width() * sizeof(uint),
                                     QCFType<CGColorSpaceRef>(CGColorSpaceCreateDeviceRGB()),
                                     kCGImageAlphaPremultipliedFirst, provider, 0, 0,
                                     kCGRenderingIntentDefault);
        }
        const CGRect dest = CGRectMake(offset.x(), offset.y(),
                                       d->deviceRect.width(), d->deviceRect.height());
        HIViewDrawCGImage(ctx, &dest, subimage); //top left
        CGContextRelease(ctx);
        CGImageRelease(subimage);
    }
#else
    Q_UNUSED(d);
    Q_UNUSED(device);
    Q_UNUSED(offset);
#endif
}

Here is the call graph for this function:

void QRasterPaintEngine::releaseBuffer

(

)

Definition at line 858 of file qpaintengine_raster.cpp.

References d.

{
    Q_D(QRasterPaintEngine);
    delete d->rasterBuffer;
    d->rasterBuffer = new QRasterBuffer;
}

QSize QRasterPaintEngine::size

(

)

const

Definition at line 868 of file qpaintengine_raster.cpp.

References d.

Referenced by QRasterPaintDevice::size().

{
    Q_D(const QRasterPaintEngine);
    return QSize(d->rasterBuffer->width(), d->rasterBuffer->height());
}

void QRasterPaintEngine::saveBuffer

(

const QString &

s

)

const

Definition at line 878 of file qpaintengine_raster.cpp.

References d, and s.

{
    Q_D(const QRasterPaintEngine);
    d->rasterBuffer->bufferImage().save(s, "PNG");
}

Type QRasterPaintEngine::type

(

)

const [inline, virtual]

Implements QPaintEngine.

Definition at line 131 of file qpaintengine_raster_p.h.

{ return Raster; }

QPoint QRasterPaintEngine::coordinateOffset

(

)

const [virtual]

Reimplemented from QPaintEngine.

Definition at line 2617 of file qpaintengine_raster.cpp.

References d.

{
    Q_D(const QRasterPaintEngine);
    return QPoint(d->deviceRect.x(), d->deviceRect.y());
}

void QRasterPaintEngine::init

(

)

[private]

Definition at line 597 of file qpaintengine_raster.cpp.

References d, qt_ft_outline_cubic_to(), qt_ft_outline_line_to(), and qt_ft_outline_move_to().

Referenced by QRasterPaintEngine().

{
    Q_D(QRasterPaintEngine);

    d->rasterPoolSize = 4096;
    d->rasterPoolBase =
#if defined(Q_WS_WIN64)
        (unsigned char *) _aligned_malloc(d->rasterPoolSize, __alignof(void*));
#else
        (unsigned char *) malloc(d->rasterPoolSize);
#endif

    // The antialiasing raster.
    d->grayRaster = new QT_FT_Raster;
    qt_ft_grays_raster.raster_new(0, d->grayRaster);
    qt_ft_grays_raster.raster_reset(*d->grayRaster, d->rasterPoolBase, d->rasterPoolSize);

    // Initialize the standard raster.
    d->blackRaster = new QT_FT_Raster;
    qt_ft_standard_raster.raster_new(0, d->blackRaster);
    qt_ft_standard_raster.raster_reset(*d->blackRaster, d->rasterPoolBase, d->rasterPoolSize);

    d->rasterBuffer = new QRasterBuffer();
#ifdef Q_WS_WIN
    d->fontRasterBuffer = new QRasterBuffer();
#endif
    d->outlineMapper = new QFTOutlineMapper;

    d->dashStroker = 0;

    d->flushOnEnd = true;

    d->basicStroker.setMoveToHook(qt_ft_outline_move_to);
    d->basicStroker.setLineToHook(qt_ft_outline_line_to);
    d->basicStroker.setCubicToHook(qt_ft_outline_cubic_to);
    d->dashStroker = 0;
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

QSpan [related]

A struct equivalent to QT_FT_Span, containing a position (x, y), the span's length in pixels and its color/coverage (a value ranging from 0 to 255).

---

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

• src/gui/painting/qpaintengine_raster_p.h
• src/gui/painting/qpaintengine_raster.cpp

---