Inheritance diagram for QDirectFBPaintEnginePrivate:

Public Types
enum	BlitFlag { HasAlpha = 0x1, Premultiplied = 0x2 }

enum	ClipType { ClipUnset, NoClip, RectClip, RegionClip, ComplexClip }

enum	TransformationTypeFlags { Matrix_NegativeScaleX = 0x100, Matrix_NegativeScaleY = 0x200, Matrix_RectsUnsupported = (QTransform::TxRotate\|QTransform::TxShear\|QTransform::TxProject), Matrix_BlitsUnsupported = (Matrix_RectsUnsupported\|Matrix_NegativeScaleX\|Matrix_NegativeScaleY) }

Public Functions
void	blit (const QRectF &dest, IDirectFBSurface *surface, const QRectF &src)

void	drawTiledPixmap (const QRectF &dest, const QPixmap &pixmap, const QPointF &pos, const QTransform &pixmapTransform)

void	lock ()

void	prepareForBlit (uint blitFlags)

bool	prepareForDraw (const QColor &color)

	QDirectFBPaintEnginePrivate (QDirectFBPaintEngine *p)

void	setBrush (const QBrush &brush)

void	setCompositionMode (QPainter::CompositionMode mode)

void	setPen (const QPen &pen)

void	setRenderHints (QPainter::RenderHints hints)

void	setTransform (const QTransform &transforma)

bool	supportsStretchBlit () const

virtual void	systemStateChanged ()

void	unlock ()

void	updateClip ()

	~QDirectFBPaintEnginePrivate ()

Public Functions inherited from QRasterPaintEnginePrivate
QTransform	brushMatrix () const

bool	canUseFastImageBlending (QPainter::CompositionMode mode, const QImage &image) const

const QClipData *	clip () const

void	drawImage (const QPointF &pt, const QImage &img, SrcOverBlendFunc func, const QRect &clip, int alpha, const QRect &sr=QRect())

ProcessSpans	getBrushFunc (const QRect &rect, const QSpanData *data) const

ProcessSpans	getBrushFunc (const QRectF &rect, const QSpanData *data) const

ProcessSpans	getPenFunc (const QRectF &rect, const QSpanData *data) const

void	initializeRasterizer (QSpanData *data)

bool	isUnclipped (const QRect &rect, int penWidth) const

bool	isUnclipped (const QRectF &rect, int penWidth) const

bool	isUnclipped_normalized (const QRect &rect) const
	Returns true if the rectangle is completely within the current clip state of the paint engine. More...

void	prepare (QCustomRasterPaintDevice *)

	QRasterPaintEnginePrivate ()

void	rasterize (QT_FT_Outline outline, ProcessSpans callback, QSpanData spanData, QRasterBuffer *rasterBuffer)

void	rasterize (QT_FT_Outline outline, ProcessSpans callback, void userData, QRasterBuffer *rasterBuffer)

void	rasterizeLine_dashed (QLineF line, qreal width, int dashIndex, qreal dashOffset, bool *inDash)

void	recalculateFastImages ()

void	updateMatrixData (QSpanData *spanData, const QBrush &brush, const QTransform &brushMatrix)

Public Functions inherited from QPaintEngineExPrivate
bool	hasClipOperations () const

	QPaintEngineExPrivate ()

void	replayClipOperations ()

	~QPaintEngineExPrivate ()

Public Functions inherited from QPaintEnginePrivate
void	drawBoxTextItem (const QPointF &p, const QTextItemInt &ti)

	QPaintEnginePrivate ()

void	setSystemTransform (const QTransform &xform)

void	setSystemViewport (const QRegion &region)

void	transformSystemClip ()

virtual	~QPaintEnginePrivate ()

Static Public Functions
static IDirectFBSurface *	getSurface (const QImage &img, bool *release)

static uint	getTransformationType (const QTransform &transform)

static void	unlock (QDirectFBPaintDevice *device)

Public Variables
bool	antialiased

ClipType	clipType

QRect	currentClip

QDirectFBPaintDevice *	dfbDevice

QDirectFBPaintEngine *	engine

IDirectFB *	fb

bool	inClip

bool	isPremultiplied

quint8	opacity

bool	supportedBrush

bool	supportedComposition

bool	supportedPen

IDirectFBSurface *	surface

