FCL/sf/mw/qt: comparison src/openvg/qpaintengine

equal deleted inserted replaced

-:41300fa6a67c
+:2f34d5167611
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenVG module of the Qt Toolkit.
 **
 void setTransform(VGMatrixMode mode, const QTransform& transform);
 void updateTransform(QPaintDevice *pdev);
 void draw(VGPath path, const QPen& pen, const QBrush& brush, VGint rule = VG_EVEN_ODD);
 void stroke(VGPath path, const QPen& pen);
 void fill(VGPath path, const QBrush& brush, VGint rule = VG_EVEN_ODD);
-VGPath vectorPathToVGPath(const QVectorPath& path);
+inline void releasePath(VGPath path);
-VGPath painterPathToVGPath(const QPainterPath& path);
+VGPath vectorPathToVGPath(const QVectorPath& path, bool forceNewPath = false);
+VGPath painterPathToVGPath(const QPainterPath& path, bool forceNewPath = false);
 VGPath roundedRectPath(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode);
 VGPaintType setBrush
 (VGPaint paint, const QBrush& brush, VGMatrixMode mode,
 VGPaintType prevPaintType);
 void setPenParams(const QPen& pen);
 VGPath rectPath;        // Cached path for quick drawing of rectangles.
 VGPath linePath;        // Cached path for quick drawing of lines.
 VGPath roundRectPath;   // Cached path for quick drawing of rounded rects.
 #endif
+VGPath reusablePath;    // Reusable path for vectorPathToVGPath(), etc.
 QTransform transform;   // Currently active transform.
 bool simpleTransform;   // True if the transform is simple (non-projective).
 qreal penScale;         // Pen scaling factor from "transform".
 QTransform pathTransform;  // Calculated VG path transformation.
 QTransform imageTransform; // Calculated VG image transformation.
 bool pathTransformSet;  // True if path transform set in the VG context.
 bool maskValid;         // True if vgMask() contains valid data.
 bool maskIsSet;         // True if mask would be fully set if it was valid.
+bool scissorMask;       // True if scissor is used in place of the mask.
 bool rawVG;             // True if processing a raw VG escape.
 QRect maskRect;         // Rectangle version of mask if it is simple.
 QTransform penTransform;   // Transform for the pen.
 VGMatrixMode matrixMode;    // Last matrix mode that was set.
 VGImageMode imageMode;      // Last image mode that was set.
 QRegion scissorRegion;  // Currently active scissor region.
 bool scissorActive;     // True if scissor region is active.
+bool scissorDirty;      // True if scissor is dirty after native painting.
 QPaintEngine::DirtyFlags dirty;
 QColor clearColor;      // Last clear color that was set.
 VGfloat clearOpacity;   // Opacity during the last clear.
 rectPath = 0;
 linePath = 0;
 roundRectPath = 0;
 #endif
+reusablePath = 0;
 simpleTransform = true;
 pathTransformSet = false;
 penScale = 1.0;
 maskValid = false;
 maskIsSet = false;
+scissorMask = false;
 rawVG = false;
 scissorActive = false;
+scissorDirty = false;
 dirty = 0;
 clearOpacity = 1.0f;
 2,    // segmentCapacityHint
 4,    // coordCapacityHint
 VG_PATH_CAPABILITY_ALL);
 vgAppendPathData(linePath, 2, segments, coords);
 #endif
