Inheritance diagram for QVGPaintEnginePrivate:

Public Types
enum	AdvancedBlending { QT_VG_BLEND_OVERLAY_KHR = 0x2010, QT_VG_BLEND_HARDLIGHT_KHR = 0x2011, QT_VG_BLEND_SOFTLIGHT_SVG_KHR = 0x2012, QT_VG_BLEND_SOFTLIGHT_KHR = 0x2013, QT_VG_BLEND_COLORDODGE_KHR = 0x2014, QT_VG_BLEND_COLORBURN_KHR = 0x2015, QT_VG_BLEND_DIFFERENCE_KHR = 0x2016, QT_VG_BLEND_SUBTRACT_KHR = 0x2017, QT_VG_BLEND_INVERT_KHR = 0x2018, QT_VG_BLEND_EXCLUSION_KHR = 0x2019, QT_VG_BLEND_LINEARDODGE_KHR = 0x201a, QT_VG_BLEND_LINEARBURN_KHR = 0x201b, QT_VG_BLEND_VIVIDLIGHT_KHR = 0x201c, QT_VG_BLEND_LINEARLIGHT_KHR = 0x201d, QT_VG_BLEND_PINLIGHT_KHR = 0x201e, QT_VG_BLEND_HARDMIX_KHR = 0x201f, QT_VG_BLEND_CLEAR_KHR = 0x2020, QT_VG_BLEND_DST_KHR = 0x2021, QT_VG_BLEND_SRC_OUT_KHR = 0x2022, QT_VG_BLEND_DST_OUT_KHR = 0x2023, QT_VG_BLEND_SRC_ATOP_KHR = 0x2024, QT_VG_BLEND_DST_ATOP_KHR = 0x2025, QT_VG_BLEND_XOR_KHR = 0x2026 }

Public Functions
void	clearModes ()

void	destroy ()

void	draw (VGPath path, const QPen &pen, const QBrush &brush, VGint rule=VG_EVEN_ODD)

void	ensureBrush (const QBrush &brush)

void	ensureMask (QVGPaintEngine *engine, int width, int height)

void	ensurePathTransform ()

void	ensurePen (const QPen &pen)

void	fill (VGPath path, const QBrush &brush, VGint rule=VG_EVEN_ODD)

void	init ()

void	initObjects ()

void	modifyMask (QVGPaintEngine *engine, VGMaskOperation op, const QRegion &region)

void	modifyMask (QVGPaintEngine *engine, VGMaskOperation op, const QRect &rect)

bool	needsBrushEmulation () const

bool	needsEmulation (const QBrush &brush) const

bool	needsEmulation () const

bool	needsPenEmulation () const

VGPath	painterPathToVGPath (const QPainterPath &path)

	QVGPaintEnginePrivate (QVGPaintEngine *q_ptr)

VGPath	roundedRectPath (const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)

void	setBlendMode (VGBlendMode mode)

VGPaintType	setBrush (VGPaint paint, const QBrush &brush, VGMatrixMode mode, VGPaintType prevPaintType)

void	setBrushTransform (const QBrush &brush, VGMatrixMode mode)

void	setFillRule (VGint mode)

void	setImageMode (VGImageMode mode)

void	setImageOptions ()

void	setImageQuality (VGImageQuality mode)

void	setPenParams (const QPen &pen)

void	setRenderingQuality (VGRenderingQuality mode)

void	setTransform (VGMatrixMode mode, const QTransform &transform)

void	setupColorRamp (const QGradient *grad, VGPaint paint)

void	stroke (VGPath path, const QPen &pen)

void	systemStateChanged ()

void	updateTransform (QPaintDevice *pdev)

VGPath	vectorPathToVGPath (const QVectorPath &path)

	~QVGPaintEnginePrivate ()

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 ()

Public Variables
VGBlendMode	blendMode

QScopedPointer< QPixmapFilter >	blurFilter

QPointF	brushOrigin

VGPaint	brushPaint

QTransform	brushTransform

VGPaintType	brushType

QColor	clearColor

VGfloat	clearOpacity

QScopedPointer< QPixmapFilter >	colorizeFilter

QScopedPointer< QPixmapFilter >	convolutionFilter

QBrush	currentBrush

QPen	currentPen

QPaintEngine::DirtyFlags	dirty

QScopedPointer< QPixmapFilter >	dropShadowFilter

VGPaint	fillPaint

VGint	fillRule

bool	forceBrushChange

bool	forcePenChange

bool	hasAdvancedBlending

bool	hasExtendedRadialGradientBrush

bool	hasExtendedRadialGradientPen

VGImageMode	imageMode

VGImageQuality	imageQuality

QTransform	imageTransform

VGPath	linePath

bool	maskIsSet

QRect	maskRect

bool	maskValid

VGMatrixMode	matrixMode

VGint	maxScissorRects

qreal	opacity

VGPaint	opacityPaint

qreal	paintOpacity

QTransform	pathTransform

bool	pathTransformSet

VGPaint	penPaint

qreal	penScale

QTransform	penTransform

VGPaintType	penType

bool	rawVG

VGPath	rectPath

VGRenderingQuality	renderingQuality

VGPath	roundRectPath

bool	scissorActive

bool	scissorDirty

bool	scissorMask

QRegion	scissorRegion

bool	simpleTransform

QTransform	transform

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

Properties
QVGPaintEngine *	q

Detailed Description

Definition at line 100 of file qpaintengine_vg.cpp.

Enumerations

◆ AdvancedBlending

enum QVGPaintEnginePrivate::AdvancedBlending

Enumerator
QT_VG_BLEND_OVERLAY_KHR
QT_VG_BLEND_HARDLIGHT_KHR
QT_VG_BLEND_SOFTLIGHT_SVG_KHR
QT_VG_BLEND_SOFTLIGHT_KHR
QT_VG_BLEND_COLORDODGE_KHR
QT_VG_BLEND_COLORBURN_KHR
QT_VG_BLEND_DIFFERENCE_KHR
QT_VG_BLEND_SUBTRACT_KHR
QT_VG_BLEND_INVERT_KHR
QT_VG_BLEND_EXCLUSION_KHR
QT_VG_BLEND_LINEARDODGE_KHR
QT_VG_BLEND_LINEARBURN_KHR
QT_VG_BLEND_VIVIDLIGHT_KHR
QT_VG_BLEND_LINEARLIGHT_KHR
QT_VG_BLEND_PINLIGHT_KHR
QT_VG_BLEND_HARDMIX_KHR
QT_VG_BLEND_CLEAR_KHR
QT_VG_BLEND_DST_KHR
QT_VG_BLEND_SRC_OUT_KHR
QT_VG_BLEND_DST_OUT_KHR
QT_VG_BLEND_SRC_ATOP_KHR
QT_VG_BLEND_DST_ATOP_KHR
QT_VG_BLEND_XOR_KHR

