The QRasterPaintEngine class enables hardware acceleration of painting operations in Qt for Embedded Linux. More...

#include <qpaintengine_raster_p.h>

Inheritance diagram for QRasterPaintEngine:

Public Types
enum	ClipType { RectClip, ComplexClip }

Public Types inherited from QPaintEngineEx
enum	Flags { DoNotEmulate = 0x01, IsEmulationEngine = 0x02 }

Public Types inherited from QPaintEngine
enum	DirtyFlag { DirtyPen = 0x0001, DirtyBrush = 0x0002, DirtyBrushOrigin = 0x0004, DirtyFont = 0x0008, DirtyBackground = 0x0010, DirtyBackgroundMode = 0x0020, DirtyTransform = 0x0040, DirtyClipRegion = 0x0080, DirtyClipPath = 0x0100, DirtyHints = 0x0200, DirtyCompositionMode = 0x0400, DirtyClipEnabled = 0x0800, DirtyOpacity = 0x1000, AllDirty = 0xffff }
	QPaintEngine::updateState(). More...

enum	PaintEngineFeature { PrimitiveTransform = 0x00000001, PatternTransform = 0x00000002, PixmapTransform = 0x00000004, PatternBrush = 0x00000008, LinearGradientFill = 0x00000010, RadialGradientFill = 0x00000020, ConicalGradientFill = 0x00000040, AlphaBlend = 0x00000080, PorterDuff = 0x00000100, PainterPaths = 0x00000200, Antialiasing = 0x00000400, BrushStroke = 0x00000800, ConstantOpacity = 0x00001000, MaskedBrush = 0x00002000, PerspectiveTransform = 0x00004000, BlendModes = 0x00008000, ObjectBoundingModeGradients = 0x00010000, RasterOpModes = 0x00020000, PaintOutsidePaintEvent = 0x20000000, AllFeatures = 0xffffffff }
	This enum is used to describe the features or capabilities that the paint engine has. More...

enum	PolygonDrawMode { OddEvenMode, WindingMode, ConvexMode, PolylineMode }

enum	Type { X11, Windows, QuickDraw, CoreGraphics, MacPrinter, QWindowSystem, PostScript, OpenGL, Picture, SVG, Raster, Direct3D, Pdf, OpenVG, OpenGL2, PaintBuffer, Blitter, User = 50, MaxUser = 100 }

Public Functions
void	alphaPenBlt (const void *src, int bpl, int depth, int rx, int ry, int w, int h)

bool	begin (QPaintDevice *device)
	Reimplemented Function More...

void	brushChanged ()

void	brushOriginChanged ()

void	clip (const QVectorPath &path, Qt::ClipOperation op)

void	clip (const QRect &rect, Qt::ClipOperation op)

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

QRect	clipBoundingRect () const
	Returns the bounding rect of the currently set clip. More...

void	clipEnabledChanged ()

ClipType	clipType () const
	Returns the type of the clip currently set. More...

void	compositionModeChanged ()

QPoint	coordinateOffset () const

QPainterState *	createState (QPainterState *orig) const

virtual void	drawBufferSpan (const uint *buffer, int bufsize, int x, int y, int length, uint const_alpha)
	Draws the given buffer. More...

virtual void	drawColorSpans (const QSpan *spans, int count, uint color)
	Draws the given color spans with the specified color. More...

void	drawEllipse (const QRectF &rect)
	Reimplemented Function More...

void	drawImage (const QPointF &p, const QImage &img)

void	drawImage (const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags falgs=Qt::AutoColor)
	Reimplemented Function More...

void	drawLines (const QLine *line, int lineCount)
	Reimplemented Function More...

void	drawLines (const QLineF *line, int lineCount)
	Reimplemented Function More...

void	drawPixmap (const QPointF &p, const QPixmap &pm)

void	drawPixmap (const QRectF &r, const QPixmap &pm, const QRectF &sr)
	Reimplemented Function More...

void	drawPoints (const QPointF *points, int pointCount)
	Reimplemented Function More...

void	drawPoints (const QPoint *points, int pointCount)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Draws the first pointCount points in the buffer points. More...

void	drawPolygon (const QPointF *points, int pointCount, PolygonDrawMode mode)
	Reimplemented Function More...

void	drawPolygon (const QPoint *points, int pointCount, PolygonDrawMode mode)
	Reimplemented Function More...

void	drawRects (const QRect *rects, int rectCount)
	Reimplemented Function More...

void	drawRects (const QRectF *rects, int rectCount)
	Reimplemented Function More...

void	drawStaticTextItem (QStaticTextItem *textItem)
	Reimplemented Function More...

void	drawTextItem (const QPointF &p, const QTextItem &textItem)
	Reimplemented Function More...

void	drawTiledPixmap (const QRectF &r, const QPixmap &pm, const QPointF &sr)
	Reimplemented Function More...

bool	end ()
	Reimplemented Function More...

void	fill (const QVectorPath &path, const QBrush &brush)

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

void	fillPolygon (const QPointF *points, int pointCount, PolygonDrawMode mode)

void	fillRect (const QRectF &rect, const QBrush &brush)
	Reimplemented Function More...

void	fillRect (const QRectF &rect, const QColor &color)
	Reimplemented Function More...

CGContextRef	getCGContext () const

HDC	getDC () const

void	opacityChanged ()

void	penChanged ()

	QRasterPaintEngine (QPaintDevice *device)
	Creates a raster based paint engine for operating on the given device, with the complete set of QPaintEngine::PaintEngineFeature {paint engine features and capabilities}. More...

void	releaseBuffer ()

void	releaseDC (HDC hdc) const

void	renderHintsChanged ()

void	saveBuffer (const QString &s) const

void	setCGContext (CGContextRef ref)

void	setDC (HDC hdc)

void	setState (QPainterState *s)

QSize	size () const

QRasterPaintEngineState *	state ()

const QRasterPaintEngineState *	state () const

void	stroke (const QVectorPath &path, const QPen &pen)

bool	supportsTransformations (const QFontEngine *fontEngine) const

bool	supportsTransformations (qreal pixelSize, const QTransform &m) const

void	transformChanged ()

Type	type () const
	Reimplemented Function More...

void	updateBrush (const QBrush &brush)

void	updateMatrix (const QTransform &matrix)

void	updatePen (const QPen &pen)

	~QRasterPaintEngine ()
	Destroys this paint engine. More...

Public Functions inherited from QPaintEngineEx
virtual void	beginNativePainting ()

virtual void	clip (const QPainterPath &path, Qt::ClipOperation op)

virtual void	draw (const QVectorPath &path)

virtual void	drawEllipse (const QRect &r)
	The default implementation of this function calls the floating point version of this function. More...

virtual void	drawPath (const QPainterPath &path)
	The default implementation ignores the path and does nothing. More...

virtual void	drawPixmapFragments (const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints)

virtual void	drawPixmapFragments (const QRectF targetRects, const QRectF sourceRects, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints)

virtual void	drawRoundedRect (const QRectF &rect, qreal xrad, qreal yrad, Qt::SizeMode mode)

virtual void	endNativePainting ()

virtual uint	flags () const

virtual QPixmapFilter *	pixmapFilter (int, const QPixmapFilter *)

	QPaintEngineEx ()

QPainterState *	state ()

const QPainterState *	state () const

virtual void	sync ()

virtual void	updateState (const QPaintEngineState &state)
	Reimplement this function to update the state of a paint engine. More...

Public Functions inherited from QPaintEngine
void	clearDirty (DirtyFlags df)

void	fix_neg_rect (int x, int y, int w, int h)

bool	hasFeature (PaintEngineFeatures feature) const
	Returns true if the paint engine supports the specified feature; otherwise returns false. More...

bool	isActive () const
	Returns true if the paint engine is actively drawing; otherwise returns false. More...

bool	isExtended () const
	Returns true if the paint engine is a QPaintEngineEx derivative. More...

QPaintDevice *	paintDevice () const
	Returns the device that this engine is painting on, if painting is active; otherwise returns 0. More...

QPainter *	painter () const
	Returns the paint engine's painter. More...

	QPaintEngine (PaintEngineFeatures features=0)
	Creates a paint engine with the featureset specified by caps. More...

void	setActive (bool newState)
	Sets the active state of the paint engine to state. More...

void	setDirty (DirtyFlags df)

void	setPaintDevice (QPaintDevice *device)

void	setSystemClip (const QRegion &baseClip)
	Sets the system clip for this engine. More...

void	setSystemRect (const QRect &rect)
	Sets the target rect for drawing within the backing store. More...

void	syncState ()
	Updates all dirty states in this engine. More...

QRegion	systemClip () const
	Returns the system clip. More...

QRect	systemRect () const
	Retrieves the rect for drawing within the backing store. More...

bool	testDirty (DirtyFlags df)

virtual	~QPaintEngine ()
	Destroys the paint engine. More...

Protected Functions
	QRasterPaintEngine (QRasterPaintEnginePrivate &d, QPaintDevice *)

Protected Functions inherited from QPaintEngineEx
	QPaintEngineEx (QPaintEngineExPrivate &data)

Protected Functions inherited from QPaintEngine
	QPaintEngine (QPaintEnginePrivate &data, PaintEngineFeatures devcaps=0)

Private Functions
void	drawBitmap (const QPointF &pos, const QImage &image, QSpanData *fill)

bool	drawCachedGlyphs (int numGlyphs, const glyph_t glyphs, const QFixedPoint positions, QFontEngine *fontEngine)

void	ensureBrush (const QBrush &brush)

void	ensureBrush ()

void	ensureOutlineMapper ()

void	ensurePen (const QPen &pen)

void	ensurePen ()

void	ensureState ()

void	fillRect (const QRectF &rect, QSpanData *data)

void	init ()

bool	setClipRectInDeviceCoords (const QRect &r, Qt::ClipOperation op)

void	updateOutlineMapper ()

void	updateState ()

Friends
class	QBlitterPaintEngine

class	QBlitterPaintEnginePrivate

struct	QSpanData

Related Functions
(Note that these are not member functions.)
	QSpan
	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). More...

Additional Inherited Members
Protected Variables inherited from QPaintEngine
uint	active: 1

QScopedPointer< QPaintEnginePrivate >	d_ptr

uint	extended: 1

PaintEngineFeatures	gccaps

uint	selfDestruct: 1

QPaintEngineState *	state

Detailed Description

The QRasterPaintEngine class enables hardware acceleration of painting operations in Qt for Embedded Linux.

This function is under development and subject to change.

Since: 4.2

Note that this functionality is only available in Qt for Embedded Linux.

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

Hardware acceleration is accomplished by creating a custom screen driver, accelerating the copying from memory to the screen, and implementing a custom paint engine accelerating the various painting operations. Then a custom paint device (derived from the QCustomRasterPaintDevice class) and a custom window surface (derived from QWSWindowSurface) must be implemented to make Qt for Embedded Linux aware of the accelerated driver.

Note: The QRasterPaintEngine class does not support 8-bit images. Instead, they need to be converted to a supported format, such as QImage::Format_ARGB32_Premultiplied.

See the Adding an Accelerated Graphics Driver to Qt for Embedded Linux documentation for details.

See also: QCustomRasterPaintDevice, QPaintEngine

Definition at line 132 of file qpaintengine_raster_p.h.

Enumerations

◆ ClipType

enum QRasterPaintEngine::ClipType

Warning: This function is not part of the public interface.

RectClip Indicates that the currently set clip is a single rectangle.
ComplexClip Indicates that the currently set clip is a combination of several shapes.

Enumerator
RectClip
ComplexClip

Definition at line 205 of file qpaintengine_raster_p.h.

                   {
         RectClip,
         ComplexClip
     };

Constructors and Destructors

◆ QRasterPaintEngine() [1/2]

QRasterPaintEngine::QRasterPaintEngine ( QPaintDevice * device )

Creates a raster based paint engine for operating on the given device, with the complete set of QPaintEngine::PaintEngineFeature {paint engine features and capabilities}.

Since: 4.5

Definition at line 320 of file qpaintengine_raster.cpp.

     : QPaintEngineEx(*(new QRasterPaintEnginePrivate))
 {
     d_func()->device = device;
     init();
 }

◆ ~QRasterPaintEngine()

QRasterPaintEngine::~QRasterPaintEngine ( )

Destroys this paint engine.

Definition at line 430 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
 
     qt_ft_grays_raster.raster_done(*d->grayRaster.data());
 }

◆ QRasterPaintEngine() [2/2]

QRasterPaintEngine::QRasterPaintEngine	(	QRasterPaintEnginePrivate &	dd,
		QPaintDevice *	device
	)

protected

Warning: This function is not part of the public interface.

Definition at line 330 of file qpaintengine_raster.cpp.

     : QPaintEngineEx(dd)
 {
     d_func()->device = device;
     init();
 }

Functions

◆ alphaPenBlt()

void QRasterPaintEngine::alphaPenBlt	(	const void *	src,
		int	bpl,
		int	depth,
		int	rx,
		int	ry,
		int	w,
		int	h
	)

Warning: This function is not part of the public interface.