+// This path can be reused over and over by calling vgClearPath().
+reusablePath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VG_PATH_DATATYPE_F,
+1.0f,        // scale
+0.0f,        // bias
+32 + 1,      // segmentCapacityHint
+32 * 2,      // coordCapacityHint
+VG_PATH_CAPABILITY_ALL);
 }
 void QVGPaintEnginePrivate::destroy()
 {
 if (penPaint)
 if (linePath)
 vgDestroyPath(linePath);
 if (roundRectPath)
 vgDestroyPath(roundRectPath);
 #endif
+if (reusablePath)
+vgDestroyPath(reusablePath);
 #if !defined(QVG_NO_DRAW_GLYPHS)
 QVGFontCache::Iterator it;
 for (it = fontCache.begin(); it != fontCache.end(); ++it)
 delete it.value();
 //      3. Flip the co-ordinate system upside down.
 QTransform viewport(1.0f, 0.0f, 0.0f,
 0.0f, -1.0f, 0.0f,
 0.5f, devh + 0.5f, 1.0f);
-// The image transform is always the full transformation,
+// Compute the path transform and determine if it is projective.
-// because it can be projective.
+pathTransform = transform * viewport;
-imageTransform = transform * viewport;
+bool projective = (pathTransform.m13() != 0.0f ||
+pathTransform.m23() != 0.0f ||
-// Determine if the transformation is projective.
+pathTransform.m33() != 1.0f);
-bool projective = (imageTransform.m13() != 0.0f ||
-imageTransform.m23() != 0.0f ||
-imageTransform.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 {
-pathTransform = imageTransform;
 simpleTransform = true;
 }
 pathTransformSet = false;
+// The image transform is always the full transformation,
+// because it can be projective. It also does not need the
+// (0.5, -0.5) translation because vgDrawImage() implicitly
+// adds 0.5 to each co-ordinate.
+QTransform viewport2(1.0f, 0.0f, 0.0f,
+0.0f, -1.0f, 0.0f,
+0.0f, devh, 1.0f);
+imageTransform = transform * viewport2;
 // Calculate the scaling factor to use for turning cosmetic pens
 // into ordinary non-cosmetic pens.
 qt_scaleForTransform(transform, &penScale);
 }
-VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path)
+inline void QVGPaintEnginePrivate::releasePath(VGPath path)
+{
+if (path == reusablePath)
+vgClearPath(path, VG_PATH_CAPABILITY_ALL);
+else
+vgDestroyPath(path);
+}
+VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path, bool forceNewPath)
 {
 int count = path.elementCount();
 const qreal *points = path.points();
 const QPainterPath::ElementType *elements = path.elements();
-VGPath vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VGPath vgpath;
-VG_PATH_DATATYPE_F,
+if (forceNewPath) {
-1.0f,        // scale
+vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
-0.0f,        // bias
+VG_PATH_DATATYPE_F,
-count + 1,   // segmentCapacityHint
+1.0f,        // scale
-count * 2,   // coordCapacityHint
+0.0f,        // bias
-VG_PATH_CAPABILITY_ALL);
+count + 1,   // segmentCapacityHint
+count * 2,   // coordCapacityHint
+VG_PATH_CAPABILITY_ALL);
+} else {
+vgpath = reusablePath;
+}
 // Size is sufficient segments for drawRoundedRect() paths.
 QVarLengthArray<VGubyte, 20> segments;
 if (sizeof(qreal) == sizeof(VGfloat) && elements && simpleTransform) {
 segments.constData(), coords.constData());
 return vgpath;
 }
-VGPath QVGPaintEnginePrivate::painterPathToVGPath(const QPainterPath& path)
+VGPath QVGPaintEnginePrivate::painterPathToVGPath(const QPainterPath& path, bool forceNewPath)
 {
 int count = path.elementCount();
-VGPath vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VGPath vgpath;
-VG_PATH_DATATYPE_F,
+if (forceNewPath) {
-1.0f,        // scale
+vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
-0.0f,        // bias
+VG_PATH_DATATYPE_F,
-count + 1,   // segmentCapacityHint
+1.0f,        // scale
-count * 2,   // coordCapacityHint
+0.0f,        // bias
-VG_PATH_CAPABILITY_ALL);
+count + 1,   // segmentCapacityHint
+count * 2,   // coordCapacityHint
+VG_PATH_CAPABILITY_ALL);
+} else {
+vgpath = reusablePath;
+}
 if (count == 0)
 return vgpath;
 const QPainterPath::Element *elements = &(path.elementAt(0));
 roundRectPath = vgpath;
 } else {
 vgModifyPathCoords(vgpath, 0, 9, pts);
 }
 #else