Definition at line 107 of file qpaintengine_vg.cpp.

                           {
         QT_VG_BLEND_OVERLAY_KHR       = 0x2010,
         QT_VG_BLEND_HARDLIGHT_KHR     = 0x2011,
         QT_VG_BLEND_SOFTLIGHT_SVG_KHR = 0x2012,
         QT_VG_BLEND_SOFTLIGHT_KHR     = 0x2013,
         QT_VG_BLEND_COLORDODGE_KHR    = 0x2014,
         QT_VG_BLEND_COLORBURN_KHR     = 0x2015,
         QT_VG_BLEND_DIFFERENCE_KHR    = 0x2016,
         QT_VG_BLEND_SUBTRACT_KHR      = 0x2017,
         QT_VG_BLEND_INVERT_KHR        = 0x2018,
         QT_VG_BLEND_EXCLUSION_KHR     = 0x2019,
         QT_VG_BLEND_LINEARDODGE_KHR   = 0x201a,
         QT_VG_BLEND_LINEARBURN_KHR    = 0x201b,
         QT_VG_BLEND_VIVIDLIGHT_KHR    = 0x201c,
         QT_VG_BLEND_LINEARLIGHT_KHR   = 0x201d,
         QT_VG_BLEND_PINLIGHT_KHR      = 0x201e,
         QT_VG_BLEND_HARDMIX_KHR       = 0x201f,
         QT_VG_BLEND_CLEAR_KHR         = 0x2020,
         QT_VG_BLEND_DST_KHR           = 0x2021,
         QT_VG_BLEND_SRC_OUT_KHR       = 0x2022,
         QT_VG_BLEND_DST_OUT_KHR       = 0x2023,
         QT_VG_BLEND_SRC_ATOP_KHR      = 0x2024,
         QT_VG_BLEND_DST_ATOP_KHR      = 0x2025,
         QT_VG_BLEND_XOR_KHR           = 0x2026
     };

Constructors and Destructors

◆ QVGPaintEnginePrivate()

QVGPaintEnginePrivate::QVGPaintEnginePrivate ( QVGPaintEngine * q_ptr )

Definition at line 366 of file qpaintengine_vg.cpp.

◆ ~QVGPaintEnginePrivate()

QVGPaintEnginePrivate::~QVGPaintEnginePrivate ( )

Definition at line 427 of file qpaintengine_vg.cpp.

 {
     destroy();
 }

Functions

◆ clearModes()

void QVGPaintEnginePrivate::clearModes ( )

Definition at line 357 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::endNativePainting(), and init().

 {
     matrixMode = (VGMatrixMode)0;
     imageMode = (VGImageMode)0;
     blendMode = (VGBlendMode)0;
     renderingQuality = (VGRenderingQuality)0;
     imageQuality = (VGImageQuality)0;
 }

◆ destroy()

void QVGPaintEnginePrivate::destroy ( )

Definition at line 506 of file qpaintengine_vg.cpp.

Referenced by ~QVGPaintEnginePrivate().

 {
     if (penPaint)
         vgDestroyPaint(penPaint);
     if (brushPaint)
         vgDestroyPaint(brushPaint);
     if (opacityPaint)
         vgDestroyPaint(opacityPaint);
 
 #if !defined(QVG_NO_MODIFY_PATH)
     if (rectPath)
         vgDestroyPath(rectPath);
     if (linePath)
         vgDestroyPath(linePath);
     if (roundRectPath)
         vgDestroyPath(roundRectPath);
 #endif
 
 #if !defined(QVG_NO_DRAW_GLYPHS)
     QVGFontCache::Iterator it;
     for (it = fontCache.begin(); it != fontCache.end(); ++it)
         delete it.value();
     fontCache.clear();
     delete fontEngineCleaner;
 #endif
 }

◆ draw()

void QVGPaintEnginePrivate::draw	(	VGPath	path,
		const QPen &	pen,
		const QBrush &	brush,
		VGint	rule = `VG_EVEN_ODD`
	)

Definition at line 1499 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::createState().

 {
     VGbitfield mode = 0;
     if (qpen_style(pen) != Qt::NoPen && qbrush_style(qpen_brush(pen)) != Qt::NoBrush) {
         ensurePen(pen);
         mode |= VG_STROKE_PATH;
     }
     if (brush.style() != Qt::NoBrush) {
         ensureBrush(brush);
         setFillRule(rule);
         mode |= VG_FILL_PATH;
     }
     if (mode != 0) {
         ensurePathTransform();
         vgDrawPath(path, mode);
     }
 }

◆ ensureBrush()

void QVGPaintEnginePrivate::ensureBrush ( const QBrush & brush )

inline

Definition at line 268 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::beginNativePainting(), QVGPaintEngine::drawCachedGlyphs(), QVGCompositionHelper::fillBackground(), and qt_vg_drawVGImageStencil().

                                                  {
         if (forceBrushChange || brush != currentBrush) {
             currentBrush = brush;
             forceBrushChange = false;
             brushType = setBrush
                 (brushPaint, brush, VG_MATRIX_FILL_PAINT_TO_USER, brushType);
         }
         if (fillPaint != brushPaint) {
             vgSetPaint(brushPaint, VG_FILL_PATH);
             fillPaint = brushPaint;
         }
     }

◆ ensureMask()

void QVGPaintEnginePrivate::ensureMask	(	QVGPaintEngine *	engine,
		int	width,
		int	height
	)

Definition at line 2177 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::clip().

 {
     scissorMask = false;
     if (maskIsSet) {
         vgMask(VG_INVALID_HANDLE, VG_FILL_MASK, 0, 0, width, height);
         maskRect = QRect();
     } else {
         vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK, 0, 0, width, height);
         if (maskRect.isValid()) {
             vgMask(VG_INVALID_HANDLE, VG_FILL_MASK,
                    maskRect.x(), height - maskRect.y() - maskRect.height(),
                    maskRect.width(), maskRect.height());
             maskRect = QRect();
             engine->updateScissor();
         }
     }
 }

◆ ensurePathTransform()

void QVGPaintEnginePrivate::ensurePathTransform ( )

inline

Definition at line 243 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::beginNativePainting().

     {
         if (!pathTransformSet) {
             QTransform aliasedTransform = pathTransform;
             if (renderingQuality == VG_RENDERING_QUALITY_NONANTIALIASED && currentPen != Qt::NoPen)
                 aliasedTransform = aliasedTransform
                     * QTransform::fromTranslate(aliasedCoordinateDelta, -aliasedCoordinateDelta);
             setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, aliasedTransform);
             pathTransformSet = true;
         }
     }