Definition at line 2557 of file qpaintengine_raster.cpp.

Referenced by QProxyFontEngine::canRender(), QFontEngineQPF::draw(), and QFontEngineQPF1::draw().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     if (!s->penData.blend)
         return;
 
     QRasterBuffer *rb = d->rasterBuffer.data();
 
     const QRect rect(rx, ry, w, h);
     const QClipData *clip = d->clip();
     bool unclipped = false;
     if (clip) {
         // inlined QRect::intersects
         const bool intersects = qMax(clip->xmin, rect.left()) <= qMin(clip->xmax - 1, rect.right())
                                 && qMax(clip->ymin, rect.top()) <= qMin(clip->ymax - 1, rect.bottom());
 
         if (clip->hasRectClip) {
             unclipped = rx > clip->xmin
                         && rx + w < clip->xmax
                         && ry > clip->ymin
                         && ry + h < clip->ymax;
         }
 
         if (!intersects)
             return;
     } else {
         // inlined QRect::intersects
         const bool intersects = qMax(0, rect.left()) <= qMin(rb->width() - 1, rect.right())
                                 && qMax(0, rect.top()) <= qMin(rb->height() - 1, rect.bottom());
         if (!intersects)
             return;
 
         // inlined QRect::contains
         const bool contains = rect.left() >= 0 && rect.right() < rb->width()
                               && rect.top() >= 0 && rect.bottom() < rb->height();
 
         unclipped = contains && d->isUnclipped_normalized(rect);
     }
 
     ProcessSpans blend = unclipped ? s->penData.unclipped_blend : s->penData.blend;
     const uchar * scanline = static_cast<const uchar *>(src);
 
     if (s->flags.fast_text) {
         if (unclipped) {
             if (depth == 1) {
                 if (s->penData.bitmapBlit) {
                     s->penData.bitmapBlit(rb, rx, ry, s->penData.solid.color,
                                           scanline, w, h, bpl);
                     return;
                 }
             } else if (depth == 8) {
                 if (s->penData.alphamapBlit) {
                     s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color,
                                             scanline, w, h, bpl, 0);
                     return;
                 }
             } else if (depth == 32) {
                 // (A)RGB Alpha mask where the alpha component is not used.
                 if (s->penData.alphaRGBBlit) {
                     s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color,
                                             (const uint *) scanline, w, h, bpl / 4, 0);
                     return;
                 }
             }
         } else if (d->deviceDepth == 32 && (depth == 8 || depth == 32)) {
             // (A)RGB Alpha mask where the alpha component is not used.
             if (!clip) {
                 int nx = qMax(0, rx);
                 int ny = qMax(0, ry);
 
                 // Move scanline pointer to compensate for moved x and y
                 int xdiff = nx - rx;
                 int ydiff = ny - ry;
                 scanline += ydiff * bpl;
                 scanline += xdiff * (depth == 32 ? 4 : 1);
 
                 w -= xdiff;
                 h -= ydiff;
 
                 if (nx + w > d->rasterBuffer->width())
                     w = d->rasterBuffer->width() - nx;
                 if (ny + h > d->rasterBuffer->height())
                     h = d->rasterBuffer->height() - ny;
 
                 rx = nx;
                 ry = ny;
             }
             if (depth == 8 && s->penData.alphamapBlit) {
                 s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color,
                                         scanline, w, h, bpl, clip);
             } else if (depth == 32 && s->penData.alphaRGBBlit) {
                 s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color,
                                         (const uint *) scanline, w, h, bpl / 4, clip);
             }
             return;
         }
     }
 
     int x0 = 0;
     if (rx < 0) {
         x0 = -rx;
         w -= x0;
     }
 
     int y0 = 0;
     if (ry < 0) {
         y0 = -ry;
         scanline += bpl * y0;
         h -= y0;
     }
 
     w = qMin(w, rb->width() - qMax(0, rx));
     h = qMin(h, rb->height() - qMax(0, ry));
 
     if (w <= 0 || h <= 0)
         return;
 
     const int NSPANS = 256;
     QSpan spans[NSPANS];
     int current = 0;
 
     const int x1 = x0 + w;
     const int y1 = y0 + h;
 
     if (depth == 1) {
         for (int y = y0; y < y1; ++y) {
             for (int x = x0; x < x1; ) {
                 if (!monoVal(scanline, x)) {
                     ++x;
                     continue;
                 }
 
                 if (current == NSPANS) {
                     blend(current, spans, &s->penData);
                     current = 0;
                 }
                 spans[current].x = x + rx;
                 spans[current].y = y + ry;
                 spans[current].coverage = 255;
                 int len = 1;
                 ++x;
                 // extend span until we find a different one.
                 while (x < x1 && monoVal(scanline, x)) {
                     ++x;
                     ++len;
                 }
                 spans[current].len = len;
                 ++current;
             }
             scanline += bpl;
         }
     } else if (depth == 8) {
         for (int y = y0; y < y1; ++y) {
             for (int x = x0; x < x1; ) {
                 // Skip those with 0 coverage
                 if (scanline[x] == 0) {
                     ++x;
                     continue;
                 }
 
                 if (current == NSPANS) {
                     blend(current, spans, &s->penData);
                     current = 0;
                 }
                 int coverage = scanline[x];
                 spans[current].x = x + rx;
                 spans[current].y = y + ry;
                 spans[current].coverage = coverage;
                 int len = 1;
                 ++x;
 
                 // extend span until we find a different one.
                 while (x < x1 && scanline[x] == coverage) {
                     ++x;
                     ++len;
                 }
                 spans[current].len = len;
                 ++current;
             }
             scanline += bpl;
         }
     } else { // 32-bit alpha...
         uint *sl = (uint *) src;
         for (int y = y0; y < y1; ++y) {
             for (int x = x0; x < x1; ) {
                 // Skip those with 0 coverage
                 if ((sl[x] & 0x00ffffff) == 0) {
                     ++x;
                     continue;
                 }
 
                 if (current == NSPANS) {
                     blend(current, spans, &s->penData);
                     current = 0;
                 }
                 uint rgbCoverage = sl[x];
                 int coverage = qGreen(rgbCoverage);
                 spans[current].x = x + rx;
                 spans[current].y = y + ry;
                 spans[current].coverage = coverage;
                 int len = 1;
                 ++x;
 
                 // extend span until we find a different one.
                 while (x < x1 && sl[x] == rgbCoverage) {
                     ++x;
                     ++len;
                 }
                 spans[current].len = len;
                 ++current;
             }
             sl += bpl / sizeof(uint);
         }
     }
 //     qDebug() << "alphaPenBlt: num spans=" << current
 //              << "span:" << spans->x << spans->y << spans->len << spans->coverage;
         // Call span func for current set of spans.
     if (current != 0)
         blend(current, spans, &s->penData);
 }

◆ begin()

bool QRasterPaintEngine::begin ( QPaintDevice * device )

virtual

Reimplemented Function

Implements QPaintEngine.

Reimplemented in QDirectFBPaintEngine.

Definition at line 440 of file qpaintengine_raster.cpp.

Referenced by QVolatileImagePaintEngine::begin(), QBlitterPaintEngine::begin(), QDirectFBPaintEngine::begin(), QOnScreenRasterPaintEngine::begin(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
 
     if (device->devType() == QInternal::Pixmap) {
         QPixmap *pixmap = static_cast<QPixmap *>(device);
         QPixmapData *pd = pixmap->pixmapData();
         if (pd->classId() == QPixmapData::RasterClass || pd->classId() == QPixmapData::BlitterClass)
             d->device = pd->buffer();
     } else {
         d->device = device;
     }
 
     // Make sure QPaintEngine::paintDevice() returns the proper device.
     d->pdev = d->device;
 
     Q_ASSERT(d->device->devType() == QInternal::Image
              || d->device->devType() == QInternal::CustomRaster);
 
     d->systemStateChanged();
 
     QRasterPaintEngineState *s = state();
     ensureOutlineMapper();
     d->outlineMapper->m_clip_rect = d->deviceRect;
 
     if (d->outlineMapper->m_clip_rect.width() > QT_RASTER_COORD_LIMIT)
         d->outlineMapper->m_clip_rect.setWidth(QT_RASTER_COORD_LIMIT);
     if (d->outlineMapper->m_clip_rect.height() > QT_RASTER_COORD_LIMIT)
         d->outlineMapper->m_clip_rect.setHeight(QT_RASTER_COORD_LIMIT);
 
     d->rasterizer->setClipRect(d->deviceRect);
 
     s->penData.init(d->rasterBuffer.data(), this);
     s->penData.setup(s->pen.brush(), s->intOpacity, s->composition_mode);
     s->stroker = &d->basicStroker;
     d->basicStroker.setClipRect(d->deviceRect);
 
     s->brushData.init(d->rasterBuffer.data(), this);
     s->brushData.setup(s->brush, s->intOpacity, s->composition_mode);
 
     d->rasterBuffer->compositionMode = QPainter::CompositionMode_SourceOver;
 
     setDirty(DirtyBrushOrigin);
 
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::begin(" << (void *) device
              << ") devType:" << device->devType()
              << "devRect:" << d->deviceRect;
     if (d->baseClip) {
         dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);
     }
 #endif
 
 #if defined(Q_WS_WIN)
     d->isPlain45DegreeRotation = true;
 #endif
 
     if (d->mono_surface)
         d->glyphCacheType = QFontEngineGlyphCache::Raster_Mono;
 #if defined(Q_WS_WIN)
     else if (qt_cleartype_enabled)
 #elif defined (Q_WS_MAC)
     else if (qt_applefontsmoothing_enabled)
 #else
     else if (false)
 #endif
     {
         QImage::Format format = static_cast<QImage *>(d->device)->format();
         if (format == QImage::Format_ARGB32_Premultiplied || format == QImage::Format_RGB32)
             d->glyphCacheType = QFontEngineGlyphCache::Raster_RGBMask;
         else
             d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;
     } else
         d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;
 
     setActive(true);
     return true;
 }

◆ brushChanged()

void QRasterPaintEngine::brushChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 823 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::brushChanged(), QDirectFBPaintEngine::brushChanged(), and QBlitterPaintEngine::type().

 {
     QRasterPaintEngineState *s = state();
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::brushChanged():" << s->brush;
 #endif
     s->fillFlags |= DirtyBrush;
 }

◆ brushOriginChanged()

void QRasterPaintEngine::brushOriginChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Definition at line 809 of file qpaintengine_raster.cpp.

 {
     QRasterPaintEngineState *s = state();
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::brushOriginChanged()" << s->brushOrigin;
 #endif
 
     s->fillFlags |= DirtyBrushOrigin;
 }

◆ clip() [1/3]

void QRasterPaintEngine::clip	(	const QVectorPath &	path,
		Qt::ClipOperation	op
	)

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1178 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::clip(), QBlittablePixmapData::paintEngine(), QRasterPaintEngineState::QRasterPaintEngineState(), and QRasterPaintEngineState::~QRasterPaintEngineState().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::clip(): " << path << op;
 
     if (path.elements()) {
         for (int i=0; i<path.elementCount(); ++i) {
             qDebug() << " - " << path.elements()[i]
                      << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')';
         }
     } else {
         for (int i=0; i<path.elementCount(); ++i) {
             qDebug() << " ---- "
                      << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')';
         }
     }
 #endif
 
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     const qreal *points = path.points();
     const QPainterPath::ElementType *types = path.elements();
 
     // There are some cases that are not supported by clip(QRect)
     if (op != Qt::UniteClip && (op != Qt::IntersectClip || !s->clip
                                 || s->clip->hasRectClip || s->clip->hasRegionClip)) {
         if (s->matrix.type() <= QTransform::TxScale
             && ((path.shape() == QVectorPath::RectangleHint)
                 || (isRect(points, path.elementCount())
                     && (!types || (types[0] == QPainterPath::MoveToElement
                                    && types[1] == QPainterPath::LineToElement
                                    && types[2] == QPainterPath::LineToElement
                                    && types[3] == QPainterPath::LineToElement))))) {
 #ifdef QT_DEBUG_DRAW
             qDebug() << " --- optimizing vector clip to rect clip...";
 #endif
 
             QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
             if (setClipRectInDeviceCoords(s->matrix.mapRect(r).toRect(), op))
                 return;
         }
     }
 
     if (op == Qt::NoClip) {
         qrasterpaintengine_state_setNoClip(s);
 
     } else {
         QClipData *base = d->baseClip.data();
 
         // Intersect with current clip when available...
         if (op == Qt::IntersectClip && s->clip)
             base = s->clip;
 
         // We always intersect, except when there is nothing to
         // intersect with, in which case we simplify the operation to
         // a replace...
         Qt::ClipOperation isectOp = Qt::IntersectClip;
         if (base == 0)
             isectOp = Qt::ReplaceClip;
 
         QClipData *newClip = new QClipData(d->rasterBuffer->height());
         newClip->initialize();
         ClipData clipData = { base, newClip, isectOp };
         ensureOutlineMapper();
         d->rasterize(d->outlineMapper->convertPath(path), qt_span_clip, &clipData, 0);
 
         newClip->fixup();
 
         if (op == Qt::UniteClip) {
             // merge clips
             QClipData *result = new QClipData(d->rasterBuffer->height());
             QClipData *current = s->clip ? s->clip : new QClipData(d->rasterBuffer->height());
             qt_merge_clip(current, newClip, result);
             result->fixup();
             delete newClip;
             if (!s->clip)
                 delete current;
             newClip = result;
         }
 
         if (s->flags.has_clip_ownership)
             delete s->clip;
 
         s->clip = newClip;
         s->flags.has_clip_ownership = true;
     }
     qrasterpaintengine_dirty_clip(d, s);
 }