SurfaceCache *	surfaceCache

uint	transformationType

Public Variables inherited from QRasterPaintEnginePrivate
QScopedPointer< QClipData >	baseClip

QStroker	basicStroker

QDataBuffer< QLineF >	cachedLines

QScopedPointer< QDashStroker >	dashStroker

QPaintDevice *	device

int	deviceDepth

QRect	deviceRect

QRect	deviceRectUnclipped

QFontEngineGlyphCache::Type	glyphCacheType

QScopedPointer< QT_FT_Raster >	grayRaster

HDC	hdc

QSpanData	image_filler

QSpanData	image_filler_xform

uint	isPlain45DegreeRotation: 1

uint	mono_surface: 1

QScopedPointer< QOutlineMapper >	outlineMapper

uint	outlinemapper_xform_dirty: 1

QScopedPointer< QRasterBuffer >	rasterBuffer

QScopedPointer< QRasterizer >	rasterizer

QSpanData	solid_color_filler

Public Variables inherited from QPaintEngineExPrivate
QStrokerOps *	activeStroker

QDashStroker	dasher

QRect	exDeviceRect

StrokeHandler *	strokeHandler

QStroker	stroker

QPen	strokerPen

Public Variables inherited from QPaintEnginePrivate
QWidget *	currentClipWidget

uint	hasSystemTransform: 1

uint	hasSystemViewport: 1

QPaintDevice *	pdev

QPaintEngine *	q_ptr

QRegion	systemClip

QRect	systemRect

QTransform	systemTransform

QRegion	systemViewport

Detailed Description

Definition at line 62 of file qdirectfbpaintengine.cpp.

Enumerations

◆ BlitFlag

enum QDirectFBPaintEnginePrivate::BlitFlag

Enumerator
HasAlpha
Premultiplied

Definition at line 123 of file qdirectfbpaintengine.cpp.

                   {
         HasAlpha = 0x1,
         Premultiplied = 0x2
     };

◆ ClipType

enum QDirectFBPaintEnginePrivate::ClipType

Enumerator
ClipUnset
NoClip
RectClip
RegionClip
ComplexClip

Definition at line 86 of file qdirectfbpaintengine.cpp.

                   {
         ClipUnset,
         NoClip,
         RectClip,
         RegionClip,
         ComplexClip
     };

◆ TransformationTypeFlags

enum QDirectFBPaintEnginePrivate::TransformationTypeFlags

Enumerator
Matrix_NegativeScaleX
Matrix_NegativeScaleY
Matrix_RectsUnsupported
Matrix_BlitsUnsupported

Definition at line 65 of file qdirectfbpaintengine.cpp.

                                  {
         Matrix_NegativeScaleX = 0x100,
         Matrix_NegativeScaleY = 0x200,
         Matrix_RectsUnsupported = (QTransform::TxRotate|QTransform::TxShear|QTransform::TxProject),
 #if (Q_DIRECTFB_VERSION >= 0x010403)
         Matrix_BlitsUnsupported = (Matrix_RectsUnsupported)
 #else
         Matrix_BlitsUnsupported = (Matrix_RectsUnsupported|Matrix_NegativeScaleX|Matrix_NegativeScaleY)
 #endif
     };

Constructors and Destructors

◆ QDirectFBPaintEnginePrivate()

QDirectFBPaintEnginePrivate::QDirectFBPaintEnginePrivate ( QDirectFBPaintEngine * p )

Definition at line 965 of file qdirectfbpaintengine.cpp.

     : surface(0), antialiased(false), supportedBrush(false), supportedPen(false),
       transformationType(0), opacity(255),
       clipType(ClipUnset), dfbDevice(0),
       supportedComposition(false), isPremultiplied(false), inClip(false), engine(p)
 {
     fb = QDirectFBScreen::instance()->dfb();
     surfaceCache = new SurfaceCache;
 }

◆ ~QDirectFBPaintEnginePrivate()

QDirectFBPaintEnginePrivate::~QDirectFBPaintEnginePrivate ( )

Definition at line 975 of file qdirectfbpaintengine.cpp.

 {
     delete surfaceCache;
 }

Functions

◆ blit()

void QDirectFBPaintEnginePrivate::blit	(	const QRectF &	dest,
		IDirectFBSurface *	surface,
		const QRectF &	src
	)