-VGPath vgpath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VGPath vgpath = reusablePath;
-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;
 }
 for (int x=0; x < width; ++x)
 target[x] = (source[x>>3] >> (x&7)) & 1 ? fg : bg;
 }
 return dest;
 }
+// defined in qpixmapdata_vg.cpp.
+const uchar *qt_vg_imageBits(const QImage& image);
 static VGImage toVGImage
 (const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor)
 {
 QImage img(image);
 img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
 format = VG_sARGB_8888_PRE;
 break;
 }
-const uchar *pixels = img.bits();
+const uchar *pixels = qt_vg_imageBits(img);
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (format, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), format, 0, 0,
 img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
 format = VG_sARGB_8888_PRE;
 break;
 }
-const uchar *pixels = img.bits() + bpp * sr.x() +
+const uchar *pixels = qt_vg_imageBits(img) + bpp * sr.x() +
 img.bytesPerLine() * sr.y();
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (format, sr.width(), sr.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 painter.begin(&img);
 painter.setOpacity(opacity);
 painter.drawImage(0, 0, image);
 painter.end();
-const uchar *pixels = img.bits();
+const uchar *pixels = qt_vg_imageBits(img);
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0,
 painter.begin(&img);
 painter.setOpacity(opacity);
 painter.drawImage(QPoint(0, 0), image, sr);
 painter.end();
-const uchar *pixels = img.bits();
+const uchar *pixels = qt_vg_imageBits(img);
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0,
 VGPath vgpath = d->vectorPathToVGPath(path);
 if (!path.hasWindingFill())
 d->draw(vgpath, s->pen, s->brush, VG_EVEN_ODD);
 else
 d->draw(vgpath, s->pen, s->brush, VG_NON_ZERO);
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 }
 void QVGPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 {
 Q_D(QVGPaintEngine);
 VGPath vgpath = d->vectorPathToVGPath(path);
 if (!path.hasWindingFill())
 d->fill(vgpath, brush, VG_EVEN_ODD);
 else
 d->fill(vgpath, brush, VG_NON_ZERO);
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 }
 void QVGPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 {
 Q_D(QVGPaintEngine);
 VGPath vgpath = d->vectorPathToVGPath(path);
 d->stroke(vgpath, pen);
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 }
 // Determine if a co-ordinate transform is simple enough to allow
 // rectangle-based clipping with vgMask().  Simple transforms most
 // often result from origin translations.
 static inline bool clipTransformIsSimple(const QTransform& transform)
 {
 QTransform::TransformationType type = transform.type();
-return (type == QTransform::TxNone || type == QTransform::TxTranslate);
+if (type == QTransform::TxNone || type == QTransform::TxTranslate)
+return true;
+if (type == QTransform::TxRotate) {
+// Check for 0, 90, 180, and 270 degree rotations.
+// (0 might happen after 4 rotations of 90 degrees).
+qreal m11 = transform.m11();
+qreal m12 = transform.m12();
+qreal m21 = transform.m21();
+qreal m22 = transform.m22();
+if (m11 == 0.0f && m22 == 0.0f) {
+if (m12 == 1.0f && m21 == -1.0f)
+return true;    // 90 degrees.
+else if (m12 == -1.0f && m21 == 1.0f)
+return true;    // 270 degrees.
+} else if (m12 == 0.0f && m21 == 0.0f) {
+if (m11 == -1.0f && m22 == -1.0f)
+return true;    // 180 degrees.
+else if (m11 == 1.0f && m22 == 1.0f)
+return true;    // 0 degrees.
+}
+}
+return false;
 }
 #if defined(QVG_SCISSOR_CLIP)
 void QVGPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 d->dirty |= QPaintEngine::DirtyClipRegion;
 if (op == Qt::NoClip) {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 return;
 }