◆ ensurePen()

void QVGPaintEnginePrivate::ensurePen ( const QPen & pen )

inline

Definition at line 256 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::beginNativePainting().

                                            {
         if (forcePenChange || pen != currentPen) {
             currentPen = pen;
             forcePenChange = false;
             penType = setBrush
                 (penPaint, pen.brush(),
                  VG_MATRIX_STROKE_PAINT_TO_USER, penType);
             setPenParams(pen);
         }
     }

◆ fill()

void QVGPaintEnginePrivate::fill	(	VGPath	path,
		const QBrush &	brush,
		VGint	rule = `VG_EVEN_ODD`
	)

Definition at line 1526 of file qpaintengine_vg.cpp.

 {
     if (brush.style() == Qt::NoBrush)
         return;
     ensureBrush(brush);
     setFillRule(rule);
     QPen savedPen = currentPen;
     currentPen = Qt::NoPen;
     ensurePathTransform();
     currentPen = savedPen;
     vgDrawPath(path, VG_FILL_PATH);
 }

◆ init()

void QVGPaintEnginePrivate::init ( )

Definition at line 371 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEnginePrivate().

 {
     maxScissorRects = 0;
 
     penPaint = 0;
     brushPaint = 0;
     opacityPaint = 0;
     fillPaint = 0;
 
     forcePenChange = true;
     forceBrushChange = true;
 
     hasExtendedRadialGradientPen = false;
     hasExtendedRadialGradientBrush = false;
 
     penType = (VGPaintType)0;
     brushType = (VGPaintType)0;
 
     brushOrigin = QPointF(0.0f, 0.0f);
 
     fillRule = 0;
 
     opacity = 1.0;
     paintOpacity = 1.0f;
 
 #if !defined(QVG_NO_MODIFY_PATH)
     rectPath = 0;
     linePath = 0;
     roundRectPath = 0;
 #endif
 
     simpleTransform = true;
     pathTransformSet = false;
     penScale = 1.0;
 
     maskValid = false;
     maskIsSet = false;
     scissorMask = false;
     rawVG = false;
 
     scissorActive = false;
     scissorDirty = false;
 
     dirty = 0;
 
     clearOpacity = 1.0f;
 
 #if !defined(QVG_NO_DRAW_GLYPHS)
     fontEngineCleaner = 0;
 #endif
 
     hasAdvancedBlending = false;
 
     clearModes();
 }

◆ initObjects()

void QVGPaintEnginePrivate::initObjects ( )