Definition at line 1220 of file qdirectfbpaintengine.cpp.

 {
     const QRect sr = src.toRect();
     const QRect dr = engine->state()->matrix.mapRect(dest).toRect();
     if (dr.isEmpty())
         return;
     const DFBRectangle sRect = { sr.x(), sr.y(), sr.width(), sr.height() };
     DFBResult result;
 
     if (dr.size() == sr.size()) {
         result = surface->Blit(surface, s, &sRect, dr.x(), dr.y());
     } else {
         Q_ASSERT(supportsStretchBlit());
         const DFBRectangle dRect = { dr.x(), dr.y(), dr.width(), dr.height() };
         result = surface->StretchBlit(surface, s, &sRect, &dRect);
     }
     if (result != DFB_OK)
         DirectFBError("QDirectFBPaintEngine::drawPixmap()", result);
 }

◆ drawTiledPixmap()

void QDirectFBPaintEnginePrivate::drawTiledPixmap	(	const QRectF &	dest,
		const QPixmap &	pixmap,
		const QPointF &	pos,
		const QTransform &	pixmapTransform
	)

Definition at line 1250 of file qdirectfbpaintengine.cpp.

 {
     const QTransform &transform = engine->state()->matrix;
     Q_ASSERT(!(getTransformationType(transform) & Matrix_BlitsUnsupported) &&
              !(getTransformationType(pixmapTransform) & Matrix_BlitsUnsupported));
     const QRect destinationRect = dest.toRect();
     QRect newClip = destinationRect;
     if (!currentClip.isEmpty())
         newClip &= currentClip;
 
     if (newClip.isNull())
         return;
 
     const DFBRegion clip = {
         newClip.x(),
         newClip.y(),
         newClip.right(),
         newClip.bottom()
     };
     surface->SetClip(surface, &clip);
 
     QPointF offset = off;
     Q_ASSERT(transform.type() <= QTransform::TxScale);
     QPixmapData *data = pixmap.pixmapData();
     Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
     QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
     IDirectFBSurface *sourceSurface = dfbData->directFBSurface();
     uint blitFlags = 0;
     if (dfbData->hasAlphaChannel())
         blitFlags |= HasAlpha;
     if (QDirectFBScreen::isPremultiplied(dfbData->pixelFormat()))
         blitFlags |= Premultiplied;
     prepareForBlit(blitFlags);
     QDirectFBPaintEnginePrivate::unlock(dfbData);
     const QSize pixmapSize = dfbData->size();
     if (transform.isScaling() || pixmapTransform.isScaling()) {
         Q_ASSERT(supportsStretchBlit());
         Q_ASSERT(qMin(transform.m11(), transform.m22()) >= 0);
         offset.rx() *= transform.m11();
         offset.ry() *= transform.m22();
 
         const QSizeF mappedSize(pixmapSize.width() * pixmapTransform.m11(), pixmapSize.height() * pixmapTransform.m22());
         qreal y = fixCoord(destinationRect.y(), mappedSize.height(), offset.y());
         const qreal startX = fixCoord(destinationRect.x(), mappedSize.width(), offset.x());
         while (y <= destinationRect.bottom()) {
             qreal x = startX;
             while (x <= destinationRect.right()) {
                 const DFBRectangle destination = { qRound(x), qRound(y), mappedSize.width(), mappedSize.height() };
                 surface->StretchBlit(surface, sourceSurface, 0, &destination);
                 x += mappedSize.width();
             }
             y += mappedSize.height();
         }
     } else {
         qreal y = fixCoord(destinationRect.y(), pixmapSize.height(), offset.y());
         const qreal startX = fixCoord(destinationRect.x(), pixmapSize.width(), offset.x());
         int horizontal = qMax(1, destinationRect.width() / pixmapSize.width()) + 1;
         if (startX != destinationRect.x())
             ++horizontal;
         int vertical = qMax(1, destinationRect.height() / pixmapSize.height()) + 1;
         if (y != destinationRect.y())
             ++vertical;
 
         const int maxCount = (vertical * horizontal);
         QVarLengthArray<DFBRectangle, 16> sourceRects(maxCount);
         QVarLengthArray<DFBPoint, 16> points(maxCount);
 
         int i = 0;
         while (y <= destinationRect.bottom()) {
             Q_ASSERT(i < maxCount);
             qreal x = startX;
             while (x <= destinationRect.right()) {
                 points[i].x = qRound(x);
                 points[i].y = qRound(y);
                 sourceRects[i].x = 0;
                 sourceRects[i].y = 0;
                 sourceRects[i].w = int(pixmapSize.width());
                 sourceRects[i].h = int(pixmapSize.height());
                 x += pixmapSize.width();
                 ++i;
             }
             y += pixmapSize.height();
         }
         surface->BatchBlit(surface, sourceSurface, sourceRects.constData(), points.constData(), i);
     }
 
     if (currentClip.isEmpty()) {
         surface->SetClip(surface, 0);
     } else {
         const DFBRegion clip = {
             currentClip.x(),
             currentClip.y(),
             currentClip.right(),
             currentClip.bottom()
         };
         surface->SetClip(surface, &clip);
     }
 }