◆ clip() [2/3]

void QRasterPaintEngine::clip	(	const QRect &	rect,
		Qt::ClipOperation	op
	)

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1273 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::clip(): " << rect << op;
 #endif
 
     QRasterPaintEngineState *s = state();
 
     if (op == Qt::NoClip) {
         qrasterpaintengine_state_setNoClip(s);
 
     } else if (op == Qt::UniteClip || s->matrix.type() > QTransform::TxScale) {
         QPaintEngineEx::clip(rect, op);
         return;
 
     } else if (!setClipRectInDeviceCoords(s->matrix.mapRect(rect), op)) {
         QPaintEngineEx::clip(rect, op);
         return;
     }
 }

◆ clip() [3/3]

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

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1349 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::clip(): " << region << op;
 #endif
 
     Q_D(QRasterPaintEngine);
 
     if (region.rectCount() == 1) {
         clip(region.boundingRect(), op);
         return;
     }
 
     QRasterPaintEngineState *s = state();
     const QClipData *clip = d->clip();
     const QClipData *baseClip = d->baseClip.data();
 
     if (op == Qt::NoClip) {
         qrasterpaintengine_state_setNoClip(s);
     } else if (s->matrix.type() > QTransform::TxScale
                || op == Qt::UniteClip
                || (op == Qt::IntersectClip && !clip->hasRectClip && !clip->hasRegionClip)
                || (op == Qt::ReplaceClip && !baseClip->hasRectClip && !baseClip->hasRegionClip)) {
         QPaintEngineEx::clip(region, op);
     } else {
         const QClipData *curClip;
         QClipData *newClip;
 
         if (op == Qt::IntersectClip)
             curClip = clip;
         else
             curClip = baseClip;
 
         if (s->flags.has_clip_ownership) {
             newClip = s->clip;
             Q_ASSERT(newClip);
         } else {
             newClip = new QClipData(d->rasterBuffer->height());
             s->clip = newClip;
             s->flags.has_clip_ownership = true;
         }
 
         QRegion r = s->matrix.map(region);
         if (curClip->hasRectClip)
             newClip->setClipRegion(r & curClip->clipRect);
         else if (curClip->hasRegionClip)
             newClip->setClipRegion(r & curClip->clipRegion);
 
         qrasterpaintengine_dirty_clip(d, s);
     }
 }

◆ clipBoundingRect()

QRect QRasterPaintEngine::clipBoundingRect ( ) const

Returns the bounding rect of the currently set clip.

Warning: This function is not part of the public interface.

Definition at line 3637 of file qpaintengine_raster.cpp.

Referenced by QPixmapConvolutionFilter::draw().

 {
     Q_D(const QRasterPaintEngine);
 
     const QClipData *clip = d->clip();
 
     if (!clip)
         return d->deviceRect;
 
     if (clip->hasRectClip)
         return clip->clipRect;
 
     return QRect(clip->xmin, clip->ymin, clip->xmax - clip->xmin, clip->ymax - clip->ymin);
 }

◆ clipEnabledChanged()

void QRasterPaintEngine::clipEnabledChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 972 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::clipEnabledChanged(), QDirectFBPaintEngine::clipEnabledChanged(), and QBlitterPaintEngine::type().

 {
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::clipEnabledChanged()" << s->clipEnabled;
 #endif
 
     if (s->clip) {
         s->clip->enabled = s->clipEnabled;
         s->fillFlags |= DirtyClipEnabled;
         s->strokeFlags |= DirtyClipEnabled;
         s->pixmapFlags |= DirtyClipEnabled;
     }
 }

◆ clipType()

QRasterPaintEngine::ClipType QRasterPaintEngine::clipType ( ) const

Returns the type of the clip currently set.

Warning: This function is not part of the public interface.

Definition at line 3619 of file qpaintengine_raster.cpp.

Referenced by QPixmapConvolutionFilter::draw().

 {
     Q_D(const QRasterPaintEngine);
 
     const QClipData *clip = d->clip();
     if (!clip || clip->hasRectClip)
         return RectClip;
     else
         return ComplexClip;
 }

◆ compositionModeChanged()

void QRasterPaintEngine::compositionModeChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 902 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::compositionModeChanged(), QDirectFBPaintEngine::compositionModeChanged(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::compositionModeChanged()" << s->composition_mode;
 #endif
 
     s->fillFlags |= DirtyCompositionMode;
     s->dirty |= DirtyCompositionMode;
 
     s->strokeFlags |= DirtyCompositionMode;
     d->rasterBuffer->compositionMode = s->composition_mode;
 
     d->recalculateFastImages();
 }

◆ coordinateOffset()

QPoint QRasterPaintEngine::coordinateOffset ( ) const

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngine.

Definition at line 3460 of file qpaintengine_raster.cpp.

 {
     return QPoint(0, 0);
 }

◆ createState()

QPainterState * QRasterPaintEngine::createState ( QPainterState * orig ) const

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Definition at line 688 of file qpaintengine_raster.cpp.

 {
     QRasterPaintEngineState *s;
     if (!orig)
         s = new QRasterPaintEngineState();
     else
         s = new QRasterPaintEngineState(*static_cast<QRasterPaintEngineState *>(orig));
 
     return s;
 }

◆ drawBitmap()

void QRasterPaintEngine::drawBitmap	(	const QPointF &	pos,
		const QImage &	image,
		QSpanData *	fill
	)

private

Definition at line 3518 of file qpaintengine_raster.cpp.

 {
     Q_ASSERT(fg);
     if (!fg->blend)
         return;
     Q_D(QRasterPaintEngine);
 
     Q_ASSERT(image.depth() == 1);
 
     const int spanCount = 256;
     QT_FT_Span spans[spanCount];
     int n = 0;
 
     // Boundaries
     int w = image.width();
     int h = image.height();
     int ymax = qMin(qRound(pos.y() + h), d->rasterBuffer->height());
     int ymin = qMax(qRound(pos.y()), 0);
     int xmax = qMin(qRound(pos.x() + w), d->rasterBuffer->width());
     int xmin = qMax(qRound(pos.x()), 0);
 
     int x_offset = xmin - qRound(pos.x());
 
     QImage::Format format = image.format();
     for (int y = ymin; y < ymax; ++y) {
         const uchar *src = image.scanLine(y - qRound(pos.y()));
         if (format == QImage::Format_MonoLSB) {
             for (int x = 0; x < xmax - xmin; ++x) {
                 int src_x = x + x_offset;
                 uchar pixel = src[src_x >> 3];
                 if (!pixel) {
                     x += 7 - (src_x%8);
                     continue;
                 }
                 if (pixel & (0x1 << (src_x & 7))) {
                     spans[n].x = xmin + x;
                     spans[n].y = y;
                     spans[n].coverage = 255;
                     int len = 1;
                     while (src_x+1 < w && src[(src_x+1) >> 3] & (0x1 << ((src_x+1) & 7))) {
                         ++src_x;
                         ++len;
                     }
                     spans[n].len = ((len + spans[n].x) > xmax) ? (xmax - spans[n].x) : len;
                     x += len;
                     ++n;
                     if (n == spanCount) {
                         fg->blend(n, spans, fg);
                         n = 0;
                     }
                 }
             }
         } else {
             for (int x = 0; x < xmax - xmin; ++x) {
                 int src_x = x + x_offset;
                 uchar pixel = src[src_x >> 3];
                 if (!pixel) {
                     x += 7 - (src_x%8);
                     continue;
                 }
                 if (pixel & (0x80 >> (x & 7))) {
                     spans[n].x = xmin + x;
                     spans[n].y = y;
                     spans[n].coverage = 255;
                     int len = 1;
                     while (src_x+1 < w && src[(src_x+1) >> 3] & (0x80 >> ((src_x+1) & 7))) {
                         ++src_x;
                         ++len;
                     }
                     spans[n].len = ((len + spans[n].x) > xmax) ? (xmax - spans[n].x) : len;
                     x += len;
                     ++n;
                     if (n == spanCount) {
                         fg->blend(n, spans, fg);
                         n = 0;
                     }
                 }
             }
         }
     }
     if (n) {
         fg->blend(n, spans, fg);
         n = 0;
     }
 }

◆ drawBufferSpan()

void QRasterPaintEngine::drawBufferSpan	(	const uint *	buffer,
		int	size,
		int	x,
		int	y,
		int	length,
		uint	alpha
	)

virtual

Draws the given buffer.

The default implementation does nothing; reimplement this function to draw a buffer that contains more than one color. Note that this function must be reimplemented if the framebuffer is not memory-mapped.

The size parameter specifies the total size of the given buffer, while the length parameter specifies the number of pixels to draw. The buffer's position is given by (x, y). The provided alpha value is added to each pixel in the buffer when drawing.

See also: drawColorSpans()

Reimplemented in QDirectFBPaintEngine.

Definition at line 3504 of file qpaintengine_raster.cpp.

Referenced by drawBufferSpan().

 {
     Q_UNUSED(buffer);
     Q_UNUSED(bufsize);
     Q_UNUSED(x);
     Q_UNUSED(y);
     Q_UNUSED(length);
     Q_UNUSED(const_alpha);
     qFatal("QRasterPaintEngine::drawBufferSpan must be reimplemented on "
            "a non memory-mapped device");
 }

◆ drawCachedGlyphs()

bool QRasterPaintEngine::drawCachedGlyphs	(	int	numGlyphs,
		const glyph_t *	glyphs,
		const QFixedPoint *	positions,
		QFontEngine *	fontEngine
	)

private

Definition at line 2780 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
     const QFixed offs = QFixed::fromReal(aliasedCoordinateDelta);
 
 #if !defined(QT_NO_FREETYPE)
     if (fontEngine->type() == QFontEngine::Freetype) {
         QFontEngineFT *fe = static_cast<QFontEngineFT *>(fontEngine);
         const QFixed xOffs = fe->supportsSubPixelPositions() ? 0 : offs;
         QFontEngineFT::GlyphFormat neededFormat =
             painter()->device()->devType() == QInternal::Widget
             ? fe->defaultGlyphFormat()
             : QFontEngineFT::Format_A8;
 
         if (d_func()->mono_surface
             || fe->isBitmapFont() // alphaPenBlt can handle mono, too
             )
             neededFormat = QFontEngineFT::Format_Mono;
 
         if (neededFormat == QFontEngineFT::Format_None)
             neededFormat = QFontEngineFT::Format_A8;
 
         QFontEngineFT::QGlyphSet *gset = fe->defaultGlyphs();
         if (s->matrix.type() >= QTransform::TxScale) {
             if (s->matrix.isAffine())
                 gset = fe->loadTransformedGlyphSet(s->matrix);
             else
                 gset = 0;
         }
 
         if (!gset || gset->outline_drawing
             || !fe->loadGlyphs(gset, glyphs, numGlyphs, positions, neededFormat))
             return false;
 
         FT_Face lockedFace = 0;
 
         int depth;
         switch (neededFormat) {
         case QFontEngineFT::Format_Mono:
             depth = 1;
             break;
         case QFontEngineFT::Format_A8:
             depth = 8;
             break;
         case QFontEngineFT::Format_A32:
             depth = 32;
             break;
         default:
             Q_ASSERT(false);
             depth = 0;
         };
 
         for (int i = 0; i < numGlyphs; i++) {
             QFixed spp = fe->subPixelPositionForX(positions[i].x);
             QFontEngineFT::Glyph *glyph = gset->getGlyph(glyphs[i], spp);
 
             if (!glyph || glyph->format != neededFormat) {
                 if (!lockedFace)
                     lockedFace = fe->lockFace();
                 glyph = fe->loadGlyph(gset, glyphs[i], spp, neededFormat);
             }
 
             if (!glyph || !glyph->data)
                 continue;
 
             int pitch;
             switch (neededFormat) {
             case QFontEngineFT::Format_Mono:
                 pitch = ((glyph->width + 31) & ~31) >> 3;
                 break;
             case QFontEngineFT::Format_A8:
                 pitch = (glyph->width + 3) & ~3;
                 break;
             case QFontEngineFT::Format_A32:
                 pitch = glyph->width * 4;
                 break;
             default:
                 Q_ASSERT(false);
                 pitch = 0;
             };
 
             alphaPenBlt(glyph->data, pitch, depth,
                         qFloor(positions[i].x + xOffs) + glyph->x,
                         qFloor(positions[i].y + offs) - glyph->y,
                         glyph->width, glyph->height);
         }
         if (lockedFace)
             fe->unlockFace();
     } else
 #endif
     {
         QFontEngineGlyphCache::Type glyphType = fontEngine->glyphFormat >= 0
                 ? QFontEngineGlyphCache::Type(fontEngine->glyphFormat)
                 : d->glyphCacheType;
 
         QImageTextureGlyphCache *cache =
             static_cast<QImageTextureGlyphCache *>(fontEngine->glyphCache(0, glyphType, s->matrix));
         if (!cache) {
             cache = new QImageTextureGlyphCache(glyphType, s->matrix);
             fontEngine->setGlyphCache(0, cache);
         }
 
         cache->populate(fontEngine, numGlyphs, glyphs, positions);
         cache->fillInPendingGlyphs();
 
         const QImage &image = cache->image();
         int bpl = image.bytesPerLine();
 
         int depth = image.depth();
         int rightShift = 0;
         int leftShift = 0;
         if (depth == 32)
             leftShift = 2; // multiply by 4
         else if (depth == 1)
             rightShift = 3; // divide by 8
 
         int margin = cache->glyphMargin();
         const uchar *bits = image.bits();
         for (int i=0; i<numGlyphs; ++i) {
 
             QFixed subPixelPosition = cache->subPixelPositionForX(positions[i].x);
             QTextureGlyphCache::GlyphAndSubPixelPosition glyph(glyphs[i], subPixelPosition);
             const QTextureGlyphCache::Coord &c = cache->coords[glyph];
             if (c.isNull())
                 continue;
 
             int x = qFloor(positions[i].x) + c.baseLineX - margin;
             int y = qFloor(positions[i].y + offs) - c.baseLineY - margin;
 
             // printf("drawing [%d %d %d %d] baseline [%d %d], glyph: %d, to: %d %d, pos: %d %d\n",
             //        c.x, c.y,
             //        c.w, c.h,
             //        c.baseLineX, c.baseLineY,
             //        glyphs[i],
             //        x, y,
             //        positions[i].x.toInt(), positions[i].y.toInt());
 
             alphaPenBlt(bits + ((c.x << leftShift) >> rightShift) + c.y * bpl, bpl, depth, x, y, c.w, c.h);
         }
     }
     return true;
 }