Definition at line 432 of file qpaintengine_vg.cpp.

 {
     maxScissorRects = vgGeti(VG_MAX_SCISSOR_RECTS);
 
     penPaint = vgCreatePaint();
     vgSetParameteri(penPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
     vgSetPaint(penPaint, VG_STROKE_PATH);
 
     vgSeti(VG_MATRIX_MODE, VG_MATRIX_STROKE_PAINT_TO_USER);
     vgLoadIdentity();
 
     brushPaint = vgCreatePaint();
     vgSetParameteri(brushPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
     vgSetPaint(brushPaint, VG_FILL_PATH);
     fillPaint = brushPaint;
 
     vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
     vgLoadIdentity();
     matrixMode = VG_MATRIX_FILL_PAINT_TO_USER;
 
     opacityPaint = vgCreatePaint();
     vgSetParameteri(opacityPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
     VGfloat values[4];
     values[0] = 1.0f;
     values[1] = 1.0f;
     values[2] = 1.0f;
     values[3] = paintOpacity;
     vgSetParameterfv(opacityPaint, VG_PAINT_COLOR, 4, values);
 
 #if !defined(QVG_NO_MODIFY_PATH)
     // Create a dummy path for rectangle drawing, which we can
     // modify later with vgModifyPathCoords().  This should be
     // faster than constantly creating and destroying paths.
     rectPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                             VG_PATH_DATATYPE_F,
                             1.0f, // scale
                             0.0f, // bias
                             5,    // segmentCapacityHint
                             8,    // coordCapacityHint
                             VG_PATH_CAPABILITY_ALL);
     static VGubyte const segments[5] = {
         VG_MOVE_TO_ABS,
         VG_LINE_TO_ABS,
         VG_LINE_TO_ABS,
         VG_LINE_TO_ABS,
         VG_CLOSE_PATH
     };
     VGfloat coords[8];
     coords[0] = 0.0f;
     coords[1] = 0.0f;
     coords[2] = 100.0f;
     coords[3] = coords[1];
     coords[4] = coords[2];
     coords[5] = 100.0f;
     coords[6] = coords[0];
     coords[7] = coords[5];
     vgAppendPathData(rectPath, 5, segments, coords);
 
     // Create a dummy line drawing path as well.
     linePath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                             VG_PATH_DATATYPE_F,
                             1.0f, // scale
                             0.0f, // bias
                             2,    // segmentCapacityHint
                             4,    // coordCapacityHint
                             VG_PATH_CAPABILITY_ALL);
     vgAppendPathData(linePath, 2, segments, coords);
 #endif
 
     const char *extensions = reinterpret_cast<const char *>(vgGetString(VG_EXTENSIONS));
     if (extensions)
         hasAdvancedBlending = strstr(extensions, "VG_KHR_advanced_blending") != 0;
 }

◆ modifyMask() [1/2]

void QVGPaintEnginePrivate::modifyMask	(	QVGPaintEngine *	engine,
		VGMaskOperation	op,
		const QRegion &	region
	)

Definition at line 2196 of file qpaintengine_vg.cpp.

Referenced by ensureMask().

 {
     QPaintDevice *pdev = engine->paintDevice();
     int width = pdev->width();
     int height = pdev->height();
 
     if (!maskValid)
         ensureMask(engine, width, height);
 
     QVector<QRect> rects = region.rects();
     for (int i = 0; i < rects.size(); ++i) {
         vgMask(VG_INVALID_HANDLE, op,
                rects[i].x(), height - rects[i].y() - rects[i].height(),
                rects[i].width(), rects[i].height());
     }
 
     vgSeti(VG_MASKING, VG_TRUE);
     maskValid = true;
     maskIsSet = false;
     scissorMask = false;
 }

◆ modifyMask() [2/2]

void QVGPaintEnginePrivate::modifyMask	(	QVGPaintEngine *	engine,
		VGMaskOperation	op,
		const QRect &	rect
	)

Definition at line 2219 of file qpaintengine_vg.cpp.

 {
     QPaintDevice *pdev = engine->paintDevice();
     int width = pdev->width();
     int height = pdev->height();
 
     if (!maskValid)
         ensureMask(engine, width, height);
 
     if (rect.isValid()) {
         vgMask(VG_INVALID_HANDLE, op,
                rect.x(), height - rect.y() - rect.height(),
                rect.width(), rect.height());
     }
 
     vgSeti(VG_MASKING, VG_TRUE);
     maskValid = true;
     maskIsSet = false;
     scissorMask = false;
 }

◆ needsBrushEmulation()

bool QVGPaintEnginePrivate::needsBrushEmulation ( ) const

inline

Definition at line 297 of file qpaintengine_vg.cpp.

     {
         return hasExtendedRadialGradientBrush;
     }

◆ needsEmulation() [1/2]

bool QVGPaintEnginePrivate::needsEmulation ( const QBrush & brush ) const

inline

Definition at line 281 of file qpaintengine_vg.cpp.

     {
         Q_GUI_EXPORT bool qt_isExtendedRadialGradient(const QBrush &brush);
         return qt_isExtendedRadialGradient(brush);
     }

◆ needsEmulation() [2/2]

bool QVGPaintEnginePrivate::needsEmulation ( ) const

inline

Definition at line 287 of file qpaintengine_vg.cpp.

     {
         return hasExtendedRadialGradientPen || hasExtendedRadialGradientBrush;
     }

◆ needsPenEmulation()

bool QVGPaintEnginePrivate::needsPenEmulation ( ) const

inline

Definition at line 292 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawTextItem().

     {
         return hasExtendedRadialGradientPen;
     }

◆ painterPathToVGPath()

VGPath QVGPaintEnginePrivate::painterPathToVGPath ( const QPainterPath & path )

Definition at line 780 of file qpaintengine_vg.cpp.

Referenced by QVGFontEngineCleaner::fontEngineDestroyed().

 {
     int count = path.elementCount();
 
     VGPath vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                                  VG_PATH_DATATYPE_F,
                                  1.0f,        // scale
                                  0.0f,        // bias
                                  count + 1,   // segmentCapacityHint
                                  count * 2,   // coordCapacityHint
                                  VG_PATH_CAPABILITY_ALL);
 
     if (count == 0)
         return vgpath;
 
     const QPainterPath::Element *elements = &(path.elementAt(0));
 
     // Sizes chosen so that drawRoundedRect() paths fit in these arrays.
     QVarLengthArray<VGfloat, 48> coords;
     QVarLengthArray<VGubyte, 20> segments;
 
     int curvePos = 0;
     QPointF temp;
 
     // Keep track of the start and end of each sub-path.  QPainterPath
     // does not have an "implicit close" flag like QVectorPath does.
     // We therefore have to detect closed paths by looking for a LineTo
     // element that connects back to the initial MoveTo element.
     qreal startx = 0.0;
     qreal starty = 0.0;
     qreal endx = 0.0;
     qreal endy = 0.0;
     bool haveStart = false;
     bool haveEnd = false;
 
     if (simpleTransform) {
         // Convert the members of the element array.
         for (int i = 0; i < count; ++i) {
             switch (elements[i].type) {
 
             case QPainterPath::MoveToElement:
             {
                 if (haveStart && haveEnd && startx == endx && starty == endy) {
                     // Implicitly close the previous sub-path.
                     segments.append(VG_CLOSE_PATH);
                 }
                 startx = elements[i].x;
                 starty = elements[i].y;
                 coords.append(startx);
                 coords.append(starty);
                 haveStart = true;
                 haveEnd = false;
                 segments.append(VG_MOVE_TO_ABS);
             }
             break;
 
             case QPainterPath::LineToElement:
             {
                 endx = elements[i].x;
                 endy = elements[i].y;
                 coords.append(endx);
                 coords.append(endy);
                 haveEnd = true;
                 segments.append(VG_LINE_TO_ABS);
             }
             break;
 
             case QPainterPath::CurveToElement:
             {
                 coords.append(elements[i].x);
                 coords.append(elements[i].y);
                 haveEnd = false;
                 curvePos = 2;
             }
             break;
 
             case QPainterPath::CurveToDataElement:
             {
                 coords.append(elements[i].x);
                 coords.append(elements[i].y);
                 haveEnd = false;
                 curvePos += 2;
                 if (curvePos == 6) {
                     curvePos = 0;
                     segments.append(VG_CUBIC_TO_ABS);
                 }
             }
             break;
 
             }
         }
     } else {
         // Convert the members of the element array after applying the
         // current transform to the path locally.
         for (int i = 0; i < count; ++i) {
             switch (elements[i].type) {
 
             case QPainterPath::MoveToElement:
             {
                 if (haveStart && haveEnd && startx == endx && starty == endy) {
                     // Implicitly close the previous sub-path.
                     segments.append(VG_CLOSE_PATH);
                 }
                 temp = transform.map(QPointF(elements[i].x, elements[i].y));
                 startx = temp.x();
                 starty = temp.y();
                 coords.append(startx);
                 coords.append(starty);
                 haveStart = true;
                 haveEnd = false;
                 segments.append(VG_MOVE_TO_ABS);
             }
             break;
 
             case QPainterPath::LineToElement:
             {
                 temp = transform.map(QPointF(elements[i].x, elements[i].y));
                 endx = temp.x();
                 endy = temp.y();
                 coords.append(endx);
                 coords.append(endy);
                 haveEnd = true;
                 segments.append(VG_LINE_TO_ABS);
             }
             break;
 
             case QPainterPath::CurveToElement:
             {
                 temp = transform.map(QPointF(elements[i].x, elements[i].y));
                 coords.append(temp.x());
                 coords.append(temp.y());
                 haveEnd = false;
                 curvePos = 2;
             }
             break;
 
             case QPainterPath::CurveToDataElement:
             {
                 temp = transform.map(QPointF(elements[i].x, elements[i].y));
                 coords.append(temp.x());
                 coords.append(temp.y());
                 haveEnd = false;
                 curvePos += 2;
                 if (curvePos == 6) {
                     curvePos = 0;
                     segments.append(VG_CUBIC_TO_ABS);
                 }
             }
             break;
 
             }
         }
     }
 
     if (haveStart && haveEnd && startx == endx && starty == endy) {
         // Implicitly close the last sub-path.
         segments.append(VG_CLOSE_PATH);
     }
 
     vgAppendPathData(vgpath, segments.count(),
                      segments.constData(), coords.constData());
 
     return vgpath;
 }

◆ roundedRectPath()

VGPath QVGPaintEnginePrivate::roundedRectPath	(	const QRectF &	rect,
		qreal	xRadius,
		qreal	yRadius,
		Qt::SizeMode	mode
	)