-#if defined(QVG_NO_RENDER_TO_MASK)
 // We don't have vgRenderToMask(), so handle simple QRectF's only.
 if (path.shape() == QVectorPath::RectangleHint &&
 path.elementCount() == 4 && clipTransformIsSimple(d->transform)) {
 // Clipping region that resulted from QPainter::setClipRect(QRectF).
 // Convert it into a QRect and apply.
 const qreal *points = path.points();
 QRectF rect(points[0], points[1], points[2] - points[0],
 points[5] - points[1]);
 clip(rect.toRect(), op);
-}
+return;
-#else
+}
+#if !defined(QVG_NO_RENDER_TO_MASK)
 QPaintDevice *pdev = paintDevice();
 int width = pdev->width();
 int height = pdev->height();
 if (op == Qt::ReplaceClip) {
 vgRenderToMask(vgpath, VG_FILL_PATH, VG_INTERSECT_MASK);
 break;
 default: break;
 }
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 vgSeti(VG_MASKING, VG_TRUE);
 d->maskValid = true;
 d->maskIsSet = false;
+d->scissorMask = false;
 #endif
 }
 void QVGPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
 {
 switch (op) {
 case Qt::NoClip:
 {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 }
 break;
 // same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 // Special case: if the intersection of the system
 // clip and "r" is a single rectangle, then use the
 // scissor for clipping.  We try to avoid allocating a
 } else {
 clip = clip.intersect(r);
 if (clip.rectCount() != 1) {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 d->modifyMask(this, VG_FILL_MASK, r);
 break;
 }
 clipRect = clip.boundingRect();
 }
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = true;
 d->maskRect = clipRect;
 vgSeti(VG_MASKING, VG_FALSE);
 updateScissor();
 }
 }
 break;
 case Qt::IntersectClip:
 {
 QRect r = d->transform.mapRect(rect);
-if (d->maskIsSet && isDefaultClipRect(r)) {
+if (!d->maskValid) {
+// Mask has not been used yet, so intersect with
+// the previous scissor-based region in maskRect.
+if (d->scissorMask)
+r = r.intersect(d->maskRect);
+if (isDefaultClipRect(r)) {
+// The clip is the full window, so turn off clipping.
+d->maskIsSet = true;
+d->maskRect = QRect();
+} else {
+// Activate the scissor on a smaller maskRect.
+d->maskIsSet = false;
+d->maskRect = r;
+}
+d->scissorMask = true;
+updateScissor();
+} else if (d->maskIsSet && isDefaultClipRect(r)) {
 // Intersecting a full-window clip with a full-window
 // region is the same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 d->modifyMask(this, VG_INTERSECT_MASK, r);
 }
 }
 switch (op) {
 case Qt::NoClip:
 {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 }
 break;
 // same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 // Special case: if the intersection of the system
 // clip and the region is a single rectangle, then
 // use the scissor for clipping.
 else
 clip = clip.intersect(r);
 if (clip.rectCount() == 1) {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = true;
 d->maskRect = clip.boundingRect();
 vgSeti(VG_MASKING, VG_FALSE);
 updateScissor();
 } else {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 d->modifyMask(this, VG_FILL_MASK, r);
 }
 }
 }
 // region is the same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 d->modifyMask(this, VG_INTERSECT_MASK, r);
 }
 }
 d->dirty |= QPaintEngine::DirtyClipRegion;
 if (op == Qt::NoClip) {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 return;
 }
 vgRenderToMask(vgpath, VG_FILL_PATH, VG_INTERSECT_MASK);
 break;
 default: break;
 }
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 vgSeti(VG_MASKING, VG_TRUE);
 d->maskValid = true;
 d->maskIsSet = false;
+d->scissorMask = false;
 #else
 QPaintEngineEx::clip(path, op);
 #endif
 }
 void QVGPaintEnginePrivate::ensureMask
 (QVGPaintEngine *engine, int width, int height)
 {
+	  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);
 }
 vgSeti(VG_MASKING, VG_TRUE);
 maskValid = true;
 maskIsSet = false;