◆ drawColorSpans()

void QRasterPaintEngine::drawColorSpans	(	const QSpan *	spans,
		int	count,
		uint	color
	)

virtual

Draws the given color spans with the specified color.

The count parameter specifies the number of spans.

The default implementation does nothing; reimplement this function to draw the given color spans with the specified color. Note that this function must be reimplemented if the framebuffer is not memory-mapped.

See also: drawBufferSpan()

Definition at line 3477 of file qpaintengine_raster.cpp.

 {
     Q_UNUSED(spans);
     Q_UNUSED(count);
     Q_UNUSED(color);
     qFatal("QRasterPaintEngine::drawColorSpans must be reimplemented on "
            "a non memory-mapped device");
 }

◆ drawEllipse()

void QRasterPaintEngine::drawEllipse ( const QRectF & rect )

virtual

Reimplemented Function

Reimplement this function to draw the largest ellipse that can be contained within rectangle rect.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3350 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::drawEllipse(), QDirectFBPaintEngine::drawEllipse(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensurePen();
     if (((qpen_style(s->lastPen) == Qt::SolidLine && s->flags.fast_pen)
            || (qpen_style(s->lastPen) == Qt::NoPen))
         && !s->flags.antialiased
         && qMax(rect.width(), rect.height()) < QT_RASTER_COORD_LIMIT
         && !rect.isEmpty()
         && s->matrix.type() <= QTransform::TxScale) // no shear
     {
         ensureBrush();
         const QRectF r = s->matrix.mapRect(rect);
         ProcessSpans penBlend = d->getPenFunc(r, &s->penData);
         ProcessSpans brushBlend = d->getBrushFunc(r, &s->brushData);
         const QRect brect = QRect(int(r.x()), int(r.y()),
                                   int_dim(r.x(), r.width()),
                                   int_dim(r.y(), r.height()));
         if (brect == r) {
             drawEllipse_midpoint_i(brect, d->deviceRect, penBlend, brushBlend,
                                    &s->penData, &s->brushData);
             return;
         }
     }
     QPaintEngineEx::drawEllipse(rect);
 }

◆ drawImage() [1/2]

void QRasterPaintEngine::drawImage	(	const QPointF &	p,
		const QImage &	img
	)

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 2164 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::drawImage(), QBlitterPaintEngine::drawImage(), QVolatileImagePaintEngine::drawPixmap(), QDirectFBPaintEngine::drawPixmap(), drawPixmap(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawImage(), p=" <<  p << " image=" << img.size() << "depth=" << img.depth();
 #endif
 
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     if (s->matrix.type() > QTransform::TxTranslate) {
         drawImage(QRectF(p.x(), p.y(), img.width(), img.height()),
                   img,
                   QRectF(0, 0, img.width(), img.height()));
     } else {
 
         const QClipData *clip = d->clip();
         QPointF pt(p.x() + s->matrix.dx(), p.y() + s->matrix.dy());
 
         if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
             SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
             if (func) {
                 if (!clip) {
                     d->drawImage(pt, img, func, d->deviceRect, s->intOpacity);
                     return;
                 } else if (clip->hasRectClip) {
                     d->drawImage(pt, img, func, clip->clipRect, s->intOpacity);
                     return;
                 }
             }
         }
 
 
 
         d->image_filler.clip = clip;
         d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, img.rect());
         if (!d->image_filler.blend)
             return;
         d->image_filler.dx = -pt.x();
         d->image_filler.dy = -pt.y();
         QRect rr = img.rect().translated(qRound(pt.x()), qRound(pt.y()));
 
         fillRect_normalized(rr, &d->image_filler, d);
     }
 
 }

◆ drawImage() [2/2]

void QRasterPaintEngine::drawImage	(	const QRectF &	r,
		const QImage &	pm,
		const QRectF &	sr,
		Qt::ImageConversionFlags	falgs = `Qt::AutoColor`
	)

virtual

Reimplemented Function

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 2253 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawImage(), r=" << r << " sr=" << sr << " image=" << img.size() << "depth=" << img.depth();
 #endif
 
     if (r.isEmpty())
         return;
 
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
     int sr_l = qFloor(sr.left());
     int sr_r = qCeil(sr.right()) - 1;
     int sr_t = qFloor(sr.top());
     int sr_b = qCeil(sr.bottom()) - 1;
 
     if (s->matrix.type() <= QTransform::TxScale && !s->flags.antialiased && sr_l == sr_r && sr_t == sr_b) {
         // as fillRect will apply the aliased coordinate delta we need to
         // subtract it here as we don't use it for image drawing
         QTransform old = s->matrix;
         s->matrix = s->matrix * QTransform::fromTranslate(-aliasedCoordinateDelta, -aliasedCoordinateDelta);
 
         // Do whatever fillRect() does, but without premultiplying the color if it's already premultiplied.
         QRgb color = img.pixel(sr_l, sr_t);
         switch (img.format()) {
         case QImage::Format_ARGB32_Premultiplied:
         case QImage::Format_ARGB8565_Premultiplied:
         case QImage::Format_ARGB6666_Premultiplied:
         case QImage::Format_ARGB8555_Premultiplied:
         case QImage::Format_ARGB4444_Premultiplied:
             // Combine premultiplied color with the opacity set on the painter.
             d->solid_color_filler.solid.color =
                 ((((color & 0x00ff00ff) * s->intOpacity) >> 8) & 0x00ff00ff)
                 | ((((color & 0xff00ff00) >> 8) * s->intOpacity) & 0xff00ff00);
             break;
         default:
             d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color, s->intOpacity));
             break;
         }
 
         if ((d->solid_color_filler.solid.color & 0xff000000) == 0
             && s->composition_mode == QPainter::CompositionMode_SourceOver) {
             return;
         }
 
         d->solid_color_filler.clip = d->clip();
         d->solid_color_filler.adjustSpanMethods();
         fillRect(r, &d->solid_color_filler);
 
         s->matrix = old;
         return;
     }
 
     bool stretch_sr = r.width() != sr.width() || r.height() != sr.height();
 
     const QClipData *clip = d->clip();
 
     if (s->matrix.type() > QTransform::TxTranslate
         && !stretch_sr
         && (!clip || clip->hasRectClip)
         && s->intOpacity == 256
         && (d->rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver
             || d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)
         && d->rasterBuffer->format == img.format()
         && (d->rasterBuffer->format == QImage::Format_RGB16
             || d->rasterBuffer->format == QImage::Format_RGB32
             || (d->rasterBuffer->format == QImage::Format_ARGB32_Premultiplied
                 && d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)))
     {
         RotationType rotationType = qRotationType(s->matrix);
 
         if (rotationType != NoRotation && qMemRotateFunctions[d->rasterBuffer->format][rotationType] && img.rect().contains(sr.toAlignedRect())) {
             QRectF transformedTargetRect = s->matrix.mapRect(r);
 
             if ((!(s->renderHints & QPainter::SmoothPixmapTransform) && !(s->renderHints & QPainter::Antialiasing))
                 || (isPixelAligned(transformedTargetRect) && isPixelAligned(sr)))
             {
                 QRect clippedTransformedTargetRect = transformedTargetRect.toRect().intersected(clip ? clip->clipRect : d->deviceRect);
                 if (clippedTransformedTargetRect.isNull())
                     return;
 
                 QRectF clippedTargetRect = s->matrix.inverted().mapRect(QRectF(clippedTransformedTargetRect));
 
                 QRect clippedSourceRect
                     = QRectF(sr.x() + clippedTargetRect.x() - r.x(), sr.y() + clippedTargetRect.y() - r.y(),
                             clippedTargetRect.width(), clippedTargetRect.height()).toRect();
 
                 uint dbpl = d->rasterBuffer->bytesPerLine();
                 uint sbpl = img.bytesPerLine();
 
                 uchar *dst = d->rasterBuffer->buffer();
                 uint bpp = img.depth() >> 3;
 
                 const uchar *srcBase = img.bits() + clippedSourceRect.y() * sbpl + clippedSourceRect.x() * bpp;
                 uchar *dstBase = dst + clippedTransformedTargetRect.y() * dbpl + clippedTransformedTargetRect.x() * bpp;
 
                 uint cw = clippedSourceRect.width();
                 uint ch = clippedSourceRect.height();
 
                 qMemRotateFunctions[d->rasterBuffer->format][rotationType](srcBase, cw, ch, sbpl, dstBase, dbpl);
 
                 return;
             }
         }
     }
 
     if (s->matrix.type() > QTransform::TxTranslate || stretch_sr) {
 
         QRectF targetBounds = s->matrix.mapRect(r);
         bool exceedsPrecision = targetBounds.width() > 0xffff
                                 || targetBounds.height() > 0xffff;
 
         if (!exceedsPrecision && d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
             if (s->matrix.type() > QTransform::TxScale) {
                 SrcOverTransformFunc func = qTransformFunctions[d->rasterBuffer->format][img.format()];
                 if (func && (!clip || clip->hasRectClip)) {
                     func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), img.bits(),
                          img.bytesPerLine(), r, sr, !clip ? d->deviceRect : clip->clipRect,
                          s->matrix, s->intOpacity);
                     return;
                 }
             } else {
                 SrcOverScaleFunc func = qScaleFunctions[d->rasterBuffer->format][img.format()];
                 if (func && (!clip || clip->hasRectClip)) {
                     func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(),
                          img.bits(), img.bytesPerLine(), img.height(),
                          qt_mapRect_non_normalizing(r, s->matrix), sr,
                          !clip ? d->deviceRect : clip->clipRect,
                          s->intOpacity);
                     return;
                 }
             }
         }
 
         QTransform copy = s->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());
 
         d->image_filler_xform.clip = clip;
         d->image_filler_xform.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
         if (!d->image_filler_xform.blend)
             return;
         d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
 
         if (!s->flags.antialiased && s->matrix.type() == QTransform::TxScale) {
             QPointF rr_tl = s->matrix.map(r.topLeft());
             QPointF rr_br = s->matrix.map(r.bottomRight());
 
             int x1 = qRound(rr_tl.x());
             int y1 = qRound(rr_tl.y());
             int x2 = qRound(rr_br.x());
             int y2 = qRound(rr_br.y());
 
             if (x1 > x2)
                 qSwap(x1, x2);
             if (y1 > y2)
                 qSwap(y1, y2);
 
             fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler_xform, d);
             return;
         }
 
 #ifdef QT_FAST_SPANS
         ensureState();
         if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
             d->initializeRasterizer(&d->image_filler_xform);
             d->rasterizer->setAntialiased(s->flags.antialiased);
 
             const QPointF offs = s->flags.antialiased ? QPointF() : QPointF(aliasedCoordinateDelta, aliasedCoordinateDelta);
 
             const QRectF &rect = r.normalized();
             const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f) - offs;
             const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f) - offs;
 
             if (s->flags.tx_noshear)
                 d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
             else
                 d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width())));
             return;
         }
 #endif
         const qreal offs = s->flags.antialiased ? qreal(0) : aliasedCoordinateDelta;
         QPainterPath path;
         path.addRect(r);
         QTransform m = s->matrix;
         s->matrix = QTransform(m.m11(), m.m12(), m.m13(),
                                m.m21(), m.m22(), m.m23(),
                                m.m31() - offs, m.m32() - offs, m.m33());
         fillPath(path, &d->image_filler_xform);
         s->matrix = m;
     } else {
         if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
             SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
             if (func) {
                 QPointF pt(r.x() + s->matrix.dx(), r.y() + s->matrix.dy());
                 if (!clip) {
                     d->drawImage(pt, img, func, d->deviceRect, s->intOpacity, sr.toRect());
                     return;
                 } else if (clip->hasRectClip) {
                     d->drawImage(pt, img, func, clip->clipRect, s->intOpacity, sr.toRect());
                     return;
                 }
             }
         }
 
         d->image_filler.clip = clip;
         d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
         if (!d->image_filler.blend)
             return;
         d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x();
         d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y();
 
         QRectF rr = r;
         rr.translate(s->matrix.dx(), s->matrix.dy());
 
         const int x1 = qRound(rr.x());
         const int y1 = qRound(rr.y());
         const int x2 = qRound(rr.right());
         const int y2 = qRound(rr.bottom());
 
         fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler, d);
     }
 }