Definition at line 945 of file qpaintengine_vg.cpp.

 {
     static VGubyte roundedrect_types[] = {
         VG_MOVE_TO_ABS,
         VG_LINE_TO_ABS,
         VG_CUBIC_TO_ABS,
         VG_LINE_TO_ABS,
         VG_CUBIC_TO_ABS,
         VG_LINE_TO_ABS,
         VG_CUBIC_TO_ABS,
         VG_LINE_TO_ABS,
         VG_CUBIC_TO_ABS,
         VG_CLOSE_PATH
     };
 
     qreal x1 = rect.left();
     qreal x2 = rect.right();
     qreal y1 = rect.top();
     qreal y2 = rect.bottom();
 
     if (mode == Qt::RelativeSize) {
         xRadius = xRadius * rect.width() / 200.;
         yRadius = yRadius * rect.height() / 200.;
     }
 
     xRadius = qMin(xRadius, rect.width() / 2);
     yRadius = qMin(yRadius, rect.height() / 2);
 
     VGfloat pts[] = {
         x1 + xRadius, y1,                   // MoveTo
         x2 - xRadius, y1,                   // LineTo
         x2 - (1 - KAPPA) * xRadius, y1,     // CurveTo
         x2, y1 + (1 - KAPPA) * yRadius,
         x2, y1 + yRadius,
         x2, y2 - yRadius,                   // LineTo
         x2, y2 - (1 - KAPPA) * yRadius,     // CurveTo
         x2 - (1 - KAPPA) * xRadius, y2,
         x2 - xRadius, y2,
         x1 + xRadius, y2,                   // LineTo
         x1 + (1 - KAPPA) * xRadius, y2,     // CurveTo
         x1, y2 - (1 - KAPPA) * yRadius,
         x1, y2 - yRadius,
         x1, y1 + yRadius,                   // LineTo
         x1, y1 + (1 - KAPPA) * yRadius,     // CurveTo
         x1 + (1 - KAPPA) * xRadius, y1,
         x1 + xRadius, y1
     };
 
 #if !defined(QVG_NO_MODIFY_PATH)
     VGPath vgpath = roundRectPath;
     if (!vgpath) {
         vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                               VG_PATH_DATATYPE_F,
                               1.0f,        // scale
                               0.0f,        // bias
                               10,          // segmentCapacityHint
                               17 * 2,      // coordCapacityHint
                               VG_PATH_CAPABILITY_ALL);
         vgAppendPathData(vgpath, 10, roundedrect_types, pts);
         roundRectPath = vgpath;
     } else {
         vgModifyPathCoords(vgpath, 0, 9, pts);
     }
 #else
     VGPath vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                                  VG_PATH_DATATYPE_F,
                                  1.0f,        // scale
                                  0.0f,        // bias
                                  10,          // segmentCapacityHint
                                  17 * 2,      // coordCapacityHint
                                  VG_PATH_CAPABILITY_ALL);
     vgAppendPathData(vgpath, 10, roundedrect_types, pts);
 #endif
 
     return vgpath;
 }

◆ setBlendMode()

void QVGPaintEnginePrivate::setBlendMode ( VGBlendMode mode )

inline

Definition at line 341 of file qpaintengine_vg.cpp.

Referenced by QVGCompositionHelper::startCompositing().

 {
     if (blendMode != mode) {
         vgSeti(VG_BLEND_MODE, mode);
         blendMode = mode;
     }
 }

◆ setBrush()

VGPaintType QVGPaintEnginePrivate::setBrush	(	VGPaint	paint,
		const QBrush &	brush,
		VGMatrixMode	mode,
		VGPaintType	prevPaintType
	)

Definition at line 1178 of file qpaintengine_vg.cpp.