◆ getSurface()

IDirectFBSurface * QDirectFBPaintEnginePrivate::getSurface	(	const QImage &	img,
		bool *	release
	)

static

Definition at line 1185 of file qdirectfbpaintengine.cpp.

Referenced by SurfaceCache::~SurfaceCache().

 {
 #ifdef QT_NO_DIRECTFB_IMAGECACHE
     *release = true;
     return QDirectFBScreen::instance()->createDFBSurface(img, img.format(), QDirectFBScreen::DontTrackSurface);
 #else
     const qint64 key = img.cacheKey();
     *release = false;
     if (imageCache.contains(key)) {
         return imageCache[key]->surface;
     }
 
     const int cost = cacheCost(img);
     const bool cache = cost <= imageCache.maxCost();
     QDirectFBScreen *screen = QDirectFBScreen::instance();
     const QImage::Format format = (img.format() == screen->alphaPixmapFormat() || QDirectFBPixmapData::hasAlphaChannel(img)
                                    ? screen->alphaPixmapFormat() : screen->pixelFormat());
 
     IDirectFBSurface *surface = screen->createDFBSurface(img, format,
                                                          cache
                                                          ? QDirectFBScreen::TrackSurface
                                                          : QDirectFBScreen::DontTrackSurface);
     if (cache) {
         CachedImage *cachedImage = new CachedImage;
         const_cast<QImage&>(img).data_ptr()->is_cached = true;
         cachedImage->surface = surface;
         imageCache.insert(key, cachedImage, cost);
     } else {
         *release = true;
     }
     return surface;
 #endif
 }

◆ getTransformationType()

static uint QDirectFBPaintEnginePrivate::getTransformationType ( const QTransform & transform )

inlinestatic

Definition at line 76 of file qdirectfbpaintengine.cpp.

Referenced by drawTiledPixmap(), QDirectFBPaintEngine::fillRect(), and setTransform().

     {
         int ret = transform.type();
         if (transform.m11() < 0)
             ret |= QDirectFBPaintEnginePrivate::Matrix_NegativeScaleX;
         if (transform.m22() < 0)
             ret |= QDirectFBPaintEnginePrivate::Matrix_NegativeScaleY;
         return ret;
     }

◆ lock()

void QDirectFBPaintEnginePrivate::lock ( )

Definition at line 980 of file qdirectfbpaintengine.cpp.

 {
     // We will potentially get a new pointer to the buffer after a
     // lock so we need to call the base implementation of prepare so
     // it updates its rasterBuffer to point to the new buffer address.
     Q_ASSERT(dfbDevice);
     if (dfbDevice->lockSurface(DSLF_READ|DSLF_WRITE)) {
         prepare(dfbDevice);
     }
 }

◆ prepareForBlit()

void QDirectFBPaintEnginePrivate::prepareForBlit ( uint blitFlags )

Definition at line 1107 of file qdirectfbpaintengine.cpp.

