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

equal deleted inserted replaced

-:dee5afe5301f
+:3f74d0d4af4c
 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 glyphTransform; // Calculated VG glyph 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.
 pathTransformSet = false;
 penScale = 1.0;
 maskValid = false;
 maskIsSet = false;
+scissorMask = false;
 rawVG = false;
 scissorActive = false;
 scissorDirty = false;
 extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
 void QVGPaintEnginePrivate::updateTransform(QPaintDevice *pdev)
 {
-VGfloat devh = pdev->height() - 1;
+VGfloat devh = pdev->height();
 // Construct the VG transform by combining the Qt transform with
 // the following viewport transformation:
-//        | 1  0  0   |   | 1 0  0.5 |   | 1  0     0.5      |
+//        | 1  0  0   |
-//        | 0 -1 devh | * | 0 1 -0.5 | = | 0 -1 (0.5 + devh) |
+//        | 0 -1 devh |
-//        | 0  0  1   |   | 0 0   1  |   | 0  0      1       |
+//        | 0  0  1   |
+// The glyph transform uses a slightly different transformation:
+//        | 1  0  0       |   | 1 0  0.5 |   | 1  0     0.5      |
+//        | 0 -1 devh - 1 | * | 0 1 -0.5 | = | 0 -1 (devh - 0.5) |
+//        | 0  0  1       |   | 0 0   1  |   | 0  0      1       |
 // The full VG transform is effectively:
 //      1. Apply the user's transformation matrix.
-//      2. Translate by (0.5, -0.5) to correct for Qt and VG putting
+//      2. Translate glyphs by an extra (0.5, -0.5).
-//         the centre of the pixel at different positions.
 //      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);
+0.0f, devh, 1.0f);
+QTransform gviewport(1.0f, 0.0f, 0.0f,
-// The image transform is always the full transformation,
+0.0f, -1.0f, 0.0f,
-// because it can be projective.
+0.5f, devh - 0.5f, 1.0f);
-imageTransform = transform * viewport;
+// Compute the path transform and determine if it is projective.
-// Determine if the transformation is projective.
+pathTransform = transform * viewport;
-bool projective = (imageTransform.m13() != 0.0f ||
+glyphTransform = transform * gviewport;
-imageTransform.m23() != 0.0f ||
+bool projective = (pathTransform.m13() != 0.0f ||
-imageTransform.m33() != 1.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;
+glyphTransform = gviewport;
 simpleTransform = false;
 } else {
-pathTransform = imageTransform;
 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);
 }
 // 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) {
 vgDestroyPath(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;
 }
 vgDestroyPath(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()
 } 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)) {
 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)
 QObject::connect(ti.fontEngine, SIGNAL(destroyed()),
 d->fontEngineCleaner, SLOT(fontEngineDestroyed()));
 }
 // Set the transformation to use for drawing the current glyphs.
-QTransform glyphTransform(d->pathTransform);
+QTransform glyphTransform(d->glyphTransform);
 glyphTransform.translate(p.x(), p.y());
 #if defined(QVG_NO_IMAGE_GLYPHS)
 glyphTransform.scale(glyphCache->scaleX, glyphCache->scaleY);
 #endif
 d->setTransform(VG_MATRIX_GLYPH_USER_TO_SURFACE, glyphTransform);
 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)
 }
 }
 } else {
 // Set the path transform to the default viewport transformation.
-VGfloat devh = screenSize.height() - 1;
+VGfloat devh = screenSize.height();
 QTransform viewport(1.0f, 0.0f, 0.0f,
 0.0f, -1.0f, 0.0f,
--0.5f, devh + 0.5f, 1.0f);
+0.0f, devh, 1.0f);
 d->setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, viewport);
 // Set the brush to use to fill the background.
 d->ensureBrush(brush);
 d->setFillRule(VG_EVEN_ODD);
 if (vgpd->isValid())
 vgImage = vgpd->toVGImage();
 }
 // Set the image transformation and modes.
-VGfloat devh = screenSize.height() - 1;
+VGfloat devh = screenSize.height();
 QTransform transform(1.0f, 0.0f, 0.0f,
 0.0f, -1.0f, 0.0f,
--0.5f, devh + 0.5f, 1.0f);
+0.0f, devh, 1.0f);
 transform.translate(offset.x(), offset.y());
 d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
 d->setImageMode(VG_DRAW_IMAGE_NORMAL);
 // Draw the VGImage.

branch	RCL_3
changeset 7	3f74d0d4af4c
parent 4	3b1da2848fc7
child 13	c0432d11811c