◆ drawLines() [1/2]

void QRasterPaintEngine::drawLines	(	const QLine *	line,
		int	lineCount
	)

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3252 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::drawLines().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawLines(QLine*)" << lineCount;
 #endif
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensurePen();
     if (!s->penData.blend)
         return;
 
     if (s->flags.fast_pen) {
         QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
         for (int i=0; i<lineCount; ++i) {
             const QLine &l = lines[i];
             stroker.drawLine(l.p1(), l.p2());
         }
     } else {
         QPaintEngineEx::drawLines(lines, lineCount);
     }
 }

◆ drawLines() [2/2]

void QRasterPaintEngine::drawLines	(	const QLineF *	line,
		int	lineCount
	)

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3324 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawLines(QLineF *)" << lineCount;
 #endif
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensurePen();
     if (!s->penData.blend)
         return;
     if (s->flags.fast_pen) {
         QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
         for (int i=0; i<lineCount; ++i) {
             QLineF line = lines[i];
             stroker.drawLine(line.p1(), line.p2());
         }
     } else {
         QPaintEngineEx::drawLines(lines, lineCount);
     }
 }

◆ drawPixmap() [1/2]

void QRasterPaintEngine::drawPixmap	(	const QPointF &	pos,
		const QPixmap &	pixmap
	)

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 2045 of file qpaintengine_raster.cpp.

Referenced by QVolatileImagePaintEngine::drawPixmap(), QBlitterPaintEngine::drawPixmap(), QDirectFBPaintEngine::drawPixmap(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
     QPixmapData *pd = pixmap.pixmapData();
     if (pd->classId() == QPixmapData::RasterClass) {
         const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
             if (s->matrix.type() <= QTransform::TxTranslate) {
                 ensurePen();
                 drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
             } else {
                 drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
             }
         } else {
             QRasterPaintEngine::drawImage(pos, image);
         }
     } else {
         const QImage image = pixmap.toImage();
         if (pixmap.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
             if (s->matrix.type() <= QTransform::TxTranslate) {
                 ensurePen();
                 drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
             } else {
                 drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
             }
         } else {
             QRasterPaintEngine::drawImage(pos, image);
         }
     }
 }

◆ drawPixmap() [2/2]

void QRasterPaintEngine::drawPixmap	(	const QRectF &	r,
		const QPixmap &	pm,
		const QRectF &	sr
	)

virtual

Reimplemented Function

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 2086 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
     QPixmapData* pd = pixmap.pixmapData();
     if (pd->classId() == QPixmapData::RasterClass) {
         const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
             if (s->matrix.type() <= QTransform::TxTranslate
                 && r.size() == sr.size()
                 && r.size() == pixmap.size()) {
                 ensurePen();
                 drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
                 return;
             } else {
                 drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr);
             }
         } else {
             drawImage(r, image, sr);
         }
     } else {
         QRect clippedSource = sr.toAlignedRect().intersected(pixmap.rect());
         const QImage image = pd->toImage(clippedSource);
         QRectF translatedSource = sr.translated(-clippedSource.topLeft());
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
             if (s->matrix.type() <= QTransform::TxTranslate
                 && r.size() == sr.size()
                 && r.size() == pixmap.size()) {
                 ensurePen();
                 drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
                 return;
             } else {
                 drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), translatedSource);
             }
         } else {
             drawImage(r, image, translatedSource);
         }
     }
 }

◆ drawPoints() [1/2]

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

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3212 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::drawPoints(), QBlitterPaintEngine::drawPoints(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensurePen();
     if (!s->penData.blend)
         return;
 
     if (!s->flags.fast_pen) {
         QPaintEngineEx::drawPoints(points, pointCount);
         return;
     }
 
     QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
     stroker.drawPoints(points, pointCount);
 }

◆ drawPoints() [2/2]

void QRasterPaintEngine::drawPoints	(	const QPoint *	points,
		int	pointCount
	)

virtual

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Draws the first pointCount points in the buffer points.

The default implementation converts the first pointCount QPoints in points to QPointFs and calls the floating point version of drawPoints.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3231 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensurePen();
     if (!s->penData.blend)
         return;
 
     if (!s->flags.fast_pen) {
         QPaintEngineEx::drawPoints(points, pointCount);
         return;
     }
 
     QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
     stroker.drawPoints(points, pointCount);
 }

◆ drawPolygon() [1/2]

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

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1933 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::drawPolygon(), QDirectFBPaintEngine::drawPolygon(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug(" - QRasterPaintEngine::drawPolygon(F), pointCount=%d", pointCount);
     for (int i=0; i<pointCount; ++i)
         qDebug() << "   - " << points[i];
 #endif
     Q_ASSERT(pointCount >= 2);
 
     if (mode != PolylineMode && isRect((qreal *) points, pointCount)) {
         QRectF r(points[0], points[2]);
         drawRects(&r, 1);
         return;
     }
 
     ensurePen();
     if (mode != PolylineMode) {
         // Do the fill...
         ensureBrush();
         if (s->brushData.blend)
             fillPolygon(points, pointCount, mode);
     }
 
     // Do the outline...
     if (s->penData.blend) {
         QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
         if (s->flags.fast_pen) {
             QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
             stroker.drawPath(vp);
         } else {
             QPaintEngineEx::stroke(vp, s->lastPen);
         }
     }
 }

◆ drawPolygon() [2/2]

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

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1974 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug(" - QRasterPaintEngine::drawPolygon(I), pointCount=%d", pointCount);
     for (int i=0; i<pointCount; ++i)
         qDebug() << "   - " << points[i];
 #endif
     Q_ASSERT(pointCount >= 2);
     if (mode != PolylineMode && isRect((int *) points, pointCount)) {
         QRect r(points[0].x(),
                 points[0].y(),
                 points[2].x() - points[0].x(),
                 points[2].y() - points[0].y());
         drawRects(&r, 1);
         return;
     }
 
     ensurePen();
 
     // Do the fill
     if (mode != PolylineMode) {
         ensureBrush();
         if (s->brushData.blend) {
             // Compose polygon fill..,
             ensureOutlineMapper();
             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.
             ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,
                                                       &s->brushData);
             d->rasterize(d->outlineMapper->outline(), brushBlend, &s->brushData, d->rasterBuffer.data());
         }
     }
 
     // Do the outline...
     if (s->penData.blend) {
         int count = pointCount * 2;
         QVarLengthArray<qreal> fpoints(count);
     #ifdef Q_WS_MAC
         for (int i=0; i<count; i+=2) {
             fpoints[i] = ((int *) points)[i+1];
             fpoints[i+1] = ((int *) points)[i];
         }
     #else
         for (int i=0; i<count; ++i)
             fpoints[i] = ((int *) points)[i];
     #endif
         QVectorPath vp((qreal *) fpoints.data(), pointCount, 0, QVectorPath::polygonFlags(mode));
 
         if (s->flags.fast_pen) {
             QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
             stroker.drawPath(vp);
         } else {
             QPaintEngineEx::stroke(vp, s->lastPen);
         }
     }
 }

◆ drawRects() [1/2]

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

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1509 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::drawRects(), QBlitterPaintEngine::drawRects(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
 #endif
     Q_D(QRasterPaintEngine);
     ensureState();
     QRasterPaintEngineState *s = state();
 
     // Fill
     ensureBrush();
     if (s->brushData.blend) {
         if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxTranslate) {
             const QRect *r = rects;
             const QRect *lastRect = rects + rectCount;
 
             int offset_x = int(s->matrix.dx());
             int offset_y = int(s->matrix.dy());
             while (r < lastRect) {
                 QRect rect = r->normalized();
                 QRect rr = rect.translated(offset_x, offset_y);
                 fillRect_normalized(rr, &s->brushData, d);
                 ++r;
             }
         } else {
             QRectVectorPath path;
             for (int i=0; i<rectCount; ++i) {
                 path.set(rects[i]);
                 fill(path, s->brush);
             }
         }
     }
 
     ensurePen();
     if (s->penData.blend) {
         QRectVectorPath path;
         if (s->flags.fast_pen) {
             QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
             for (int i = 0; i < rectCount; ++i) {
                 path.set(rects[i]);
                 stroker.drawPath(path);
             }
         } else {
             for (int i = 0; i < rectCount; ++i) {
                 path.set(rects[i]);
                 stroke(path, s->pen);
             }
         }
     }
 }

◆ drawRects() [2/2]

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

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1563 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug(" - QRasterPaintEngine::drawRect(QRectF*), rectCount=%d", rectCount);
 #endif
 #ifdef QT_FAST_SPANS
     Q_D(QRasterPaintEngine);
     ensureState();
     QRasterPaintEngineState *s = state();
 
 
     if (s->flags.tx_noshear) {
         ensureBrush();
         if (s->brushData.blend) {
             d->initializeRasterizer(&s->brushData);
             for (int i = 0; i < rectCount; ++i) {
                 const QRectF &rect = rects[i].normalized();
                 if (rect.isEmpty())
                     continue;
                 const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
                 const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
                 d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
             }
         }
 
         ensurePen();
         if (s->penData.blend) {
             QRectVectorPath path;
             if (s->flags.fast_pen) {
                 QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
                 for (int i = 0; i < rectCount; ++i) {
                     path.set(rects[i]);
                     stroker.drawPath(path);
                 }
             } else {
                 for (int i = 0; i < rectCount; ++i) {
                     path.set(rects[i]);
                     QPaintEngineEx::stroke(path, s->lastPen);
                 }
             }
         }
 
         return;
     }
 #endif // QT_FAST_SPANS
     QPaintEngineEx::drawRects(rects, rectCount);
 }

◆ drawStaticTextItem()

void QRasterPaintEngine::drawStaticTextItem ( QStaticTextItem * textItem )

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3071 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::drawStaticTextItem(), QDirectFBPaintEngine::drawStaticTextItem(), and QBlitterPaintEngine::type().

 {
     ensurePen();
     ensureState();
 
     QFontEngine *fontEngine = textItem->fontEngine();
     if (!supportsTransformations(fontEngine)) {
         drawCachedGlyphs(textItem->numGlyphs, textItem->glyphs, textItem->glyphPositions,
                          fontEngine);
     } else {
         QPaintEngineEx::drawStaticTextItem(textItem);
     }
 }

◆ drawTextItem()

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

virtual

Reimplemented Function

Reimplemented from QPaintEngine.

Reimplemented in QDirectFBPaintEngine.