Referenced by drawTiledPixmap().

 {
     DFBSurfaceBlittingFlags blittingFlags = DSBLIT_NOFX;
 
 #if (Q_DIRECTFB_VERSION >= 0x010403)
     if (transformationType & Matrix_NegativeScaleX)
         blittingFlags |= DSBLIT_FLIP_HORIZONTAL;
 
     if (transformationType & Matrix_NegativeScaleY)
         blittingFlags |= DSBLIT_FLIP_VERTICAL;
 #endif
 
     if (flags & HasAlpha)
         blittingFlags |= DSBLIT_BLEND_ALPHACHANNEL;
 
     if (opacity != 255) {
         blittingFlags |= DSBLIT_BLEND_COLORALPHA;
         surface->SetColor(surface, 0xff, 0xff, 0xff, opacity);
     }
 
     if (flags & Premultiplied) {
         if (blittingFlags & DSBLIT_BLEND_COLORALPHA)
             blittingFlags |= DSBLIT_SRC_PREMULTCOLOR;
     } else {
         if (blittingFlags & (DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_BLEND_COLORALPHA))
             blittingFlags |= DSBLIT_SRC_PREMULTIPLY;
     }
 
     surface->SetBlittingFlags(surface, blittingFlags);
 }

◆ prepareForDraw()

bool QDirectFBPaintEnginePrivate::prepareForDraw ( const QColor & color )

Definition at line 1145 of file qdirectfbpaintengine.cpp.

 {
     Q_ASSERT(surface);
     Q_ASSERT(supportedComposition);
     const quint8 alpha = (opacity == 255 ?
                           color.alpha() : ALPHA_MUL(color.alpha(), opacity));
     QColor col;
     if (isPremultiplied) {
         col = QColor(ALPHA_MUL(color.red(), alpha),
                      ALPHA_MUL(color.green(), alpha),
                      ALPHA_MUL(color.blue(), alpha),
                      alpha);
     } else {
         col = QColor(color.red(), color.green(), color.blue(), alpha);
     }
     surface->SetColor(surface, col.red(), col.green(), col.blue(), col.alpha());
 
     bool blend = false;
 
     switch (engine->state()->composition_mode) {
     case QPainter::CompositionMode_Clear:
     case QPainter::CompositionMode_Source:
         break;
     case QPainter::CompositionMode_SourceOver:
         if (alpha == 0)
             return false;
 
         if (alpha != 255)
             blend = true;
         break;
     default:
         blend = true;
         break;
     }
 
     surface->SetDrawingFlags(surface, blend ? DSDRAW_BLEND : DSDRAW_NOFX);
 
     return true;
 }

◆ setBrush()

void QDirectFBPaintEnginePrivate::setBrush ( const QBrush & brush )

Definition at line 1011 of file qdirectfbpaintengine.cpp.

 {
      supportedBrush = (brush.style() == Qt::NoBrush) || (brush.style() == Qt::SolidPattern && !antialiased);
 }

◆ setCompositionMode()

void QDirectFBPaintEnginePrivate::setCompositionMode ( QPainter::CompositionMode mode )

Definition at line 1016 of file qdirectfbpaintengine.cpp.

 {
     if (!surface)
         return;
 
     static const bool forceRasterFallBack = qgetenv("QT_DIRECTFB_FORCE_RASTER").toInt() > 0;
     if (forceRasterFallBack) {
         supportedComposition = false;
         return;
     }
 
     supportedComposition = true;
     switch (mode) {
     case QPainter::CompositionMode_Clear:
         surface->SetPorterDuff(surface, DSPD_CLEAR);
         break;
     case QPainter::CompositionMode_Source:
         surface->SetPorterDuff(surface, DSPD_SRC);
         break;
     case QPainter::CompositionMode_SourceOver:
         surface->SetPorterDuff(surface, DSPD_SRC_OVER);
         break;
     case QPainter::CompositionMode_DestinationOver:
         surface->SetPorterDuff(surface, DSPD_DST_OVER);
         break;
     case QPainter::CompositionMode_SourceIn:
         surface->SetPorterDuff(surface, DSPD_SRC_IN);
         break;
     case QPainter::CompositionMode_DestinationIn:
         surface->SetPorterDuff(surface, DSPD_DST_IN);
         break;
     case QPainter::CompositionMode_SourceOut:
         surface->SetPorterDuff(surface, DSPD_SRC_OUT);
         break;
     case QPainter::CompositionMode_DestinationOut:
         surface->SetPorterDuff(surface, DSPD_DST_OUT);
         break;
     case QPainter::CompositionMode_Destination:
         surface->SetSrcBlendFunction(surface, DSBF_ZERO);
         surface->SetDstBlendFunction(surface, DSBF_ONE);
         break;
 #if (Q_DIRECTFB_VERSION >= 0x010000)
     case QPainter::CompositionMode_SourceAtop:
         surface->SetPorterDuff(surface, DSPD_SRC_ATOP);
         break;
     case QPainter::CompositionMode_DestinationAtop:
         surface->SetPorterDuff(surface, DSPD_DST_ATOP);
         break;
     case QPainter::CompositionMode_Plus:
         surface->SetPorterDuff(surface, DSPD_ADD);
         break;
     case QPainter::CompositionMode_Xor:
         surface->SetPorterDuff(surface, DSPD_XOR);
         break;
 #endif
     default:
         supportedComposition = false;
         break;
     }
 }