Referenced by toVGImageWithOpacitySubRect().

 {
     VGfloat values[5];
     setBrushTransform(brush, mode);
 
     // Reset the paint pattern on the brush, which will discard
     // the previous VGImage if one was set.
     if (prevType == VG_PAINT_TYPE_PATTERN || prevType == (VGPaintType)0)
         vgPaintPattern(paint, VG_INVALID_HANDLE);
 
     switch (brush.style()) {
 
     case Qt::SolidPattern: {
         // The brush is a solid color.
         QColor color(brush.color());
         values[0] = color.redF();
         values[1] = color.greenF();
         values[2] = color.blueF();
         values[3] = color.alphaF() * opacity;
         if (prevType != VG_PAINT_TYPE_COLOR)
             vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
         vgSetParameterfv(paint, VG_PAINT_COLOR, 4, values);
         return VG_PAINT_TYPE_COLOR;
     }
 
     case Qt::LinearGradientPattern: {
         // The brush is a linear gradient.
         Q_ASSERT(brush.gradient()->type() == QGradient::LinearGradient);
         const QLinearGradient *grad =
             static_cast<const QLinearGradient*>(brush.gradient());
         values[0] = grad->start().x();
         values[1] = grad->start().y();
         values[2] = grad->finalStop().x();
         values[3] = grad->finalStop().y();
         if (prevType != VG_PAINT_TYPE_LINEAR_GRADIENT)
             vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
         vgSetParameterfv(paint, VG_PAINT_LINEAR_GRADIENT, 4, values);
         setupColorRamp(grad, paint);
         return VG_PAINT_TYPE_LINEAR_GRADIENT;
     }
 
     case Qt::RadialGradientPattern: {
         // The brush is a radial gradient.
         Q_ASSERT(brush.gradient()->type() == QGradient::RadialGradient);
         const QRadialGradient *grad =
             static_cast<const QRadialGradient*>(brush.gradient());
         values[0] = grad->center().x();
         values[1] = grad->center().y();
         values[2] = grad->focalPoint().x();
         values[3] = grad->focalPoint().y();
         values[4] = grad->radius();
         if (prevType != VG_PAINT_TYPE_RADIAL_GRADIENT)
             vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
         vgSetParameterfv(paint, VG_PAINT_RADIAL_GRADIENT, 5, values);
         setupColorRamp(grad, paint);
         return VG_PAINT_TYPE_RADIAL_GRADIENT;
     }
 
     case Qt::TexturePattern: {
         // The brush is a texture specified by a QPixmap/QImage.
         QPixmapData *pd = brush.texture().pixmapData();
         if (!pd)
             break;  // null QPixmap
         VGImage vgImg;
         bool deref = false;
         if (pd->pixelType() == QPixmapData::BitmapType) {
             // Colorize bitmaps using the brush color and opacity.
             QColor color = brush.color();
             if (opacity != 1.0)
                 color.setAlphaF(color.alphaF() * opacity);
             QImage image = colorizeBitmap(*(pd->buffer()), color);
             vgImg = toVGImage(image);
             deref = true;
         } else if (opacity == 1.0) {
             if (pd->classId() == QPixmapData::OpenVGClass) {
                 QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
                 vgImg = vgpd->toVGImage();
 
                 // We don't want the pool to reclaim this image
                 // because we cannot predict when the paint object
                 // will stop using it.  Replacing the image with
                 // new data will make the paint object invalid.
                 vgpd->detachImageFromPool();
             } else {
                 vgImg = toVGImage(*(pd->buffer()));
                 deref = true;
             }
         } else if (pd->classId() == QPixmapData::OpenVGClass) {
             QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
             vgImg = vgpd->toVGImage(opacity);
             vgpd->detachImageFromPool();
         } else {
             vgImg = toVGImageWithOpacity(*(pd->buffer()), opacity);
             deref = true;
         }
         if (vgImg == VG_INVALID_HANDLE)
             break;
         if (prevType != VG_PAINT_TYPE_PATTERN)
             vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_PATTERN);
         vgSetParameteri(paint, VG_PAINT_PATTERN_TILING_MODE, VG_TILE_REPEAT);
         vgPaintPattern(paint, vgImg);
         if (deref)
             vgDestroyImage(vgImg); // Will be valid until pattern is destroyed.
         return VG_PAINT_TYPE_PATTERN;
     }
 
     case Qt::ConicalGradientPattern: {
         // Convert conical gradients into the first stop color.
         qWarning() << "QVGPaintEnginePrivate::setBrush: conical gradients are not supported by OpenVG";
         Q_ASSERT(brush.gradient()->type() == QGradient::ConicalGradient);
         const QConicalGradient *grad =
             static_cast<const QConicalGradient*>(brush.gradient());
         const QGradientStops stops = grad->stops();
         QColor color;
         if (stops.size() > 0)
             color = stops[0].second;
         values[0] = color.redF();
         values[1] = color.greenF();
         values[2] = color.blueF();
         values[3] = color.alphaF() * opacity;
         if (prevType != VG_PAINT_TYPE_COLOR)
             vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
         vgSetParameterfv(paint, VG_PAINT_COLOR, 4, values);
         return VG_PAINT_TYPE_COLOR;
     }
 
     case Qt::Dense1Pattern:
     case Qt::Dense2Pattern:
     case Qt::Dense3Pattern:
     case Qt::Dense4Pattern:
     case Qt::Dense5Pattern:
     case Qt::Dense6Pattern:
     case Qt::Dense7Pattern:
     case Qt::HorPattern:
     case Qt::VerPattern:
     case Qt::CrossPattern:
     case Qt::BDiagPattern:
     case Qt::FDiagPattern:
     case Qt::DiagCrossPattern: {
         // The brush is a traditional dotted or cross-hatched pattern brush.
         QColor color = brush.color();
         if (opacity != 1.0)
             color.setAlphaF(color.alphaF() * opacity);
         QImage image = colorizeBitmap
             (qt_imageForBrush(brush.style(), true), color);
         VGImage vgImg = toVGImage(image);
         if (prevType != VG_PAINT_TYPE_PATTERN)
             vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_PATTERN);
         vgSetParameteri(paint, VG_PAINT_PATTERN_TILING_MODE, VG_TILE_REPEAT);
         vgPaintPattern(paint, vgImg);
         vgDestroyImage(vgImg); // Will stay valid until pattern is destroyed.
         return VG_PAINT_TYPE_PATTERN;
     }
 
     default: break;
     }
     return (VGPaintType)0;
 }

◆ setBrushTransform()

void QVGPaintEnginePrivate::setBrushTransform	(	const QBrush &	brush,
		VGMatrixMode	mode
	)

Definition at line 1381 of file qpaintengine_vg.cpp.

Referenced by setBrush(), and setPenParams().

 {
     // Compute the new brush transformation matrix.
     QTransform transform(brush.transform());
     if (brushOrigin.x() != 0.0f || brushOrigin.y() != 0.0f)
         transform.translate(brushOrigin.x(), brushOrigin.y());
 
     // Bail out if the matrix is the same as last time, to avoid
     // updating the VG context state unless absolutely necessary.
     // Most applications won't have a brush transformation set,
     // which will leave the VG setting at its default of identity.
     // Always change the transform if coming out of raw VG mode.
     if (mode == VG_MATRIX_FILL_PAINT_TO_USER) {
         if (!rawVG && transform == brushTransform)
             return;
         brushTransform = transform;
     } else {
         if (!rawVG && transform == penTransform)
             return;
         penTransform = transform;
     }
 
     // Set the brush transformation matrix.
     if (mode != matrixMode) {
         vgSeti(VG_MATRIX_MODE, mode);
         matrixMode = mode;
     }
     if (transform.isIdentity()) {
         vgLoadIdentity();
     } else {
         VGfloat mat[9];
         mat[0] = transform.m11();
         mat[1] = transform.m12();
         mat[2] = transform.m13();
         mat[3] = transform.m21();
         mat[4] = transform.m22();
         mat[5] = transform.m23();
         mat[6] = transform.m31();
         mat[7] = transform.m32();
         mat[8] = transform.m33();
         vgLoadMatrix(mat);
     }
 }

◆ setFillRule()

void QVGPaintEnginePrivate::setFillRule ( VGint mode )

inline

Definition at line 349 of file qpaintengine_vg.cpp.

Referenced by QVGCompositionHelper::fillBackground().

 {
     if (fillRule != mode) {
         fillRule = mode;
         vgSeti(VG_FILL_RULE, mode);
     }
 }

◆ setImageMode()

void QVGPaintEnginePrivate::setImageMode ( VGImageMode mode )

inline

Definition at line 316 of file qpaintengine_vg.cpp.

Referenced by QVGCompositionHelper::blitWindow(), QVGPaintEngine::drawCachedGlyphs(), QVGCompositionHelper::drawCursorPixmap(), QVGPaintEngine::drawPixmapFragments(), and qt_vg_drawVGImageStencil().

 {
     if (imageMode != mode) {
         imageMode = mode;
         vgSeti(VG_IMAGE_MODE, mode);
     }
 }

◆ setImageOptions()

void QVGPaintEnginePrivate::setImageOptions ( )

Definition at line 3107 of file qpaintengine_vg.cpp.