Definition at line 3088 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::drawTextItem(), QDirectFBPaintEngine::drawTextItem(), and QBlitterPaintEngine::type().

 {
     const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     Q_D(QRasterPaintEngine);
     fprintf(stderr," - QRasterPaintEngine::drawTextItem(), (%.2f,%.2f), string=%s ct=%d\n",
            p.x(), p.y(), QString::fromRawData(ti.chars, ti.num_chars).toLatin1().data(),
            d->glyphCacheType);
 #endif
 
     ensurePen();
     ensureState();
 
 #if defined (Q_WS_WIN) || defined(Q_WS_MAC) || (defined(Q_OS_MAC) && defined(Q_WS_QPA))
 
     if (!supportsTransformations(ti.fontEngine)) {
         QVarLengthArray<QFixedPoint> positions;
         QVarLengthArray<glyph_t> glyphs;
 
         QTransform matrix = s->matrix;
         matrix.translate(p.x(), p.y());
 
         ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
 
         drawCachedGlyphs(glyphs.size(), glyphs.constData(), positions.constData(), ti.fontEngine);
         return;
     }
 
 #elif defined (Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE) // Q_WS_WIN || Q_WS_MAC
     if (s->matrix.type() <= QTransform::TxTranslate
         || (s->matrix.type() == QTransform::TxScale
                 && (qFuzzyCompare(s->matrix.m11(), s->matrix.m22())))) {
         drawGlyphsS60(p, ti);
         return;
     }
 #else // Q_WS_WIN || Q_WS_MAC
 
     QFontEngine *fontEngine = ti.fontEngine;
 
 #if defined(Q_WS_QWS)
     if (fontEngine->type() == QFontEngine::Box) {
         fontEngine->draw(this, qFloor(p.x()), qFloor(p.y()), ti);
         return;
     }
 
     if (s->matrix.type() < QTransform::TxScale
         && (fontEngine->type() == QFontEngine::QPF1 || fontEngine->type() == QFontEngine::QPF2
             || (fontEngine->type() == QFontEngine::Proxy
                 && !(static_cast<QProxyFontEngine *>(fontEngine)->drawAsOutline()))
             )) {
         fontEngine->draw(this, qFloor(p.x() + aliasedCoordinateDelta), qFloor(p.y() + aliasedCoordinateDelta), ti);
         return;
     }
 #endif // Q_WS_QWS
 
 #ifdef Q_WS_QPA
     if (s->matrix.type() < QTransform::TxScale) {
 
         QVarLengthArray<QFixedPoint> positions;
         QVarLengthArray<glyph_t> glyphs;
         QTransform matrix = state()->transform();
 
         qreal _x = qFloor(p.x());
         qreal _y = qFloor(p.y());
         matrix.translate(_x, _y);
 
         fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
         if (glyphs.size() == 0)
             return;
 
         for(int i = 0; i < glyphs.size(); i++) {
             QImage img = fontEngine->alphaMapForGlyph(glyphs[i]);
             glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[i]);
             // ### hm, perhaps an QFixed offs = QFixed::fromReal(aliasedCoordinateDelta) is needed here?
             alphaPenBlt(img.bits(), img.bytesPerLine(), img.depth(),
                                          qRound(positions[i].x + metrics.x),
                                          qRound(positions[i].y + metrics.y),
                                          img.width(), img.height());
         }
         return;
     }
 #endif //Q_WS_QPA
 
 #if (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)) && !defined(QT_NO_FREETYPE)
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_QWS_QPF2)
     if (fontEngine->type() == QFontEngine::QPF2) {
         QFontEngine *renderingEngine = static_cast<QFontEngineQPF *>(fontEngine)->renderingEngine();
         if (renderingEngine)
             fontEngine = renderingEngine;
     }
 #endif
 
     if (fontEngine->type() != QFontEngine::Freetype) {
         QPaintEngineEx::drawTextItem(p, ti);
         return;
     }
 
     QFontEngineFT *fe = static_cast<QFontEngineFT *>(fontEngine);
 
     QTransform matrix = s->matrix;
     matrix.translate(p.x(), p.y());
 
     QVarLengthArray<QFixedPoint> positions;
     QVarLengthArray<glyph_t> glyphs;
     fe->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
     if (glyphs.size() == 0)
         return;
 
     if (!drawCachedGlyphs(glyphs.size(), glyphs.constData(), positions.constData(), fontEngine))
         QPaintEngine::drawTextItem(p, ti);
 
     return;
 #endif
 #endif
 
     QPaintEngineEx::drawTextItem(p, ti);
 }

◆ drawTiledPixmap()

void QRasterPaintEngine::drawTiledPixmap	(	const QRectF &	r,
		const QPixmap &	pm,
		const QPointF &	sr
	)

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 2483 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::drawTiledPixmap(), QBlitterPaintEngine::drawTiledPixmap(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawTiledPixmap(), r=" << r << "pixmap=" << pixmap.size();
 #endif
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     QImage image;
 
     QPixmapData *pd = pixmap.pixmapData();
     if (pd->classId() == QPixmapData::RasterClass) {
         image = static_cast<QRasterPixmapData *>(pd)->image;
     } else {
         image = pixmap.toImage();
     }
 
     if (image.depth() == 1)
         image = d->rasterBuffer->colorizeBitmap(image, s->pen.color());
 
     if (s->matrix.type() > QTransform::TxTranslate) {
         QTransform copy = s->matrix;
         copy.translate(r.x(), r.y());
         copy.translate(-sr.x(), -sr.y());
         d->image_filler_xform.clip = d->clip();
         d->image_filler_xform.initTexture(&image, s->intOpacity, QTextureData::Tiled);
         if (!d->image_filler_xform.blend)
             return;
         d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
 
 #ifdef QT_FAST_SPANS
         ensureState();
         if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
             d->initializeRasterizer(&d->image_filler_xform);
             d->rasterizer->setAntialiased(s->flags.antialiased);
 
             const QRectF &rect = r.normalized();
             const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
             const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
             if (s->flags.tx_noshear)
                 d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
             else
                 d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width())));
             return;
         }
 #endif
         QPainterPath path;
         path.addRect(r);
         fillPath(path, &d->image_filler_xform);
     } else {
         d->image_filler.clip = d->clip();
 
         d->image_filler.initTexture(&image, s->intOpacity, QTextureData::Tiled);
         if (!d->image_filler.blend)
             return;
         d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x();
         d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y();
 
         QRectF rr = r;
         rr.translate(s->matrix.dx(), s->matrix.dy());
         fillRect_normalized(rr.toRect().normalized(), &d->image_filler, d);
     }
 }

◆ end()

bool QRasterPaintEngine::end ( )

virtual

Reimplemented Function

Implements QPaintEngine.

Reimplemented in QDirectFBPaintEngine.

Definition at line 522 of file qpaintengine_raster.cpp.

Referenced by QVolatileImagePaintEngine::end(), QBlitterPaintEngine::end(), QDirectFBPaintEngine::end(), QOnScreenRasterPaintEngine::end(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     Q_D(QRasterPaintEngine);
     qDebug() << "QRasterPaintEngine::end devRect:" << d->deviceRect;
     if (d->baseClip) {
         dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);
     }
 #endif
 
     return true;
 }

◆ ensureBrush() [1/2]

void QRasterPaintEngine::ensureBrush ( const QBrush & brush )

inlineprivate

Definition at line 272 of file qpaintengine_raster_p.h.

                                                  {
         if (!qbrush_fast_equals(state()->lastBrush, brush) || (brush.style() != Qt::NoBrush && state()->fillFlags))
             updateBrush(brush);
     }

◆ ensureBrush() [2/2]

void QRasterPaintEngine::ensureBrush ( )

inlineprivate

Definition at line 276 of file qpaintengine_raster_p.h.

Referenced by ensureBrush().

276 { ensureBrush(state()->brush); }

QRasterPaintEngine::state

QRasterPaintEngineState * state()

Definition: qpaintengine_raster_p.h:157

QRasterPaintEngine::ensureBrush

void ensureBrush()

Definition: qpaintengine_raster_p.h:276

◆ ensureOutlineMapper()

void QRasterPaintEngine::ensureOutlineMapper ( )

inlineprivate

Definition at line 552 of file qpaintengine_raster_p.h.

Referenced by begin(), and updateMatrix().

                                                     {
     if (d_func()->outlinemapper_xform_dirty)
         updateOutlineMapper();
 }

◆ ensurePen() [1/2]

void QRasterPaintEngine::ensurePen ( const QPen & pen )

inlineprivate

Definition at line 278 of file qpaintengine_raster_p.h.

                                            {
         if (!qpen_fast_equals(state()->lastPen, pen) || (pen.style() != Qt::NoPen && state()->strokeFlags))
             updatePen(pen);
     }

◆ ensurePen() [2/2]

void QRasterPaintEngine::ensurePen ( )

inlineprivate

Definition at line 282 of file qpaintengine_raster_p.h.

Referenced by ensurePen().

282 { ensurePen(state()->pen); }

QRasterPaintEngine::state

QRasterPaintEngineState * state()

Definition: qpaintengine_raster_p.h:157

QRasterPaintEngine::ensurePen

void ensurePen()

Definition: qpaintengine_raster_p.h:282

◆ ensureState()

void QRasterPaintEngine::ensureState ( )

inlineprivate

Definition at line 288 of file qpaintengine_raster_p.h.

                               {
         if (state()->dirty)
             updateState();
     }

◆ fill()

void QRasterPaintEngine::fill	(	const QVectorPath &	path,
		const QBrush &	brush
	)

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1699 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::fill(), QDirectFBPaintEngine::fill(), and QBlitterPaintEngine::type().

 {
     if (path.isEmpty())
         return;
 #ifdef QT_DEBUG_DRAW
     QRectF rf = path.controlPointRect();
     qDebug() << "QRasterPaintEngine::fill(): "
              << "size=" << path.elementCount()
              << ", hints=" << hex << path.hints()
              << rf << brush;
 #endif
 
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensureBrush(brush);
     if (!s->brushData.blend)
         return;
 
     if (path.shape() == QVectorPath::RectangleHint) {
         if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxScale) {
             const qreal *p = path.points();
             QPointF tl = QPointF(p[0], p[1]) * s->matrix;
             QPointF br = QPointF(p[4], p[5]) * s->matrix;
             fillRect_normalized(toNormalizedFillRect(QRectF(tl, br)), &s->brushData, d);
             return;
         }
         ensureState();
         if (s->flags.tx_noshear) {
             d->initializeRasterizer(&s->brushData);
             // ### Is normalizing really necessary here?
             const qreal *p = path.points();
             QRectF r = QRectF(p[0], p[1], p[2] - p[0], p[7] - p[1]).normalized();
             if (!r.isEmpty()) {
                 const QPointF a = s->matrix.map((r.topLeft() + r.bottomLeft()) * 0.5f);
                 const QPointF b = s->matrix.map((r.topRight() + r.bottomRight()) * 0.5f);
                 d->rasterizer->rasterizeLine(a, b, r.height() / r.width());
             }
             return;
         }
     }
 
     // ### Optimize for non transformed ellipses and rectangles...
     QRectF cpRect = path.controlPointRect();
     const QRect deviceRect = s->matrix.mapRect(cpRect).toRect();
     ProcessSpans blend = d->getBrushFunc(deviceRect, &s->brushData);
 
         // ### Falcon
 //         const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
 //                               || deviceRect.right() > QT_RASTER_COORD_LIMIT
 //                               || deviceRect.top() < -QT_RASTER_COORD_LIMIT
 //                               || deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
 
         // ### Falonc: implement....
 //         if (!s->flags.antialiased && !do_clip) {
 //             d->initializeRasterizer(&s->brushData);
 //             d->rasterizer->rasterize(path * d->matrix, path.fillRule());
 //             return;
 //         }
 
     ensureOutlineMapper();
     d->rasterize(d->outlineMapper->convertPath(path), blend, &s->brushData, d->rasterBuffer.data());
 }

◆ fillPath()

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

Warning: This function is not part of the public interface.

Definition at line 1404 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::fillPath(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << " --- fillPath, bounds=" << path.boundingRect();
 #endif
 
     if (!fillData->blend)
         return;
 
     Q_D(QRasterPaintEngine);
 
     const QRectF controlPointRect = path.controlPointRect();
 
     QRasterPaintEngineState *s = state();
     const QRect deviceRect = s->matrix.mapRect(controlPointRect).toRect();
     ProcessSpans blend = d->getBrushFunc(deviceRect, fillData);
     const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
                           || deviceRect.right() > QT_RASTER_COORD_LIMIT
                           || deviceRect.top() < -QT_RASTER_COORD_LIMIT
                           || deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
 
     if (!s->flags.antialiased && !do_clip) {
         d->initializeRasterizer(fillData);
         d->rasterizer->rasterize(path * s->matrix, path.fillRule());
         return;
     }
 
     ensureOutlineMapper();
     d->rasterize(d->outlineMapper->convertPath(path), blend, fillData, d->rasterBuffer.data());
 }

◆ fillPolygon()

void QRasterPaintEngine::fillPolygon	(	const QPointF *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)

Warning: This function is not part of the public interface.

Definition at line 1899 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::fillPolygon(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     const int maxPoints = 0xffff;
 
     // max amount of points that raster engine can reliably handle
     if (pointCount > maxPoints) {
         QVector<QPointF> upper, lower;
 
         if (splitPolygon(points, pointCount, &upper, &lower)) {
             fillPolygon(upper.constData(), upper.size(), mode);
             fillPolygon(lower.constData(), lower.size(), mode);
         } else
             qWarning("Polygon too complex for filling.");
 
         return;
     }
 
     // Compose polygon fill..,
     QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
     ensureOutlineMapper();
     QT_FT_Outline *outline = d->outlineMapper->convertPath(vp);
 
     // scanconvert.
     ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,
                                               &s->brushData);
     d->rasterize(outline, brushBlend, &s->brushData, d->rasterBuffer.data());
 }

◆ fillRect() [1/3]

void QRasterPaintEngine::fillRect	(	const QRectF &	rect,
		const QBrush &	brush
	)

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1804 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::fillRect(), QDirectFBPaintEngine::fillRect(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::fillRecct(): " << r << brush;
 #endif
     QRasterPaintEngineState *s = state();
 
     ensureBrush(brush);
     if (!s->brushData.blend)
         return;
 
     fillRect(r, &s->brushData);
 }