+scissorMask = false;
 }
 void QVGPaintEnginePrivate::modifyMask
 (QVGPaintEngine *engine, VGMaskOperation op, const QRect& rect)
 {
 }
 vgSeti(VG_MASKING, VG_TRUE);
 maskValid = true;
 maskIsSet = false;
+scissorMask = false;
 }
 #endif // !QVG_SCISSOR_CLIP
 void QVGPaintEngine::updateScissor()
 if (isDefaultClipRegion(region)) {
 // The scissor region is the entire drawing surface,
 // so there is no point doing any scissoring.
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 return;
 }
 } else
 #endif
 {
 #if !defined(QVG_SCISSOR_CLIP)
 // Combine the system clip with the simple mask rectangle.
-if (!d->maskRect.isNull()) {
+if (d->scissorMask) {
 if (region.isEmpty())
 region = d->maskRect;
 else
 region = region.intersect(d->maskRect);
 if (isDefaultClipRegion(region)) {
 // The scissor region is the entire drawing surface,
 // so there is no point doing any scissoring.
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 return;
 }
 } else
 #endif
 // Disable the scissor completely if the system clip is empty.
 if (region.isEmpty()) {
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 return;
 }
 }
-if (d->scissorActive && region == d->scissorRegion)
+if (d->scissorActive && region == d->scissorRegion && !d->scissorDirty)
 return;
 QVector<QRect> rects = region.rects();
 int count = rects.count();
 if (count > d->maxScissorRects)
 params[i * 4 + 3] = rects[i].height();
 }
 vgSetiv(VG_SCISSOR_RECTS, count * 4, params.data());
 vgSeti(VG_SCISSORING, VG_TRUE);
