Revert "When using complex transformations rendering goes easily off by one pixel."

This reverts commit 2acdc634ee895af4a9738c0f6c2496e388afba38.

Originally this fixed QT-3791 but it caused lots of problems in
other sites. So reverting this will fix QT-4001 but reopens
QT-3791. QT-4001 blocks Qt 4.7.1 but QT-3791 doesn't.

Task-number: QT-4001
Reviewed-by: Jason Barron
(cherry picked from commit 25ddfb434f13aa3bbc6ac303aa17dbe9582bf3f0)

1 files changed, 66 insertions, 92 deletions

diff --git a/src/openvg/qpaintengine_vg.cpp b/src/openvg/qpaintengine_vg.cpp
index 74395a2b63..f6d2435dfa 100644
--- a/src/openvg/qpaintengine_vg.cpp
+++ b/src/openvg/qpaintengine_vg.cpp
@@ -196,9 +196,7 @@ public:
 #endif
 
     QTransform transform;   // Currently active transform.
-    bool affineTransform;   // True if the transform is non-projective.
-    bool simpleTransform;   // True if the transform is simple translate
-                            // or 0, 90, 180, and 270 degree rotation
+    bool simpleTransform;   // True if the transform is simple (non-projective).
     qreal penScale;         // Pen scaling factor from "transform".
 
     QTransform pathTransform;  // Calculated VG path transformation.
@@ -379,7 +377,6 @@ void QVGPaintEnginePrivate::init()
     roundRectPath = 0;
 #endif
 
-    affineTransform = true;
     simpleTransform = true;
     pathTransformSet = false;
     penScale = 1.0;
@@ -532,59 +529,12 @@ void QVGPaintEnginePrivate::setTransform
     vgLoadMatrix(mat);
 }
 
-// Determine if a co-ordinate transform is simple enough to allow
-// rectangle-based clipping with vgMask() and rounding translation
-// to integers. Simple transforms most often result from origin translations.
-static inline bool transformIsSimple(const QTransform& transform)
-{
-    QTransform::TransformationType type = transform.type();
-    if (type == QTransform::TxNone || type == QTransform::TxTranslate) {
-        return true;
-    } else if (type == QTransform::TxScale) {
-        // Check for 0 and 180 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 (m12 == 0.0f && m21 == 0.0f) {
-            if (m11 == 1.0f && m22 == 1.0f)
-                return true; // 0 degrees
-            else if (m11 == -1.0f && m22 == -1.0f)
-                return true; // 180 degrees.
-            if(m11 == 1.0f && m22 == -1.0f)
-                return true; // 0 degrees inverted y.
-            else if(m11 == -1.0f && m22 == 1.0f)
-                return true; // 180 degrees inverted y.
-        }
-    } else if (type == QTransform::TxRotate) {
-        // Check for 90, and 270 degree rotations.
-        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 == -1.0f && m21 == -1.0f)
-                return true; // 90 degrees inverted y.
-            else if (m12 == 1.0f && m21 == 1.0f)
-                return true; // 270 degrees inverted y.
-        }
-    }
-    return false;
-}
-
 Q_DECL_IMPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
 
 void QVGPaintEnginePrivate::updateTransform(QPaintDevice *pdev)
 {
     VGfloat devh = pdev->height();
 
-    simpleTransform = transformIsSimple(transform);
-
     // Construct the VG transform by combining the Qt transform with
     // the following viewport transformation:
     //        | 1  0  0   |
@@ -607,9 +557,9 @@ void QVGPaintEnginePrivate::updateTransform(QPaintDevice *pdev)
         // so we will have to convert the co-ordinates ourselves.
         // Change the matrix to just the viewport transformation.
         pathTransform = viewport;
-        affineTransform = false;
+        simpleTransform = false;
     } else {
-        affineTransform = true;
+        simpleTransform = true;
     }
     pathTransformSet = false;
 
@@ -638,7 +588,7 @@ VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path)
     // Size is sufficient segments for drawRoundedRect() paths.
     QVarLengthArray<VGubyte, 20> segments;
 