◆ setPen()

void QDirectFBPaintEnginePrivate::setPen ( const QPen & pen )

Definition at line 1077 of file qdirectfbpaintengine.cpp.

Referenced by setRenderHints(), and setTransform().

 {
     if (pen.style() == Qt::NoPen) {
         supportedPen = true;
     } else if (pen.style() == Qt::SolidLine
                && !antialiased
                && pen.brush().style() == Qt::SolidPattern
                && pen.widthF() <= 1.0
                && (transformationType < QTransform::TxScale || pen.isCosmetic())) {
         supportedPen = true;
     } else {
         supportedPen = false;
     }
 }

◆ setRenderHints()

void QDirectFBPaintEnginePrivate::setRenderHints ( QPainter::RenderHints hints )

Definition at line 1098 of file qdirectfbpaintengine.cpp.

 {
     const bool old = antialiased;
     antialiased = bool(hints & QPainter::Antialiasing);
     if (old != antialiased) {
         setPen(engine->state()->pen);
     }
 }

◆ setTransform()

void QDirectFBPaintEnginePrivate::setTransform ( const QTransform & transforma )

Definition at line 1092 of file qdirectfbpaintengine.cpp.

 {
     transformationType = getTransformationType(transform);
     setPen(engine->state()->pen);
 }

◆ supportsStretchBlit()

bool QDirectFBPaintEnginePrivate::supportsStretchBlit ( ) const

Definition at line 1376 of file qdirectfbpaintengine.cpp.

Referenced by blit(), and drawTiledPixmap().

 {
 #ifdef QT_DIRECTFB_STRETCHBLIT
     DFBGraphicsDeviceDescription desc;
 
     fb->GetDeviceDescription(fb, &desc);
 
     return !(engine->state()->renderHints & QPainter::SmoothPixmapTransform)
                || (desc.acceleration_mask & DFXL_STRETCHBLIT);
 #else
     return false;
 #endif
 }

◆ systemStateChanged()

void QDirectFBPaintEnginePrivate::systemStateChanged ( )

virtual

Reimplemented from QRasterPaintEnginePrivate.

Definition at line 1391 of file qdirectfbpaintengine.cpp.

 {
     QRasterPaintEnginePrivate::systemStateChanged();
     updateClip();
 }

◆ unlock() [1/2]

void QDirectFBPaintEnginePrivate::unlock ( )

Definition at line 991 of file qdirectfbpaintengine.cpp.

Referenced by QDirectFBPaintEngine::begin(), QDirectFBPaintEngine::drawPixmap(), and drawTiledPixmap().

 {
     Q_ASSERT(dfbDevice);
 #ifdef QT_DIRECTFB_SUBSURFACE
     dfbDevice->syncPending = true;
 #else
     QDirectFBPaintEnginePrivate::unlock(dfbDevice);
 #endif
 }

◆ unlock() [2/2]

void QDirectFBPaintEnginePrivate::unlock ( QDirectFBPaintDevice * device )

inlinestatic

Definition at line 1001 of file qdirectfbpaintengine.cpp.

 {
 #ifdef QT_NO_DIRECTFB_SUBSURFACE
     Q_ASSERT(device);
     device->unlockSurface();
 #else
     Q_UNUSED(device);
 #endif
 }

◆ updateClip()

void QDirectFBPaintEnginePrivate::updateClip ( )

Definition at line 1350 of file qdirectfbpaintengine.cpp.