Referenced by drawImageTiled(), and drawVGImage().

 {
     if (opacity != 1.0f && simpleTransform) {
         if (opacity != paintOpacity) {
             VGfloat values[4];
             values[0] = 1.0f;
             values[1] = 1.0f;
             values[2] = 1.0f;
             values[3] = opacity;
             vgSetParameterfv(opacityPaint, VG_PAINT_COLOR, 4, values);
             paintOpacity = opacity;
         }
         if (fillPaint != opacityPaint) {
             vgSetPaint(opacityPaint, VG_FILL_PATH);
             fillPaint = opacityPaint;
         }
         setImageMode(VG_DRAW_IMAGE_MULTIPLY);
     } else {
         setImageMode(VG_DRAW_IMAGE_NORMAL);
     }
 }

◆ setImageQuality()

void QVGPaintEnginePrivate::setImageQuality ( VGImageQuality mode )

inline

Definition at line 333 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawCachedGlyphs(), and drawImageTiled().

 {
     if (imageQuality != mode) {
         vgSeti(VG_IMAGE_QUALITY, mode);
         imageQuality = mode;
     }
 }

◆ setPenParams()

void QVGPaintEnginePrivate::setPenParams ( const QPen & pen )

Definition at line 1338 of file qpaintengine_vg.cpp.

 {
     // Note: OpenVG does not support zero-width or cosmetic pens,
     // so we have to simulate cosmetic pens by reversing the scale.
     VGfloat width = pen.widthF();
     if (width <= 0.0f)
         width = 1.0f;
     if (pen.isCosmetic()) {
         if (penScale != 1.0 && penScale != 0.0)
             width /= penScale;
     }
     vgSetf(VG_STROKE_LINE_WIDTH, width);
 
     if (pen.capStyle() == Qt::FlatCap)
         vgSetf(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
     else if (pen.capStyle() == Qt::SquareCap)
         vgSetf(VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
     else
         vgSetf(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
 
     if (pen.joinStyle() == Qt::MiterJoin) {
         vgSetf(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
         vgSetf(VG_STROKE_MITER_LIMIT, pen.miterLimit());
     } else if (pen.joinStyle() == Qt::BevelJoin) {
         vgSetf(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
     } else {
         vgSetf(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
     }
 
     if (pen.style() == Qt::SolidLine) {
         vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);
     } else {
         const QVector<qreal> dashPattern = pen.dashPattern();
         QVector<VGfloat> currentDashPattern(dashPattern.count());
         for (int i = 0; i < dashPattern.count(); ++i)
             currentDashPattern[i] = dashPattern[i] * width;
         vgSetfv(VG_STROKE_DASH_PATTERN, currentDashPattern.count(), currentDashPattern.data());
         vgSetf(VG_STROKE_DASH_PHASE, pen.dashOffset());
         vgSetf(VG_STROKE_DASH_PHASE_RESET, VG_FALSE);
     }
 }

◆ setRenderingQuality()

void QVGPaintEnginePrivate::setRenderingQuality ( VGRenderingQuality mode )

inline

Definition at line 324 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawCachedGlyphs(), and drawImageTiled().

 {
     if (renderingQuality != mode) {
         vgSeti(VG_RENDERING_QUALITY, mode);
         renderingQuality = mode;
         pathTransformSet = false; // need to tweak transform for aliased stroking
     }
 }

◆ setTransform()

void QVGPaintEnginePrivate::setTransform	(	VGMatrixMode	mode,
		const QTransform &	transform
	)

Definition at line 535 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::beginNativePainting(), QVGCompositionHelper::blitWindow(), destroy(), QVGPaintEngine::drawCachedGlyphs(), QVGCompositionHelper::drawCursorPixmap(), drawImageTiled(), QVGPaintEngine::drawPixmapFragments(), drawVGImage(), QVGCompositionHelper::fillBackground(), and qt_vg_drawVGImageStencil().

 {
     VGfloat mat[9];
     if (mode != matrixMode) {
         vgSeti(VG_MATRIX_MODE, mode);
         matrixMode = mode;
     }
     mat[0] = transform.m11();
     mat[1] = transform.m12();
     mat[2] = transform.m13();
     mat[3] = transform.m21();
     mat[4] = transform.m22();
     mat[5] = transform.m23();
     mat[6] = transform.m31();
     mat[7] = transform.m32();
     mat[8] = transform.m33();
     vgLoadMatrix(mat);
 }

◆ setupColorRamp()

void QVGPaintEnginePrivate::setupColorRamp	(	const QGradient *	grad,
		VGPaint	paint
	)

Definition at line 1425 of file qpaintengine_vg.cpp.

Referenced by setBrush().

 {
     QGradient::Spread spread = grad->spread();
     VGColorRampSpreadMode spreadMode;
     if (spread == QGradient::ReflectSpread)
         spreadMode = VG_COLOR_RAMP_SPREAD_REFLECT;
     else if (spread == QGradient::RepeatSpread)
         spreadMode = VG_COLOR_RAMP_SPREAD_REPEAT;
     else
         spreadMode = VG_COLOR_RAMP_SPREAD_PAD;
 
     const QGradientStops stops = grad->stops();
     int n = 5*stops.size();
     QVector<VGfloat> fill_stops(n);
 
     for (int i = 0; i < stops.size(); ++i ) {
         QColor col = stops[i].second;
         fill_stops[i*5] = stops[i].first;
         fill_stops[i*5 + 1] = col.redF();
         fill_stops[i*5 + 2] = col.greenF();
         fill_stops[i*5 + 3] = col.blueF();
         fill_stops[i*5 + 4] = col.alphaF() * opacity;
     }
 
     vgSetParameteri(paint, VG_PAINT_COLOR_RAMP_SPREAD_MODE, spreadMode);
     vgSetParameteri(paint, VG_PAINT_COLOR_RAMP_PREMULTIPLIED, VG_FALSE);
     vgSetParameterfv(paint, VG_PAINT_COLOR_RAMP_STOPS, n, fill_stops.data());
 }

◆ stroke()

void QVGPaintEnginePrivate::stroke	(	VGPath	path,
		const QPen &	pen
	)

Definition at line 1517 of file qpaintengine_vg.cpp.

 {
     if (pen.style() == Qt::NoPen)
         return;
     ensurePen(pen);
     ensurePathTransform();
     vgDrawPath(path, VG_STROKE_PATH);
 }

◆ systemStateChanged()

void QVGPaintEnginePrivate::systemStateChanged ( )

virtual

Reimplemented from QPaintEnginePrivate.

Definition at line 3129 of file qpaintengine_vg.cpp.

 {
     q->updateScissor();
 }

◆ updateTransform()

void QVGPaintEnginePrivate::updateTransform ( QPaintDevice * pdev )

Definition at line 556 of file qpaintengine_vg.cpp.

 {
     VGfloat devh = pdev->height();
 
     // Construct the VG transform by combining the Qt transform with
     // the following viewport transformation:
     //        | 1  0  0   |
     //        | 0 -1 devh |
     //        | 0  0  1   |
     // The full VG transform is effectively:
     //      1. Apply the user's transformation matrix.
     //      2. Flip the co-ordinate system upside down.
     QTransform viewport(1.0f, 0.0f, 0.0f,
                         0.0f, -1.0f, 0.0f,
                         0.0f, devh, 1.0f);
 
     // Compute the path transform and determine if it is projective.
     pathTransform = transform * viewport;
     bool projective = (pathTransform.m13() != 0.0f ||
                        pathTransform.m23() != 0.0f ||
                        pathTransform.m33() != 1.0f);
     if (projective) {
         // The engine cannot do projective path transforms for us,
         // so we will have to convert the co-ordinates ourselves.
         // Change the matrix to just the viewport transformation.
         pathTransform = viewport;
         simpleTransform = false;
     } else {
         simpleTransform = true;
     }
     pathTransformSet = false;
 
     // The image transform is always the full transformation,
     imageTransform = transform * viewport;
 
     // Calculate the scaling factor to use for turning cosmetic pens
     // into ordinary non-cosmetic pens.
     qt_scaleForTransform(transform, &penScale);
 }

◆ vectorPathToVGPath()

VGPath QVGPaintEnginePrivate::vectorPathToVGPath ( const QVectorPath & path )

Definition at line 596 of file qpaintengine_vg.cpp.

 {
     int count = path.elementCount();
     const qreal *points = path.points();
     const QPainterPath::ElementType *elements = path.elements();
 
     VGPath vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                                  VG_PATH_DATATYPE_F,
                                  1.0f,        // scale
                                  0.0f,        // bias
                                  count + 1,   // segmentCapacityHint
                                  count * 2,   // coordCapacityHint
                                  VG_PATH_CAPABILITY_ALL);
 
     // Size is sufficient segments for drawRoundedRect() paths.
     QVarLengthArray<VGubyte, 20> segments;
 
     if (sizeof(qreal) == sizeof(VGfloat) && elements && simpleTransform) {
         // If Qt was compiled with qreal the same size as VGfloat,
         // then convert the segment types and use the incoming
         // points array directly.
         for (int i = 0; i < count; ++i) {
             switch (elements[i]) {
 
             case QPainterPath::MoveToElement:
                 segments.append(VG_MOVE_TO_ABS); break;
 
             case QPainterPath::LineToElement:
                 segments.append(VG_LINE_TO_ABS); break;
 
             case QPainterPath::CurveToElement:
                 segments.append(VG_CUBIC_TO_ABS); break;
 
             case QPainterPath::CurveToDataElement: break;
 
             }
         }
         if (path.hasImplicitClose())
             segments.append(VG_CLOSE_PATH);
 
         vgAppendPathData(vgpath, segments.count(), segments.constData(),
                          reinterpret_cast<const VGfloat *>(points));
 
         return vgpath;
     }
 
     // Sizes chosen so that drawRoundedRect() paths fit in these arrays.
     QVarLengthArray<VGfloat, 48> coords;
 
     int curvePos = 0;
     QPointF temp;
 
     if (elements && simpleTransform) {
         // Convert the members of the element array.
         for (int i = 0; i < count; ++i) {
             switch (elements[i]) {
 
             case QPainterPath::MoveToElement:
             {
                 coords.append(points[0]);
                 coords.append(points[1]);
                 segments.append(VG_MOVE_TO_ABS);
             }
             break;
 
             case QPainterPath::LineToElement:
             {
                 coords.append(points[0]);
                 coords.append(points[1]);
                 segments.append(VG_LINE_TO_ABS);
             }
             break;
 
             case QPainterPath::CurveToElement:
             {
                 coords.append(points[0]);
                 coords.append(points[1]);
                 curvePos = 2;
             }
             break;
 
             case QPainterPath::CurveToDataElement:
             {
                 coords.append(points[0]);
                 coords.append(points[1]);
                 curvePos += 2;
                 if (curvePos == 6) {
                     curvePos = 0;
                     segments.append(VG_CUBIC_TO_ABS);
                 }
             }
             break;
 
             }
             points += 2;
         }
     } else if (elements && !simpleTransform) {
         // Convert the members of the element array after applying the
         // current transform to the path locally.
         for (int i = 0; i < count; ++i) {
             switch (elements[i]) {
 
             case QPainterPath::MoveToElement:
             {
                 temp = transform.map(QPointF(points[0], points[1]));
                 coords.append(temp.x());
                 coords.append(temp.y());
                 segments.append(VG_MOVE_TO_ABS);
             }
             break;
 
             case QPainterPath::LineToElement:
             {
                 temp = transform.map(QPointF(points[0], points[1]));
                 coords.append(temp.x());
                 coords.append(temp.y());
                 segments.append(VG_LINE_TO_ABS);
             }
             break;
 
             case QPainterPath::CurveToElement:
             {
                 temp = transform.map(QPointF(points[0], points[1]));
                 coords.append(temp.x());
                 coords.append(temp.y());
                 curvePos = 2;
             }
             break;
 
             case QPainterPath::CurveToDataElement:
             {
                 temp = transform.map(QPointF(points[0], points[1]));
                 coords.append(temp.x());
                 coords.append(temp.y());
                 curvePos += 2;
                 if (curvePos == 6) {
                     curvePos = 0;
                     segments.append(VG_CUBIC_TO_ABS);
                 }
             }
             break;
 
             }
             points += 2;
         }
     } else if (count > 0 && simpleTransform) {
         // If there is no element array, then the path is assumed
         // to be a MoveTo followed by several LineTo's.
         coords.append(points[0]);
         coords.append(points[1]);
         segments.append(VG_MOVE_TO_ABS);
         while (count > 1) {
             points += 2;
             coords.append(points[0]);
             coords.append(points[1]);
             segments.append(VG_LINE_TO_ABS);
             --count;
         }
     } else if (count > 0 && !simpleTransform) {
         // Convert a simple path, and apply the transform locally.
         temp = transform.map(QPointF(points[0], points[1]));
         coords.append(temp.x());
         coords.append(temp.y());
         segments.append(VG_MOVE_TO_ABS);
         while (count > 1) {
             points += 2;
             temp = transform.map(QPointF(points[0], points[1]));
             coords.append(temp.x());
             coords.append(temp.y());
             segments.append(VG_LINE_TO_ABS);
             --count;
         }
     }
 
     // Close the path if specified.
     if (path.hasImplicitClose())
         segments.append(VG_CLOSE_PATH);
 
     vgAppendPathData(vgpath, segments.count(),
                      segments.constData(), coords.constData());
 
     return vgpath;
 }