◆ fillRect() [2/3]

void QRasterPaintEngine::fillRect	(	const QRectF &	rect,
		const QColor &	color
	)

virtual

Reimplemented Function

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1821 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::fillRect(): " << r << color;
 #endif
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color.rgba(), s->intOpacity));
     if ((d->solid_color_filler.solid.color & 0xff000000) == 0
         && s->composition_mode == QPainter::CompositionMode_SourceOver) {
         return;
     }
     d->solid_color_filler.clip = d->clip();
     d->solid_color_filler.adjustSpanMethods();
     fillRect(r, &d->solid_color_filler);
 }

◆ fillRect() [3/3]

void QRasterPaintEngine::fillRect	(	const QRectF &	rect,
		QSpanData *	data
	)

private

Definition at line 1763 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     if (!s->flags.antialiased) {
         uint txop = s->matrix.type();
         if (txop == QTransform::TxNone) {
             fillRect_normalized(toNormalizedFillRect(r), data, d);
             return;
         } else if (txop == QTransform::TxTranslate) {
             const QRect rr = toNormalizedFillRect(r.translated(s->matrix.dx(), s->matrix.dy()));
             fillRect_normalized(rr, data, d);
             return;
         } else if (txop == QTransform::TxScale) {
             const QRect rr = toNormalizedFillRect(s->matrix.mapRect(r));
             fillRect_normalized(rr, data, d);
             return;
         }
     }
     ensureState();
     if (s->flags.tx_noshear) {
         d->initializeRasterizer(data);
         QRectF nr = r.normalized();
         if (!nr.isEmpty()) {
             const QPointF a = s->matrix.map((nr.topLeft() + nr.bottomLeft()) * 0.5f);
             const QPointF b = s->matrix.map((nr.topRight() + nr.bottomRight()) * 0.5f);
             d->rasterizer->rasterizeLine(a, b, nr.height() / nr.width());
         }
         return;
     }
 
     QPainterPath path;
     path.addRect(r);
     ensureOutlineMapper();
     fillPath(path, data);
 }

◆ getCGContext()

CGContextRef QRasterPaintEngine::getCGContext ( ) const

Warning: This function is not part of the public interface.

Definition at line 3392 of file qpaintengine_raster.cpp.

 {
     Q_D(const QRasterPaintEngine);
     return d->cgContext;
 }

◆ getDC()

HDC QRasterPaintEngine::getDC ( ) const

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngine.

Definition at line 3411 of file qpaintengine_raster.cpp.

 {
     Q_D(const QRasterPaintEngine);
     return d->hdc;
 }

◆ init()

void QRasterPaintEngine::init ( )

private

Definition at line 337 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine().

 {
     Q_D(QRasterPaintEngine);
 
 
 #ifdef Q_WS_WIN
     d->hdc = 0;
 #endif
 
     // The antialiasing raster.
     d->grayRaster.reset(new QT_FT_Raster);
     Q_CHECK_PTR(d->grayRaster.data());
     if (qt_ft_grays_raster.raster_new(d->grayRaster.data()))
         QT_THROW(std::bad_alloc()); // an error creating the raster is caused by a bad malloc
 
 
     d->rasterizer.reset(new QRasterizer);
     d->rasterBuffer.reset(new QRasterBuffer());
     d->outlineMapper.reset(new QOutlineMapper);
     d->outlinemapper_xform_dirty = 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->baseClip.reset(new QClipData(d->device->height()));
     d->baseClip->setClipRect(QRect(0, 0, d->device->width(), d->device->height()));
 
     d->image_filler.init(d->rasterBuffer.data(), this);
     d->image_filler.type = QSpanData::Texture;
 
     d->image_filler_xform.init(d->rasterBuffer.data(), this);
     d->image_filler_xform.type = QSpanData::Texture;
 
     d->solid_color_filler.init(d->rasterBuffer.data(), this);
     d->solid_color_filler.type = QSpanData::Solid;
 
     d->deviceDepth = d->device->depth();
 
     d->mono_surface = false;
     gccaps &= ~PorterDuff;
 
     QImage::Format format = QImage::Format_Invalid;
 
     switch (d->device->devType()) {
     case QInternal::Pixmap:
         qWarning("QRasterPaintEngine: unsupported for pixmaps...");
         break;
     case QInternal::Image:
         format = d->rasterBuffer->prepare(static_cast<QImage *>(d->device));
         break;
 #ifdef Q_WS_QWS
     case QInternal::CustomRaster:
         d->rasterBuffer->prepare(static_cast<QCustomRasterPaintDevice*>(d->device));
         break;
 #endif
     default:
         qWarning("QRasterPaintEngine: unsupported target device %d\n", d->device->devType());
         d->device = 0;
         return;
     }
 
     switch (format) {
     case QImage::Format_MonoLSB:
     case QImage::Format_Mono:
         d->mono_surface = true;
         break;
     case QImage::Format_ARGB8565_Premultiplied:
     case QImage::Format_ARGB8555_Premultiplied:
     case QImage::Format_ARGB6666_Premultiplied:
     case QImage::Format_ARGB4444_Premultiplied:
     case QImage::Format_ARGB32_Premultiplied:
     case QImage::Format_ARGB32:
         gccaps |= PorterDuff;
         break;
     case QImage::Format_RGB32:
     case QImage::Format_RGB444:
     case QImage::Format_RGB555:
     case QImage::Format_RGB666:
     case QImage::Format_RGB888:
     case QImage::Format_RGB16:
         break;
     default:
         break;
     }
 }

◆ opacityChanged()

void QRasterPaintEngine::opacityChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 884 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::opacityChanged(), QDirectFBPaintEngine::opacityChanged(), and QBlitterPaintEngine::type().

 {
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::opacityChanged()" << s->opacity;
 #endif
 
     s->fillFlags |= DirtyOpacity;
     s->strokeFlags |= DirtyOpacity;
     s->pixmapFlags |= DirtyOpacity;
     s->dirty |= DirtyOpacity;
     s->intOpacity = (int) (s->opacity * 256);
 }

◆ penChanged()

void QRasterPaintEngine::penChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 722 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::penChanged(), QDirectFBPaintEngine::penChanged(), and QBlitterPaintEngine::type().

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::penChanged():" << state()->pen;
 #endif
     QRasterPaintEngineState *s = state();
     s->strokeFlags |= DirtyPen;
     s->dirty |= DirtyPen;
 }

◆ releaseBuffer()

void QRasterPaintEngine::releaseBuffer ( )

Warning: This function is not part of the public interface.

Definition at line 538 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     d->rasterBuffer.reset(new QRasterBuffer);
 }

◆ releaseDC()

void QRasterPaintEngine::releaseDC ( HDC hdc ) const

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngine.

Definition at line 3420 of file qpaintengine_raster.cpp.

3421 {

3422 }

◆ renderHintsChanged()

void QRasterPaintEngine::renderHintsChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 923 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::renderHintsChanged(), QDirectFBPaintEngine::renderHintsChanged(), and QBlitterPaintEngine::type().

 {
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::renderHintsChanged()" << hex << s->renderHints;
 #endif
 
     bool was_aa = s->flags.antialiased;
     bool was_bilinear = s->flags.bilinear;
 
     s->flags.antialiased = bool(s->renderHints & QPainter::Antialiasing);
     s->flags.bilinear = bool(s->renderHints & QPainter::SmoothPixmapTransform);
 
     if (was_aa != s->flags.antialiased)
         s->strokeFlags |= DirtyHints;
 
     if (was_bilinear != s->flags.bilinear) {
         s->strokeFlags |= DirtyPen;
         s->fillFlags |= DirtyBrush;
     }
 
     Q_D(QRasterPaintEngine);
     d->recalculateFastImages();
 }

◆ saveBuffer()

void QRasterPaintEngine::saveBuffer ( const QString & s ) const

Warning: This function is not part of the public interface.

Definition at line 557 of file qpaintengine_raster.cpp.

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

◆ setCGContext()

void QRasterPaintEngine::setCGContext ( CGContextRef ctx )

Warning: This function is not part of the public interface.

Definition at line 3383 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     d->cgContext = ctx;
 }

◆ setClipRectInDeviceCoords()

bool QRasterPaintEngine::setClipRectInDeviceCoords	(	const QRect &	r,
		Qt::ClipOperation	op
	)

private

Definition at line 1295 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     QRect clipRect = r & d->deviceRect;
     QRasterPaintEngineState *s = state();
 
     if (op == Qt::ReplaceClip || s->clip == 0) {
 
         // No current clip, hence we intersect with sysclip and be
         // done with it...
         QRegion clipRegion = systemClip();
         QClipData *clip = new QClipData(d->rasterBuffer->height());
 
         if (clipRegion.isEmpty())
             clip->setClipRect(clipRect);
         else
             clip->setClipRegion(clipRegion & clipRect);
 
         if (s->flags.has_clip_ownership)
             delete s->clip;
 
         s->clip = clip;
         s->clip->enabled = true;
         s->flags.has_clip_ownership = true;
 
     } else if (op == Qt::IntersectClip){ // intersect clip with current clip
         QClipData *base = s->clip;
 
         Q_ASSERT(base);
         if (base->hasRectClip || base->hasRegionClip) {
             if (!s->flags.has_clip_ownership) {
                 s->clip = new QClipData(d->rasterBuffer->height());
                 s->flags.has_clip_ownership = true;
             }
             if (base->hasRectClip)
                 s->clip->setClipRect(base->clipRect & clipRect);
             else
                 s->clip->setClipRegion(base->clipRegion & clipRect);
             s->clip->enabled = true;
         } else {
             return false;
         }
     } else {
         return false;
     }
 
     qrasterpaintengine_dirty_clip(d, s);
     return true;
 }

◆ setDC()

void QRasterPaintEngine::setDC ( HDC hdc )

Warning: This function is not part of the public interface.

Definition at line 3403 of file qpaintengine_raster.cpp.

                                       {
     Q_D(QRasterPaintEngine);
     d->hdc = hdc;
 }

◆ setState()

void QRasterPaintEngine::setState ( QPainterState * s )

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 702 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::setState(), QDirectFBPaintEngine::setState(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QPaintEngineEx::setState(s);
     d->rasterBuffer->compositionMode = s->composition_mode;
 }

◆ size()

QSize QRasterPaintEngine::size ( ) const

Warning: This function is not part of the public interface.

Definition at line 547 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::drawBufferSpan().

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

◆ state() [1/2]

QRasterPaintEngineState * QRasterPaintEngine::state ( )

inline

Warning: This function is not part of the public interface.

Definition at line 157 of file qpaintengine_raster_p.h.

                                             {
         return static_cast<QRasterPaintEngineState *>(QPaintEngineEx::state());
     }

◆ state() [2/2]

const QRasterPaintEngineState * QRasterPaintEngine::state ( ) const

inline

Warning: This function is not part of the public interface.

Definition at line 160 of file qpaintengine_raster_p.h.

                                                         {
         return static_cast<const QRasterPaintEngineState *>(QPaintEngineEx::state());
     }

◆ stroke()

void QRasterPaintEngine::stroke	(	const QVectorPath &	path,
		const QPen &	pen
	)

virtual

Warning: This function is not part of the public interface.

Reimplemented from QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 1615 of file qpaintengine_raster.cpp.

Referenced by QDirectFBPaintEngine::stroke(), QBlitterPaintEngine::stroke(), and QBlitterPaintEngine::type().

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 
     ensurePen(pen);
     if (!s->penData.blend)
         return;
 
     if (s->flags.fast_pen) {
         QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);
         stroker.drawPath(path);
     } else if (s->flags.non_complex_pen && path.shape() == QVectorPath::LinesHint) {
         qreal width = s->lastPen.isCosmetic()
                       ? (qpen_widthf(s->lastPen) == 0 ? 1 : qpen_widthf(s->lastPen))
                       : qpen_widthf(s->lastPen) * s->txscale;
         int dashIndex = 0;
         qreal dashOffset = s->lastPen.dashOffset();
         bool inDash = true;
         qreal patternLength = 0;
         const QVector<qreal> pattern = s->lastPen.dashPattern();
         for (int i = 0; i < pattern.size(); ++i)
             patternLength += pattern.at(i);
 
         if (patternLength > 0) {
             int n = qFloor(dashOffset / patternLength);
             dashOffset -= n * patternLength;
             while (dashOffset >= pattern.at(dashIndex)) {
                 dashOffset -= pattern.at(dashIndex);
                 if (++dashIndex >= pattern.size())
                     dashIndex = 0;
                 inDash = !inDash;
             }
         }
 
         Q_D(QRasterPaintEngine);
         d->initializeRasterizer(&s->penData);
         int lineCount = path.elementCount() / 2;
         const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());
 
         for (int i = 0; i < lineCount; ++i) {
             if (lines[i].p1() == lines[i].p2()) {
                 if (s->lastPen.capStyle() != Qt::FlatCap) {
                     QPointF p = lines[i].p1();
                     QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*qreal(0.5), p.y()),
                                                        QPointF(p.x() + width*qreal(0.5), p.y())));
                     d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);
                 }
                 continue;
             }
 
             const QLineF line = s->matrix.map(lines[i]);
             if (qpen_style(s->lastPen) == Qt::SolidLine) {
                 d->rasterizer->rasterizeLine(line.p1(), line.p2(),
                                             width / line.length(),
                                             s->lastPen.capStyle() == Qt::SquareCap);
             } else {
                 d->rasterizeLine_dashed(line, width,
                                         &dashIndex, &dashOffset, &inDash);
             }
         }
     }
     else
         QPaintEngineEx::stroke(path, pen);
 }