Referenced by systemStateChanged().

 {
     Q_ASSERT(surface);
     currentClip = QRect();
     const QClipData *clipData = clip();
     if (!clipData || !clipData->enabled) {
         surface->SetClip(surface, NULL);
         clipType = NoClip;
     } else if (clipData->hasRectClip) {
         const DFBRegion r = {
             clipData->clipRect.x(),
             clipData->clipRect.y(),
             clipData->clipRect.right(),
             clipData->clipRect.bottom()
         };
         surface->SetClip(surface, &r);
         currentClip = clipData->clipRect.normalized();
         // ### is this guaranteed to always be normalized?
         clipType = RectClip;
     } else if (clipData->hasRegionClip) {
         clipType = RegionClip;
     } else {
         clipType = ComplexClip;
     }
 }

Properties

◆ antialiased

bool QDirectFBPaintEnginePrivate::antialiased

Definition at line 131 of file qdirectfbpaintengine.cpp.

Referenced by setBrush(), setPen(), and setRenderHints().

◆ clipType

ClipType QDirectFBPaintEnginePrivate::clipType

Definition at line 141 of file qdirectfbpaintengine.cpp.

Referenced by rasterFallbackWarn(), and updateClip().

◆ currentClip

QRect QDirectFBPaintEnginePrivate::currentClip

Definition at line 147 of file qdirectfbpaintengine.cpp.

Referenced by drawTiledPixmap(), and updateClip().

◆ dfbDevice

QDirectFBPaintDevice* QDirectFBPaintEnginePrivate::dfbDevice

Definition at line 142 of file qdirectfbpaintengine.cpp.

Referenced by lock(), and unlock().

◆ engine

QDirectFBPaintEngine* QDirectFBPaintEnginePrivate::engine

Definition at line 149 of file qdirectfbpaintengine.cpp.

Referenced by blit(), drawTiledPixmap(), prepareForDraw(), rasterFallbackWarn(), setRenderHints(), setTransform(), and supportsStretchBlit().

◆ fb

IDirectFB* QDirectFBPaintEnginePrivate::fb

Definition at line 138 of file qdirectfbpaintengine.cpp.

Referenced by QDirectFBPaintEnginePrivate(), and supportsStretchBlit().

◆ inClip

bool QDirectFBPaintEnginePrivate::inClip

Definition at line 146 of file qdirectfbpaintengine.cpp.

◆ isPremultiplied

bool QDirectFBPaintEnginePrivate::isPremultiplied

Definition at line 144 of file qdirectfbpaintengine.cpp.

Referenced by prepareForDraw().

◆ opacity

quint8 QDirectFBPaintEnginePrivate::opacity

Definition at line 139 of file qdirectfbpaintengine.cpp.

Referenced by prepareForBlit(), and prepareForDraw().

◆ supportedBrush

bool QDirectFBPaintEnginePrivate::supportedBrush

Definition at line 132 of file qdirectfbpaintengine.cpp.

Referenced by rasterFallbackWarn(), and setBrush().

◆ supportedComposition

bool QDirectFBPaintEnginePrivate::supportedComposition

Definition at line 143 of file qdirectfbpaintengine.cpp.

Referenced by prepareForDraw(), rasterFallbackWarn(), and setCompositionMode().

◆ supportedPen

bool QDirectFBPaintEnginePrivate::supportedPen

Definition at line 133 of file qdirectfbpaintengine.cpp.

Referenced by rasterFallbackWarn(), and setPen().

◆ surface

IDirectFBSurface* QDirectFBPaintEnginePrivate::surface

Definition at line 129 of file qdirectfbpaintengine.cpp.

Referenced by blit(), SurfaceCache::clear(), drawTiledPixmap(), getSurface(), SurfaceCache::getSurface(), prepareForBlit(), prepareForDraw(), setCompositionMode(), and updateClip().

◆ surfaceCache

SurfaceCache* QDirectFBPaintEnginePrivate::surfaceCache

Definition at line 137 of file qdirectfbpaintengine.cpp.

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

◆ transformationType

uint QDirectFBPaintEnginePrivate::transformationType

Definition at line 135 of file qdirectfbpaintengine.cpp.

Referenced by prepareForBlit(), rasterFallbackWarn(), setPen(), and setTransform().

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

/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp

Public Types

Public Functions

Static Public Functions

Public Variables