-    if (sizeof(qreal) == sizeof(VGfloat) && elements && affineTransform) {
+    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.
@@ -673,7 +623,7 @@ VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path)
     int curvePos = 0;
     QPointF temp;
 
-    if (elements && affineTransform) {
+    if (elements && simpleTransform) {
         // Convert the members of the element array.
         for (int i = 0; i < count; ++i) {
             switch (elements[i]) {
@@ -717,7 +667,7 @@ VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path)
             }
             points += 2;
         }
-    } else if (elements && !affineTransform) {
+    } 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) {
@@ -766,7 +716,7 @@ VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path)
             }
             points += 2;
         }
-    } else if (count > 0 && affineTransform) {
+    } 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]);
@@ -779,7 +729,7 @@ VGPath QVGPaintEnginePrivate::vectorPathToVGPath(const QVectorPath& path)
             segments.append(VG_LINE_TO_ABS);
             --count;
         }
-    } else if (count > 0 && !affineTransform) {
+    } 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());
@@ -840,7 +790,7 @@ VGPath QVGPaintEnginePrivate::painterPathToVGPath(const QPainterPath& path)
     bool haveStart = false;
     bool haveEnd = false;
 
-    if (affineTransform) {
+    if (simpleTransform) {
         // Convert the members of the element array.
         for (int i = 0; i < count; ++i) {
             switch (elements[i].type) {
@@ -1615,6 +1565,36 @@ void QVGPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
     vgDestroyPath(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();
+    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)
@@ -1632,7 +1612,7 @@ void QVGPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 
     // We aren't using masking, so handle simple QRectF's only.
     if (path.shape() == QVectorPath::RectangleHint &&
-            path.elementCount() == 4 && d->simpleTransform) {
+            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();
@@ -1782,7 +1762,7 @@ void QVGPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 
     // We don't have vgRenderToMask(), so handle simple QRectF's only.
     if (path.shape() == QVectorPath::RectangleHint &&
-            path.elementCount() == 4 && d->simpleTransform) {
+            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();
@@ -1834,7 +1814,7 @@ void QVGPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
     d->dirty |= QPaintEngine::DirtyClipRegion;
 
     // If we have a non-simple transform, then use path-based clipping.
-    if (op != Qt::NoClip && !d->simpleTransform) {
+    if (op != Qt::NoClip && !clipTransformIsSimple(d->transform)) {
         QPaintEngineEx::clip(rect, op);
         return;
     }
@@ -1953,7 +1933,7 @@ void QVGPaintEngine::clip(const QRegion &region, Qt::ClipOperation op)
     d->dirty |= QPaintEngine::DirtyClipRegion;
 
     // If we have a non-simple transform, then use path-based clipping.
-    if (op != Qt::NoClip && !d->simpleTransform) {
+    if (op != Qt::NoClip && !clipTransformIsSimple(d->transform)) {
         QPaintEngineEx::clip(region, op);
         return;
     }
@@ -2530,14 +2510,14 @@ void QVGPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
 
     // Check to see if we can use vgClear() for faster filling.
     if (brush.style() == Qt::SolidPattern && brush.isOpaque() &&
-            d->simpleTransform && d->opacity == 1.0f &&
+            clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
             clearRect(rect, brush.color())) {
         return;
     }
 
 #if !defined(QVG_NO_MODIFY_PATH)
     VGfloat coords[8];
-    if (d->affineTransform) {
+    if (d->simpleTransform) {
         coords[0] = rect.x();
         coords[1] = rect.y();
         coords[2] = rect.x() + rect.width();
@@ -2572,14 +2552,14 @@ void QVGPaintEngine::fillRect(const QRectF &rect, const QColor &color)
     Q_D(QVGPaintEngine);
 
     // Check to see if we can use vgClear() for faster filling.
-    if (d->simpleTransform && d->opacity == 1.0f && color.alpha() == 255 &&
+    if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f && color.alpha() == 255 &&
             clearRect(rect, color)) {
         return;
     }
 
 #if !defined(QVG_NO_MODIFY_PATH)
     VGfloat coords[8];
-    if (d->affineTransform) {
+    if (d->simpleTransform) {
         coords[0] = rect.x();
         coords[1] = rect.y();
         coords[2] = rect.x() + rect.width();
@@ -2612,7 +2592,7 @@ void QVGPaintEngine::fillRect(const QRectF &rect, const QColor &color)
 void QVGPaintEngine::drawRoundedRect(const QRectF &rect, qreal xrad, qreal yrad, Qt::SizeMode mode)
 {
     Q_D(QVGPaintEngine);
-    if (d->affineTransform) {
+    if (d->simpleTransform) {
         QVGPainterState *s = state();
         VGPath vgpath = d->roundedRectPath(rect, xrad, yrad, mode);
         d->draw(vgpath, s->pen, s->brush);
@@ -2631,7 +2611,7 @@ void QVGPaintEngine::drawRects(const QRect *rects, int rectCount)
     QVGPainterState *s = state();
     for (int i = 0; i < rectCount; ++i, ++rects) {
         VGfloat coords[8];
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords[0] = rects->x();
             coords[1] = rects->y();
             coords[2] = rects->x() + rects->width();
@@ -2672,7 +2652,7 @@ void QVGPaintEngine::drawRects(const QRectF *rects, int rectCount)
     QVGPainterState *s = state();
     for (int i = 0; i < rectCount; ++i, ++rects) {
         VGfloat coords[8];
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords[0] = rects->x();
             coords[1] = rects->y();
             coords[2] = rects->x() + rects->width();
@@ -2710,7 +2690,7 @@ void QVGPaintEngine::drawLines(const QLine *lines, int lineCount)
     QVGPainterState *s = state();
     for (int i = 0; i < lineCount; ++i, ++lines) {
         VGfloat coords[4];
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords[0] = lines->x1();
             coords[1] = lines->y1();
             coords[2] = lines->x2();
@@ -2738,7 +2718,7 @@ void QVGPaintEngine::drawLines(const QLineF *lines, int lineCount)
     QVGPainterState *s = state();
     for (int i = 0; i < lineCount; ++i, ++lines) {
         VGfloat coords[4];
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords[0] = lines->x1();
             coords[1] = lines->y1();
             coords[2] = lines->x2();
@@ -2764,7 +2744,7 @@ void QVGPaintEngine::drawEllipse(const QRectF &r)
     // 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->affineTransform) {
+    if (d->simpleTransform) {
         QVGPainterState *s = state();
         VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                                    VG_PATH_DATATYPE_F,
@@ -2837,7 +2817,7 @@ void QVGPaintEngine::drawPoints(const QPointF *points, int pointCount)
 
     for (int i = 0; i < pointCount; ++i, ++points) {
         VGfloat coords[4];
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords[0] = points->x();
             coords[1] = points->y();
             coords[2] = coords[0];
@@ -2871,7 +2851,7 @@ void QVGPaintEngine::drawPoints(const QPoint *points, int pointCount)
 
     for (int i = 0; i < pointCount; ++i, ++points) {
         VGfloat coords[4];
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords[0] = points->x();
             coords[1] = points->y();
             coords[2] = coords[0];
@@ -2905,7 +2885,7 @@ void QVGPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonD
     QVarLengthArray<VGfloat, 16> coords;
     QVarLengthArray<VGubyte, 10> segments;
     for (int i = 0; i < pointCount; ++i, ++points) {
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords.append(points->x());
             coords.append(points->y());
         } else {
@@ -2952,7 +2932,7 @@ void QVGPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDr
     QVarLengthArray<VGfloat, 16> coords;
     QVarLengthArray<VGubyte, 10> segments;
     for (int i = 0; i < pointCount; ++i, ++points) {
-        if (d->affineTransform) {
+        if (d->simpleTransform) {
             coords.append(points->x());
             coords.append(points->y());
         } else {
@@ -2987,7 +2967,7 @@ void QVGPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDr
 
 void QVGPaintEnginePrivate::setImageOptions()
 {
-    if (opacity != 1.0f && affineTransform) {
+    if (opacity != 1.0f && simpleTransform) {
         if (opacity != paintOpacity) {
             VGfloat values[4];
             values[0] = 1.0f;
@@ -3034,10 +3014,7 @@ static void drawVGImage(QVGPaintEnginePrivate *d,
     QTransform transform(d->imageTransform);
     VGfloat scaleX = sr.width() == 0.0f ? 0.0f : r.width() / sr.width();
     VGfloat scaleY = sr.height() == 0.0f ? 0.0f : r.height() / sr.height();
-    if (d->simpleTransform)
-        transform.translate(qRound(r.x()), qRound(r.y()));
-    else
-        transform.translate(r.x(), r.y());
+    transform.translate(r.x(), r.y());
     transform.scale(scaleX, scaleY);
     d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
 
@@ -3055,10 +3032,7 @@ static void drawVGImage(QVGPaintEnginePrivate *d,
         return;
 
     QTransform transform(d->imageTransform);
-    if(d->simpleTransform)
-        transform.translate(qRound(pos.x()), qRound(pos.y()));
-    else
-        transform.translate(pos.x(), pos.y());
+    transform.translate(pos.x(), pos.y());
     d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
 
     d->setImageOptions();
@@ -3101,7 +3075,7 @@ void QVGPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF
         QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
         if (!vgpd->isValid())
             return;
-        if (d->affineTransform)
+        if (d->simpleTransform)
             drawVGImage(d, r, vgpd->toVGImage(), vgpd->size(), sr);
         else
             drawVGImage(d, r, vgpd->toVGImage(d->opacity), vgpd->size(), sr);
@@ -3120,7 +3094,7 @@ void QVGPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pm)
         QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
         if (!vgpd->isValid())
             return;
-        if (d->affineTransform)
+        if (d->simpleTransform)
             drawVGImage(d, pos, vgpd->toVGImage());
         else
             drawVGImage(d, pos, vgpd->toVGImage(d->opacity));
@@ -3135,7 +3109,7 @@ void QVGPaintEngine::drawImage
 {
     Q_D(QVGPaintEngine);
     VGImage vgImg;
-    if (d->affineTransform || d->opacity == 1.0f)
+    if (d->simpleTransform || d->opacity == 1.0f)
         vgImg = toVGImageSubRect(image, sr.toRect(), flags);
     else
         vgImg = toVGImageWithOpacitySubRect(image, d->opacity, sr.toRect());
@@ -3158,7 +3132,7 @@ void QVGPaintEngine::drawImage(const QPointF &pos, const QImage &image)
 {
     Q_D(QVGPaintEngine);
     VGImage vgImg;
-    if (d->affineTransform || d->opacity == 1.0f)
+    if (d->simpleTransform || d->opacity == 1.0f)
         vgImg = toVGImage(image);
     else
         vgImg = toVGImageWithOpacity(image, d->opacity);
@@ -3191,7 +3165,7 @@ void QVGPaintEngine::drawPixmapFragments(const QPainter::PixmapFragment *drawing
     QPixmapData *pd = pixmap.pixmapData();
     if (!pd)
         return; // null QPixmap
-    if (pd->classId() != QPixmapData::OpenVGClass || !d->affineTransform) {
+    if (pd->classId() != QPixmapData::OpenVGClass || !d->simpleTransform) {
         QPaintEngineEx::drawPixmapFragments(drawingData, dataCount, pixmap, hints);
         return;
     }
@@ -3416,7 +3390,7 @@ void QVGPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
 
     // If we are not using a simple transform, then fall back
     // to the default Qt path stroking algorithm.
-    if (!d->affineTransform) {
+    if (!d->simpleTransform) {
         QPaintEngineEx::drawTextItem(p, textItem);
         return;
     }