+d->scissorDirty = false;
 d->scissorActive = true;
 d->scissorRegion = region;
 }
 QRegion QVGPaintEngine::defaultClipRegion()
 d->dirty |= QPaintEngine::DirtyClipEnabled;
 if (s->clipEnabled && s->clipOperation != Qt::NoClip) {
 // Replay the entire clip stack to put the mask into the right state.
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 s->clipRegion = defaultClipRegion();
 d->replayClipOperations();
 d->transform = s->transform();
 d->updateTransform(paintDevice());
 } else {
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 }
 #endif
 }
 bool QVGPaintEngine::clearRect(const QRectF &rect, const QColor &color)
 {
 Q_D(QVGPaintEngine);
 QVGPainterState *s = state();
 if (!s->clipEnabled || s->clipOperation == Qt::NoClip) {
-// The transform will either be identity or a simple translation,
+QRect r = d->transform.mapRect(rect).toRect();
-// so do a simpler version of "r = d->transform.map(rect).toRect()".
-QRect r = QRect(qRound(rect.x() + d->transform.dx()),
-qRound(rect.y() + d->transform.dy()),
-qRound(rect.width()),
-qRound(rect.height()));
 int height = paintDevice()->height();
 if (d->clearColor != color || d->clearOpacity != s->opacity) {
 VGfloat values[4];
 values[0] = color.redF();
 values[1] = color.greenF();
 if (brush.style() == Qt::NoBrush)
 return;
 // Check to see if we can use vgClear() for faster filling.
-if (brush.style() == Qt::SolidPattern &&
+if (brush.style() == Qt::SolidPattern && brush.isOpaque() &&
 clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
 clearRect(rect, brush.color())) {
 return;
 }
 void QVGPaintEngine::fillRect(const QRectF &rect, const QColor &color)
 {
 Q_D(QVGPaintEngine);
 // Check to see if we can use vgClear() for faster filling.
-if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
+if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f && color.alpha() == 255 &&
 clearRect(rect, color)) {
 return;
 }
 #if !defined(QVG_NO_MODIFY_PATH)
 if (d->simpleTransform) {
 QVGPainterState *s = state();
 VGPath vgpath = d->roundedRectPath(rect, xrad, yrad, mode);
 d->draw(vgpath, s->pen, s->brush);
 #if defined(QVG_NO_MODIFY_PATH)
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 #endif
 } else {
 QPaintEngineEx::drawRoundedRect(rect, xrad, yrad, mode);
 }
 }
 // Based on the description of vguEllipse() in the OpenVG specification.
 // We don't use vguEllipse(), to avoid unnecessary library dependencies.
 Q_D(QVGPaintEngine);
 if (d->simpleTransform) {
 QVGPainterState *s = state();
-VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VGPath path = d->reusablePath;
-VG_PATH_DATATYPE_F,
-1.0f, // scale
-0.0f, // bias
-4,    // segmentCapacityHint
-12,   // coordCapacityHint
-VG_PATH_CAPABILITY_ALL);
 static VGubyte segments[4] = {
 VG_MOVE_TO_ABS,
 VG_SCCWARC_TO_REL,
 VG_SCCWARC_TO_REL,
 VG_CLOSE_PATH
 coords[9]  = 0.0f;
 coords[10] = r.width();
 coords[11] = 0.0f;
 vgAppendPathData(path, 4, segments, coords);
 d->draw(path, s->pen, s->brush);
-vgDestroyPath(path);
+d->releasePath(path);
 } else {
 // The projective transform version of an ellipse is difficult.
 // Generate a QVectorPath containing cubic curves and transform that.
 QPaintEngineEx::drawEllipse(r);
 }
 VGPath vgpath = d->painterPathToVGPath(path);
 if (path.fillRule() == Qt::OddEvenFill)
 d->draw(vgpath, s->pen, s->brush, VG_EVEN_ODD);
 else
 d->draw(vgpath, s->pen, s->brush, VG_NON_ZERO);
-vgDestroyPath(vgpath);
+d->releasePath(vgpath);
 }
 void QVGPaintEngine::drawPoints(const QPointF *points, int pointCount)
 {
 #if !defined(QVG_NO_MODIFY_PATH)
 void QVGPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
 {
 Q_D(QVGPaintEngine);
 QVGPainterState *s = state();
-VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VGPath path = d->reusablePath;
-VG_PATH_DATATYPE_F,
-1.0f,             // scale
-0.0f,             // bias
-pointCount + 1,   // segmentCapacityHint
-pointCount * 2,   // coordCapacityHint
-VG_PATH_CAPABILITY_ALL);
 QVarLengthArray<VGfloat, 16> coords;
 QVarLengthArray<VGubyte, 10> segments;
 for (int i = 0; i < pointCount; ++i, ++points) {
 if (d->simpleTransform) {
 coords.append(points->x());
 default:
 d->draw(path, s->pen, s->brush, VG_EVEN_ODD);
 break;
 }
-vgDestroyPath(path);
+d->releasePath(path);
 }
 void QVGPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
 {
 Q_D(QVGPaintEngine);
 QVGPainterState *s = state();
-VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+VGPath path = d->reusablePath;
-VG_PATH_DATATYPE_F,
-1.0f,             // scale
-0.0f,             // bias
-pointCount + 1,   // segmentCapacityHint
-pointCount * 2,   // coordCapacityHint
-VG_PATH_CAPABILITY_ALL);
 QVarLengthArray<VGfloat, 16> coords;
 QVarLengthArray<VGubyte, 10> segments;
 for (int i = 0; i < pointCount; ++i, ++points) {
 if (d->simpleTransform) {
 coords.append(points->x());
 default:
 d->draw(path, s->pen, s->brush, VG_EVEN_ODD);
 break;
 }
-vgDestroyPath(path);
+d->releasePath(path);
 }
 void QVGPaintEnginePrivate::setImageOptions()
 {
 if (opacity != 1.0f && simpleTransform) {
 VGImage vgImage = VG_INVALID_HANDLE;
 metrics = ti.fontEngine->boundingBox(glyph);
 if (!scaledImage.isNull()) {  // Not a space character
 if (scaledImage.format() == QImage::Format_Indexed8) {
 vgImage = vgCreateImage(VG_A_8, scaledImage.width(), scaledImage.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, scaledImage.bits(), scaledImage.bytesPerLine(), VG_A_8, 0, 0, scaledImage.width(), scaledImage.height());
+vgImageSubData(vgImage, qt_vg_imageBits(scaledImage), scaledImage.bytesPerLine(), VG_A_8, 0, 0, scaledImage.width(), scaledImage.height());
 } else if (scaledImage.format() == QImage::Format_Mono) {
 QImage img = scaledImage.convertToFormat(QImage::Format_Indexed8);
 vgImage = vgCreateImage(VG_A_8, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, img.bits(), img.bytesPerLine(), VG_A_8, 0, 0, img.width(), img.height());
+vgImageSubData(vgImage, qt_vg_imageBits(img), img.bytesPerLine(), VG_A_8, 0, 0, img.width(), img.height());
 } else {
 QImage img = scaledImage.convertToFormat(QImage::Format_ARGB32_Premultiplied);
 vgImage = vgCreateImage(VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, img.bits(), img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
+vgImageSubData(vgImage, qt_vg_imageBits(img), img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
 }
 }
 origin[0] = -metrics.x.toReal() + 0.5f;
 origin[1] = -metrics.y.toReal() + 0.5f;
 escapement[0] = metrics.xoff.toReal();
 // Calculate the path for the glyph and cache it.
 QPainterPath path;
 ti.fontEngine->getUnscaledGlyph(glyph, &path, &metrics);
 VGPath vgPath;
 if (!path.isEmpty()) {
-vgPath = d->painterPathToVGPath(path);
+vgPath = d->painterPathToVGPath(path, true);
 } else {
 // Probably a "space" character with no visible outline.
 vgPath = VG_INVALID_HANDLE;
 }
 origin[0] = 0;
 d->forceBrushChange = true;
 d->penType = (VGPaintType)0;
 d->brushType = (VGPaintType)0;
 d->clearColor = QColor();
 d->fillPaint = d->brushPaint;
+d->scissorDirty = true;
 restoreState(QPaintEngine::AllDirty);
 d->dirty = dirty;
 d->rawVG = false;
 vgSetPaint(d->penPaint, VG_STROKE_PATH);
 vgSetPaint(d->brushPaint, VG_FILL_PATH);
 if ((dirty & (QPaintEngine::DirtyClipRegion |
 QPaintEngine::DirtyClipPath |
 QPaintEngine::DirtyClipEnabled)) != 0) {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 clipEnabledChanged();
 }
 #if defined(QVG_SCISSOR_CLIP)
 (VG_sARGB_8888_PRE, img.width(), img.height(),
 VG_IMAGE_QUALITY_FASTER);
 if (vgImage == VG_INVALID_HANDLE)
 return;
 vgImageSubData
-(vgImage, img.bits() + img.bytesPerLine() * (img.height() - 1),
+(vgImage, qt_vg_imageBits(img) + img.bytesPerLine() * (img.height() - 1),
 -(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
 img.width(), img.height());
 vgDrawImage(vgImage);
 vgDestroyImage(vgImage);
 params[i * 4 + 3] = rects[i].height();
 }
 vgSetiv(VG_SCISSOR_RECTS, count * 4, params.data());
 vgSeti(VG_SCISSORING, VG_TRUE);
+d->scissorDirty = false;
 d->scissorActive = true;
 d->scissorRegion = region;
 }
 void QVGCompositionHelper::clearScissor()
 {
-if (d->scissorActive) {
+if (d->scissorActive || d->scissorDirty) {
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 }
 }
 #endif // !QVG_NO_SINGLE_CONTEXT && !QT_NO_EGL

changeset 18	2f34d5167611
parent 3	41300fa6a67c
child 19	fcece45ef507