◆ supportsTransformations() [1/2]

bool QRasterPaintEngine::supportsTransformations ( const QFontEngine * fontEngine ) const

Definition at line 3426 of file qpaintengine_raster.cpp.

 {
     const QTransform &m = state()->matrix;
 #if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
     QFontEngine::Type fontEngineType = fontEngine->type();
     if ((fontEngineType == QFontEngine::Win && !((QFontEngineWin *) fontEngine)->ttf && m.type() > QTransform::TxTranslate)
         || (m.type() <= QTransform::TxTranslate
             && (fontEngineType == QFontEngine::TestFontEngine
                 || fontEngineType == QFontEngine::Box))) {
             return true;
     }
 #endif
     return supportsTransformations(fontEngine->fontDef.pixelSize, m);
 }

◆ supportsTransformations() [2/2]

bool QRasterPaintEngine::supportsTransformations	(	qreal	pixelSize,
		const QTransform &	m
	)		const

virtual

Reimplemented from QPaintEngineEx.

Definition at line 3441 of file qpaintengine_raster.cpp.

 {
 #if defined(Q_WS_MAC) || (defined(Q_OS_MAC) && defined(Q_WS_QPA))
     // Mac font engines don't support scaling and rotation
     if (m.type() > QTransform::TxTranslate)
 #else
     if (m.type() >= QTransform::TxProject)
 #endif
         return true;
 
     if (pixelSize * pixelSize * qAbs(m.determinant()) >= 64 * 64)
         return true;
 
     return false;
 }

◆ transformChanged()

void QRasterPaintEngine::transformChanged ( )

virtual

Warning: This function is not part of the public interface.

Implements QPaintEngineEx.

Reimplemented in QDirectFBPaintEngine.

Definition at line 952 of file qpaintengine_raster.cpp.

Referenced by QBlitterPaintEngine::transformChanged(), QDirectFBPaintEngine::transformChanged(), and QBlitterPaintEngine::type().

 {
     QRasterPaintEngineState *s = state();
 
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::transformChanged()" << s->matrix;
 #endif
 
     s->fillFlags |= DirtyTransform;
     s->strokeFlags |= DirtyTransform;
 
     s->dirty |= DirtyTransform;
 
     Q_D(QRasterPaintEngine);
     d->recalculateFastImages();
 }

◆ type()

Type QRasterPaintEngine::type ( ) const

inlinevirtual

Reimplemented Function

Implements QPaintEngine.

Definition at line 240 of file qpaintengine_raster_p.h.

240 { return Raster; }

QPaintEngine::Raster

Definition: qpaintengine.h:210

◆ updateBrush()

void QRasterPaintEngine::updateBrush ( const QBrush & brush )

Warning: This function is not part of the public interface.

Definition at line 838 of file qpaintengine_raster.cpp.

 {
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::updateBrush()" << brush;
 #endif
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
     // must set clip prior to setup, as setup uses it...
     s->brushData.clip = d->clip();
     s->brushData.setup(brush, s->intOpacity, s->composition_mode);
     if (s->fillFlags & DirtyTransform
         || brush.transform().type() >= QTransform::TxNone)
         d_func()->updateMatrixData(&s->brushData, brush, d->brushMatrix());
     s->lastBrush = brush;
     s->fillFlags = 0;
 }

◆ updateMatrix()

void QRasterPaintEngine::updateMatrix ( const QTransform & matrix )

Warning: This function is not part of the public interface.

Definition at line 567 of file qpaintengine_raster.cpp.

 {
     QRasterPaintEngineState *s = state();
     // FALCON: get rid of this line, see drawImage call below.
     s->matrix = matrix;
     QTransform::TransformationType txop = s->matrix.type();
 
     switch (txop) {
 
     case QTransform::TxNone:
         s->flags.int_xform = true;
         break;
 
     case QTransform::TxTranslate:
         s->flags.int_xform = qreal(int(s->matrix.dx())) == s->matrix.dx()
                             && qreal(int(s->matrix.dy())) == s->matrix.dy();
         break;
 
     case QTransform::TxScale:
         s->flags.int_xform = qreal(int(s->matrix.dx())) == s->matrix.dx()
                             && qreal(int(s->matrix.dy())) == s->matrix.dy()
                             && qreal(int(s->matrix.m11())) == s->matrix.m11()
                             && qreal(int(s->matrix.m22())) == s->matrix.m22();
         break;
 
     default: // shear / perspective...
         s->flags.int_xform = false;
         break;
     }
 
     s->flags.tx_noshear = qt_scaleForTransform(s->matrix, &s->txscale);
 
     ensureOutlineMapper();
 
 #ifdef Q_WS_WIN
     Q_D(QRasterPaintEngine);
     d->isPlain45DegreeRotation = false;
     if (txop >= QTransform::TxRotate) {
         d->isPlain45DegreeRotation =
             (qFuzzyIsNull(matrix.m11())
              && qFuzzyIsNull(matrix.m12() - qreal(1))
              && qFuzzyIsNull(matrix.m21() + qreal(1))
              && qFuzzyIsNull(matrix.m22())
                 )
             ||
             (qFuzzyIsNull(matrix.m11() + qreal(1))
              && qFuzzyIsNull(matrix.m12())
              && qFuzzyIsNull(matrix.m21())
              && qFuzzyIsNull(matrix.m22() + qreal(1))
                 )
             ||
             (qFuzzyIsNull(matrix.m11())
              && qFuzzyIsNull(matrix.m12() + qreal(1))
              && qFuzzyIsNull(matrix.m21() - qreal(1))
              && qFuzzyIsNull(matrix.m22())
                 )
             ;
     }
 #endif
 
 }

◆ updateOutlineMapper()

void QRasterPaintEngine::updateOutlineMapper ( )

private

Definition at line 855 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     d->outlineMapper->setMatrix(state()->matrix);
 }

◆ updatePen()

void QRasterPaintEngine::updatePen ( const QPen & pen )

Warning: This function is not part of the public interface.

Definition at line 735 of file qpaintengine_raster.cpp.

 {
     Q_D(QRasterPaintEngine);
     QRasterPaintEngineState *s = state();
 #ifdef QT_DEBUG_DRAW
     qDebug() << "QRasterPaintEngine::updatePen():" << s->pen;
 #endif
 
     Qt::PenStyle pen_style = qpen_style(pen);
 
     s->lastPen = pen;
     s->strokeFlags = 0;
 
     s->penData.clip = d->clip();
     s->penData.setup(pen_style == Qt::NoPen ? QBrush() : pen.brush(), s->intOpacity, s->composition_mode);
 
     if (s->strokeFlags & QRasterPaintEngine::DirtyTransform
         || pen.brush().transform().type() >= QTransform::TxNone) {
         d->updateMatrixData(&s->penData, pen.brush(), s->matrix);
     }
 
     // Slightly ugly handling of an uncommon case... We need to change
     // the pen because it is reused in draw_midpoint to decide dashed
     // or non-dashed.
     if (pen_style == Qt::CustomDashLine && pen.dashPattern().size() == 0) {
         pen_style = Qt::SolidLine;
         s->lastPen.setStyle(Qt::SolidLine);
     }
 
     d->basicStroker.setJoinStyle(qpen_joinStyle(pen));
     d->basicStroker.setCapStyle(qpen_capStyle(pen));
     d->basicStroker.setMiterLimit(pen.miterLimit());
 
     qreal penWidth = qpen_widthf(pen);
     if (penWidth == 0)
         d->basicStroker.setStrokeWidth(1);
     else
         d->basicStroker.setStrokeWidth(penWidth);
 
     if(pen_style == Qt::SolidLine) {
         s->stroker = &d->basicStroker;
     } else if (pen_style != Qt::NoPen) {
         if (!d->dashStroker)
             d->dashStroker.reset(new QDashStroker(&d->basicStroker));
         if (pen.isCosmetic()) {
             d->dashStroker->setClipRect(d->deviceRect);
         } else {
             // ### I've seen this inverted devrect multiple places now...
             QRectF clipRect = s->matrix.inverted().mapRect(QRectF(d->deviceRect));
             d->dashStroker->setClipRect(clipRect);
         }
         d->dashStroker->setDashPattern(pen.dashPattern());
         d->dashStroker->setDashOffset(pen.dashOffset());
         s->stroker = d->dashStroker.data();
     } else {
         s->stroker = 0;
     }
 
     ensureState(); // needed because of tx_noshear...
     s->flags.fast_pen = pen_style > Qt::NoPen
             && s->penData.blend
             && ((pen.isCosmetic() && penWidth <= 1)
                 || (!pen.isCosmetic() && s->flags.tx_noshear && penWidth * s->txscale <= 1));
 
     s->flags.non_complex_pen = qpen_capStyle(s->lastPen) <= Qt::SquareCap && s->flags.tx_noshear;
 
     s->strokeFlags = 0;
 }

◆ updateState()

void QRasterPaintEngine::updateState ( )

private

Definition at line 861 of file qpaintengine_raster.cpp.

 {
     QRasterPaintEngineState *s = state();
 
     if (s->dirty & DirtyTransform)
         updateMatrix(s->matrix);
 
     if (s->dirty & (DirtyPen|DirtyCompositionMode|DirtyOpacity)) {
         const QPainter::CompositionMode mode = s->composition_mode;
         s->flags.fast_text = (s->penData.type == QSpanData::Solid)
                        && s->intOpacity == 256
                        && (mode == QPainter::CompositionMode_Source
                            || (mode == QPainter::CompositionMode_SourceOver
                                && qAlpha(s->penData.solid.color) == 255));
     }
 
     s->dirty = 0;
 }

Friends and Related Functions

◆ QBlitterPaintEngine

friend class QBlitterPaintEngine

friend

Definition at line 256 of file qpaintengine_raster_p.h.

◆ QBlitterPaintEnginePrivate

friend class QBlitterPaintEnginePrivate

friend

Definition at line 257 of file qpaintengine_raster_p.h.

◆ QSpan()

QSpan

◆ QSpanData

friend struct QSpanData

friend

Definition at line 255 of file qpaintengine_raster_p.h.

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

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

Public Types

Public Functions

Protected Functions

Private Functions

Friends

Related Functions

Additional Inherited Members

Detailed Description

Enumerations

◆ ClipType

Constructors and Destructors

◆ QRasterPaintEngine() [1/2]

◆ ~QRasterPaintEngine()

◆ QRasterPaintEngine() [2/2]

Functions

◆ alphaPenBlt()

◆ begin()

◆ brushChanged()

◆ brushOriginChanged()

◆ clip() [1/3]

◆ clip() [2/3]

◆ clip() [3/3]

◆ clipBoundingRect()

◆ clipEnabledChanged()

◆ clipType()

◆ compositionModeChanged()

◆ coordinateOffset()

◆ createState()

◆ drawBitmap()

◆ drawBufferSpan()

◆ drawCachedGlyphs()

◆ drawColorSpans()

◆ drawEllipse()

◆ drawImage() [1/2]

◆ drawImage() [2/2]

◆ drawLines() [1/2]

◆ drawLines() [2/2]

◆ drawPixmap() [1/2]

◆ drawPixmap() [2/2]

◆ drawPoints() [1/2]

◆ drawPoints() [2/2]

◆ drawPolygon() [1/2]

◆ drawPolygon() [2/2]

◆ drawRects() [1/2]

◆ drawRects() [2/2]

◆ drawStaticTextItem()

◆ drawTextItem()

◆ drawTiledPixmap()

◆ end()

◆ ensureBrush() [1/2]

◆ ensureBrush() [2/2]

◆ ensureOutlineMapper()

◆ ensurePen() [1/2]

◆ ensurePen() [2/2]

◆ ensureState()

◆ fill()

◆ fillPath()

◆ fillPolygon()

◆ fillRect() [1/3]

◆ fillRect() [2/3]

◆ fillRect() [3/3]

◆ getCGContext()

◆ getDC()

◆ init()

◆ opacityChanged()

◆ penChanged()

◆ releaseBuffer()

◆ releaseDC()

◆ renderHintsChanged()

◆ saveBuffer()

◆ setCGContext()

◆ setClipRectInDeviceCoords()

◆ setDC()

◆ setState()

◆ size()

◆ state() [1/2]

◆ state() [2/2]

◆ stroke()

◆ supportsTransformations() [1/2]

◆ supportsTransformations() [2/2]