Changeset 561 for trunk/src/gui/painting/qtransform.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/painting/qtransform.cpp (modified) (66 diffs)

trunk/src/gui/painting/qtransform.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -49 +49 @@
 #include <qmath.h>
 
+
+
 QT_BEGIN_NAMESPACE
 
-#define Q_NEAR_CLIP 0.000001
-
-
+#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)
+
+#ifdef MAP
+#  undef MAP
+#endif
 #define MAP(x, y, nx, ny) \
     do { \
@@ -77 +81 @@
             ny = affine._m12 * FX_ + affine._m22 * FY_ + affine._dy;        \
             if (t == TxProject) {                                       \
-                qreal w = 1./(m_13 * FX_ + m_23 * FY_ + m_33);              \
+                qreal w = (m_13 * FX_ + m_23 * FY_ + m_33);              \
+                if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP);     \
+                w = 1./w;                                               \
                 nx *= w;                                                \
                 ny *= w;                                                \
@@ -88 +94 @@
     \brief The QTransform class specifies 2D transformations of a coordinate system.
     \since 4.3
-    \ingroup multimedia
+    \ingroup 
 
     A transformation specifies how to translate, scale, shear, rotate
@@ -98 +104 @@
     method allows casting QTransform to QMatrix. If a perspective
     transformation has been specified on the matrix, then the
-    conversion to an affine QMatrix will cause loss of data.
+    conversion will cause loss of data.
 
     QTransform is the recommended transformation class in Qt.
@@ -122 +128 @@
     I). The inverted() function returns an inverted copy of \e this
     matrix if it is invertible (otherwise it returns the identity
-    matrix). In addition, QTransform provides the det() function
-    returning the matrix's determinant.
-
-    Finally, the QTransform class supports matrix multiplication, and
-    objects of the class can be streamed as well as compared.
+    matrix), and adjoint() returns the matrix's classical adjoint.
+    In addition, QTransform provides the determinant() function which
+    returns the matrix's determinant.
+
+    Finally, the QTransform class supports matrix multiplication, addition
+    and subtraction, and objects of the class can be streamed as well
+    as compared.
 
     \tableofcontents
@@ -188 +196 @@
     matrix, or by using the setMatrix() function later on. They can also
     be manipulated using the translate(), rotate(), scale() and
-    shear() convenience functions, The currently set values can be
+    shear() convenience functions The currently set values can be
     retrieved using the m11(), m12(), m13(), m21(), m22(), m23(),
     m31(), m32(), m33(), dx() and dy() functions.
@@ -201 +209 @@
     and \c m21. Setting these elements to values different from zero
     will twist the coordinate system. Rotation is achieved by
-    carefully setting both the shearing factors and the scaling
-    factors. Perspective transformation is achieved by carefully setting
-    both the projection factors and the scaling factors.
+    
+    
+    the scaling factors.
 
     Here's the combined transformations example using basic matrix
@@ -231 +239 @@
 
 /*!
+
+
+
+
+
     Constructs an identity matrix.
 
@@ -239 +252 @@
 */
 QTransform::QTransform()
-    : m_13(0), m_23(0), m_33(1)
+    : affine(true)
+    , m_13(0), m_23(0), m_33(1)
     , m_type(TxNone)
     , m_dirty(TxNone)
 {
-
 }
 
@@ -257 +270 @@
                        qreal h21, qreal h22, qreal h23,
                        qreal h31, qreal h32, qreal h33)
-    : affine(h11, h12, h21, h22, h31, h32),
-      m_13(h13), m_23(h23), m_33(h33)
+    : affine(h11, h12, h21, h22, h31, h32
+     m_13(h13), m_23(h23), m_33(h33)
     , m_type(TxNone)
     , m_dirty(TxProject)
 {
-
 }
 
@@ -274 +286 @@
 QTransform::QTransform(qreal h11, qreal h12, qreal h21,
                        qreal h22, qreal dx, qreal dy)
-    : affine(h11, h12, h21, h22, dx, dy),
-      m_13(0), m_23(0), m_33(1)
+    : affine(h11, h12, h21, h22, dx, dy
+     m_13(0), m_23(0), m_33(1)
     , m_type(TxNone)
     , m_dirty(TxShear)
 {
-
 }
 
@@ -290 +301 @@
  */
 QTransform::QTransform(const QMatrix &mtx)
-    : affine(mtx),
+    : affine(mtx),
       m_13(0), m_23(0), m_33(1)
     , m_type(TxNone)
     , m_dirty(TxShear)
 {
-
 }
 
@@ -318 +328 @@
     return QTransform(h11, h12, h13,
                       h21, h22, h23,
-                      h31, h32, h33);
+                      h31, h32, h33);
 }
 
@@ -328 +338 @@
     QTransform t(affine._m11, affine._m21, affine._dx,
                  affine._m12, affine._m22, affine._dy,
-                 m_13, m_23, m_33);
+                 m_13, m_23, m_33);
     t.m_type = m_type;
     t.m_dirty = m_dirty;
@@ -346 +356 @@
 QTransform QTransform::inverted(bool *invertible) const
 {
-    QTransform invert;
+    QTransform invert;
     bool inv = true;
-    qreal det;
-
-    switch(type()) {
+
+    switch(inline_type()) {
     case TxNone:
         break;
@@ -358 +367 @@
         break;
     case TxScale:
-        inv = !qFuzzyCompare(affine._m11 + 1, 1);
-        inv &= !qFuzzyCompare(affine._m22 + 1, 1);
+        inv = !qFuzzy1);
+        inv &= !qFuzzy);
         if (inv) {
-            invert.affine._m11 = 1 / affine._m11;
-            invert.affine._m22 = 1 / affine._m22;
+            invert.affine._m11 = 1 / affine._m11;
+            invert.affine._m22 = 1 / affine._m22;
             invert.affine._dx = -affine._dx * invert.affine._m11;
             invert.affine._dy = -affine._dy * invert.affine._m22;
@@ -373 +382 @@
     default:
         // general case
-        det = determinant();
-        inv = !qFuzzyCompare(det + 1, 1);
+        det = determinant();
+        inv = !qFuzzy);
         if (inv)
             invert = adjoint() / det;
@@ -398 +407 @@
     \sa setMatrix()
 */
-QTransform & QTransform::translate(qreal dx, qreal dy)
+QTransform &QTransform::translate(qreal dx, qreal dy)
 {
     if (dx == 0 && dy == 0)
         return *this;
 
-    switch(type()) {
+    switch(type()) {
     case TxNone:
         affine._dx = dx;
@@ -425 +434 @@
         break;
     }
-    m_dirty |= TxTranslate;
+    if (m_dirty < TxTranslate)
+        m_dirty = TxTranslate;
     return *this;
 }
@@ -438 +448 @@
 QTransform QTransform::fromTranslate(qreal dx, qreal dy)
 {
-    QTransform transform(1, 0, 0, 1, dx, dy);
+    QTransform transform(1, 0, 0, );
     if (dx == 0 && dy == 0)
-        transform.m_dirty = TxNone;
+        transform.m_ = TxNone;
     else
-        transform.m_dirty = TxTranslate;
+        transform.m_type = TxTranslate;
+    transform.m_dirty = TxNone;
     return transform;
 }
@@ -457 +468 @@
         return *this;
 
-    switch(type()) {
+    switch(type()) {
     case TxNone:
     case TxTranslate:
@@ -477 +488 @@
         break;
     }
-    m_dirty |= TxScale;
+    if (m_dirty < TxScale)
+        m_dirty = TxScale;
     return *this;
 }
@@ -490 +502 @@
 QTransform QTransform::fromScale(qreal sx, qreal sy)
 {
-    QTransform transform(sx, 0, 0, sy, 0, 0);
-    if (sx == 1 && sy == 1)
-        transform.m_dirty = TxNone;
+    QTransform transform(sx, 0, 0, );
+    if (sx == 1)
+        transform.m_ = TxNone;
     else
-        transform.m_dirty = TxScale;
+        transform.m_type = TxScale;
+    transform.m_dirty = TxNone;
     return transform;
 }
@@ -506 +519 @@
 QTransform & QTransform::shear(qreal sh, qreal sv)
 {
-    switch(type()) {
+    if (sh == 0 && sv == 0)
+        return *this;
+
+    switch(inline_type()) {
     case TxNone:
     case TxTranslate:
@@ -534 +550 @@
     }
     }
-    m_dirty |= TxShear;
+    if (m_dirty < TxShear)
+        m_dirty = TxShear;
     return *this;
 }
@@ -575 +592 @@
 
     if (axis == Qt::ZAxis) {
-        switch(type()) {
+        switch(type()) {
         case TxNone:
         case TxTranslate:
@@ -610 +627 @@
         }
         }
-        m_dirty |= TxRotate;
+        if (m_dirty < TxRotate)
+            m_dirty = TxRotate;
     } else {
         QTransform result;
@@ -647 +665 @@
 
     if (axis == Qt::ZAxis) {
-        switch(type()) {
+        switch(type()) {
         case TxNone:
         case TxTranslate:
@@ -682 +700 @@
         }
         }
-        m_dirty |= TxRotate;
+        if (m_dirty < TxRotate)
+            m_dirty = TxRotate;
     } else {
         QTransform result;
@@ -705 +724 @@
 bool QTransform::operator==(const QTransform &o) const
 {
-#define qFZ qFuzzyCompare
-    return qFZ(affine._m11, o.affine._m11) &&  qFZ(affine._m12, o.affine._m12) &&  qFZ(m_13, o.m_13)
-        && qFZ(affine._m21, o.affine._m21) &&  qFZ(affine._m22, o.affine._m22) &&  qFZ(m_23, o.m_23)
-        && qFZ(affine._dx, o.affine._dx) &&  qFZ(affine._dy, o.affine._dy) &&  qFZ(m_33, o.m_33);
-#undef qFZ
+    return affine._m11 == o.affine._m11 &&
+           affine._m12 == o.affine._m12 &&
+           affine._m21 == o.affine._m21 &&
+           affine._m22 == o.affine._m22 &&
+           affine._dx == o.affine._dx &&
+           affine._dy == o.affine._dy &&
+           m_13 == o.m_13 &&
+           m_23 == o.m_23 &&
+           m_33 == o.m_33;
 }
 
@@ -731 +754 @@
 QTransform & QTransform::operator*=(const QTransform &o)
 {
-    const TransformationType otherType = o.type();
+    const TransformationType otherType = o.type();
     if (otherType == TxNone)
         return *this;
 
-    const TransformationType thisType = type();
+    const TransformationType thisType = type();
     if (thisType == TxNone)
         return operator=(o);
@@ -813 +836 @@
 QTransform QTransform::operator*(const QTransform &m) const
 {
-    QTransform result = *this;
-    result *= m;
-    return result;
+    const TransformationType otherType = m.inline_type();
+    if (otherType == TxNone)
+        return *this;
+
+    const TransformationType thisType = inline_type();
+    if (thisType == TxNone)
+        return m;
+
+    QTransform t(true);
+    TransformationType type = qMax(thisType, otherType);
+    switch(type) {
+    case TxNone:
+        break;
+    case TxTranslate:
+        t.affine._dx = affine._dx + m.affine._dx;
+        t.affine._dy += affine._dy + m.affine._dy;
+        break;
+    case TxScale:
+    {
+        qreal m11 = affine._m11*m.affine._m11;
+        qreal m22 = affine._m22*m.affine._m22;
+
+        qreal m31 = affine._dx*m.affine._m11 + m.affine._dx;
+        qreal m32 = affine._dy*m.affine._m22 + m.affine._dy;
+
+        t.affine._m11 = m11;
+        t.affine._m22 = m22;
+        t.affine._dx = m31; t.affine._dy = m32;
+        break;
+    }
+    case TxRotate:
+    case TxShear:
+    {
+        qreal m11 = affine._m11*m.affine._m11 + affine._m12*m.affine._m21;
+        qreal m12 = affine._m11*m.affine._m12 + affine._m12*m.affine._m22;
+
+        qreal m21 = affine._m21*m.affine._m11 + affine._m22*m.affine._m21;
+        qreal m22 = affine._m21*m.affine._m12 + affine._m22*m.affine._m22;
+
+        qreal m31 = affine._dx*m.affine._m11 + affine._dy*m.affine._m21 + m.affine._dx;
+        qreal m32 = affine._dx*m.affine._m12 + affine._dy*m.affine._m22 + m.affine._dy;
+
+        t.affine._m11 = m11; t.affine._m12 = m12;
+        t.affine._m21 = m21; t.affine._m22 = m22;
+        t.affine._dx = m31; t.affine._dy = m32;
+        break;
+    }
+    case TxProject:
+    {
+        qreal m11 = affine._m11*m.affine._m11 + affine._m12*m.affine._m21 + m_13*m.affine._dx;
+        qreal m12 = affine._m11*m.affine._m12 + affine._m12*m.affine._m22 + m_13*m.affine._dy;
+        qreal m13 = affine._m11*m.m_13 + affine._m12*m.m_23 + m_13*m.m_33;
+
+        qreal m21 = affine._m21*m.affine._m11 + affine._m22*m.affine._m21 + m_23*m.affine._dx;
+        qreal m22 = affine._m21*m.affine._m12 + affine._m22*m.affine._m22 + m_23*m.affine._dy;
+        qreal m23 = affine._m21*m.m_13 + affine._m22*m.m_23 + m_23*m.m_33;
+
+        qreal m31 = affine._dx*m.affine._m11 + affine._dy*m.affine._m21 + m_33*m.affine._dx;
+        qreal m32 = affine._dx*m.affine._m12 + affine._dy*m.affine._m22 + m_33*m.affine._dy;
+        qreal m33 = affine._dx*m.m_13 + affine._dy*m.m_23 + m_33*m.m_33;
+
+        t.affine._m11 = m11; t.affine._m12 = m12; t.m_13 = m13;
+        t.affine._m21 = m21; t.affine._m22 = m22; t.m_23 = m23;
+        t.affine._dx = m31; t.affine._dy = m32; t.m_33 = m33;
+    }
+    }
+
+    t.m_dirty = type;
+    t.m_type = type;
+
+    return t;
 }
 
@@ -872 +963 @@
 /*!
     Resets the matrix to an identity matrix, i.e. all elements are set
-    to zero, except \c m11 and \c m22 (specifying the scale) which are
-    set to 1.
+    to zero, except \c m11 and \c m22 (specifying the scale) 
+    set to 1.
 
     \sa QTransform(), isIdentity(), {QTransform#Basic Matrix
@@ -957 +1048 @@
                   << " 32=" << m.m32()
                   << " 33=" << m.m33()
-                  << ")";
+                  << ;
     return dbg.space();
 }
@@ -977 +1068 @@
     qreal x = 0, y = 0;
 
-    TransformationType t = type();
+    TransformationType t = type();
     switch(t) {
     case TxNone:
@@ -1028 +1119 @@
     qreal x = 0, y = 0;
 
-    TransformationType t = type();
+    TransformationType t = type();
     switch(t) {
     case TxNone:
@@ -1099 +1190 @@
     qreal x1 = 0, y1 = 0, x2 = 0, y2 = 0;
 
-    TransformationType t = type();
+    TransformationType t = type();
     switch(t) {
     case TxNone:
@@ -1158 +1249 @@
     qreal x1 = 0, y1 = 0, x2 = 0, y2 = 0;
 
-    TransformationType t = type();
+    TransformationType t = type();
     switch(t) {
     case TxNone:
@@ -1246 +1337 @@
 QPolygonF QTransform::map(const QPolygonF &a) const
 {
-    TransformationType t = type();
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return a.translated(affine._dx, affine._dy);
+
     if (t >= QTransform::TxProject)
         return mapProjective(*this, a);
@@ -1273 +1367 @@
 QPolygon QTransform::map(const QPolygon &a) const
 {
-    TransformationType t = type();
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return a.translated(qRound(affine._dx), qRound(affine._dy));
+
     if (t >= QTransform::TxProject)
         return mapProjective(*this, QPolygonF(a)).toPolygon();
@@ -1315 +1412 @@
 QRegion QTransform::map(const QRegion &r) const
 {
-    TransformationType t = type();
+    TransformationType t = type();
     if (t == TxNone)
         return r;
+
     if (t == TxTranslate) {
         QRegion copy(r);
@@ -1324 +1422 @@
     }
 
+
+
+
     QPainterPath p = map(qt_regionToPath(r));
     return p.toFillPolygon(QTransform()).toPolygon();
@@ -1338 +1439 @@
 
     const QPointF toPoint() const {
-        qreal iw = 1 / w;
+        qreal iw = 1 / w;
         return QPointF(x * iw, y * iw);
     }
@@ -1352 +1453 @@
 }
 
-static inline bool lineTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, bool needsMoveTo)
+static inline bool lineTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b,
+                                  bool needsMoveTo, bool needsLineTo = true)
 {
     QHomogeneousCoordinate ha = mapHomogeneous(transform, a);
@@ -1385 +1487 @@
         path.moveTo(ha.toPoint());
 
-    path.lineTo(hb.toPoint());
+    if (needsLineTo)
+        path.lineTo(hb.toPoint());
 
     return true;
@@ -1392 +1495 @@
 static inline bool cubicTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, bool needsMoveTo)
 {
-    const QHomogeneousCoordinate ha = mapHomogeneous(transform, a);
-    const QHomogeneousCoordinate hb = mapHomogeneous(transform, b);
-    const QHomogeneousCoordinate hc = mapHomogeneous(transform, c);
-    const QHomogeneousCoordinate hd = mapHomogeneous(transform, d);
-
-    if (ha.w < Q_NEAR_CLIP && hb.w < Q_NEAR_CLIP && hc.w < Q_NEAR_CLIP && hd.w < Q_NEAR_CLIP)
-        return false;
-
-    if (ha.w >= Q_NEAR_CLIP && hb.w >= Q_NEAR_CLIP && hc.w >= Q_NEAR_CLIP && hd.w >= Q_NEAR_CLIP) {
-        if (needsMoveTo)
-            path.moveTo(ha.toPoint());
-
-        path.cubicTo(hb.toPoint(), hc.toPoint(), hd.toPoint());
-        return true;
-    }
-
-    if (lineTo_clipped(path, transform, a, b, needsMoveTo))
-            needsMoveTo = false;
-    if (lineTo_clipped(path, transform, b, c, needsMoveTo))
-            needsMoveTo = false;
-    if (lineTo_clipped(path, transform, c, d, needsMoveTo))
+    // Convert projective xformed curves to line
+    // segments so they can be transformed more accurately
+    QPolygonF segment = QBezier::fromPoints(a, b, c, d).toPolygon();
+
+    for (int i = 0; i < segment.size() - 1; ++i)
+        if (lineTo_clipped(path, transform, segment.at(i), segment.at(i+1), needsMoveTo))
             needsMoveTo = false;
 
@@ -1452 +1540 @@
 
     if (path.elementCount() > 0 && lastMoveTo != last)
-        lineTo_clipped(result, transform, last, lastMoveTo, needsMoveTo);
-
+        lineTo_clipped(result, transform, last, lastMoveTo, needsMoveTo, false);
+
+    result.setFillRule(path.fillRule());
     return result;
 }
@@ -1476 +1565 @@
 QPainterPath QTransform::map(const QPainterPath &path) const
 {
-    TransformationType t = type();
+    TransformationType t = type();
     if (t == TxNone || path.isEmpty())
         return path;
@@ -1484 +1573 @@
 
     QPainterPath copy = path;
-    copy.detach();
 
     if (t == TxTranslate) {
-        for (int i=0; i<path.elementCount(); ++i) {
-            QPainterPath::Element &e = copy.d_ptr->elements[i];
-            e.x += affine._dx;
-            e.y += affine._dy;
-        }
+        copy.translate(affine._dx, affine._dy);
     } else {
+
         // Full xform
         for (int i=0; i<path.elementCount(); ++i) {
@@ -1525 +1610 @@
 QPolygon QTransform::mapToPolygon(const QRect &rect) const
 {
-    TransformationType t = type();
+    TransformationType t = type();
 
     QPolygon a(4);
@@ -1679 +1764 @@
     \a m12, \a m13 \a m21, \a m22, \a m23 \a m31, \a m32 and
     \a m33. Note that this function replaces the previous values.
-    QMatrix provides the translate(), rotate(), scale() and shear()
+    Q provides the translate(), rotate(), scale() and shear()
     convenience functions to manipulate the various matrix elements
     based on the currently defined coordinate system.
@@ -1697 +1782 @@
 }
 
+
+
+
+
+
+
+
+
 QRect QTransform::mapRect(const QRect &rect) const
 {
-    TransformationType t = type();
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return rect.translated(qRound(affine._dx), qRound(affine._dy));
+
     if (t <= TxScale) {
         int x = qRound(affine._m11*rect.x() + affine._dx);
@@ -1714 +1810 @@
         }
         return QRect(x, y, w, h);
-    } else if (t < TxProject) {
+    } else if (t < TxProject) {
         // see mapToPolygon for explanations of the algorithm.
-        qreal x0 = 0, y0 = 0;
-        qreal x, y;
-        MAP(rect.left(), rect.top(), x0, y0);
-        qreal xmin = x0;
-        qreal ymin = y0;
-        qreal xmax = x0;
-        qreal ymax = y0;
+        qreal x = 0, y = 0;
+        MAP(rect.left(), rect.top(), x, y);
+        qreal xmin = x;
+        qreal ymin = y;
+        qreal xmax = x;
+        qreal ymax = y;
         MAP(rect.right() + 1, rect.top(), x, y);
         xmin = qMin(xmin, x);
@@ -1767 +1862 @@
 QRectF QTransform::mapRect(const QRectF &rect) const
 {
-    TransformationType t = type();
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return rect.translated(affine._dx, affine._dy);
+
     if (t <= TxScale) {
         qreal x = affine._m11*rect.x() + affine._dx;
@@ -1782 +1880 @@
         }
         return QRectF(x, y, w, h);
-    } else if (t < TxProject) {
-        qreal x0 = 0, y0 = 0;
-        qreal x, y;
-        MAP(rect.x(), rect.y(), x0, y0);
-        qreal xmin = x0;
-        qreal ymin = y0;
-        qreal xmax = x0;
-        qreal ymax = y0;
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
+        qreal x = 0, y = 0;
+        MAP(rect.x(), rect.y(), x, y);
+        qreal xmin = x;
+        qreal ymin = y;
+        qreal xmax = x;
+        qreal ymax = y;
         MAP(rect.x() + rect.width(), rect.y(), x, y);
         xmin = qMin(xmin, x);
@@ -1839 +1936 @@
 void QTransform::map(qreal x, qreal y, qreal *tx, qreal *ty) const
 {
-    TransformationType t = type();
+    TransformationType t = type();
     MAP(x, y, *tx, *ty);
 }
@@ -1853 +1950 @@
 void QTransform::map(int x, int y, int *tx, int *ty) const
 {
-    TransformationType t = type();
+    TransformationType t = type();
     qreal fx = 0, fy = 0;
     MAP(x, y, fx, fy);
@@ -1861 +1958 @@
 
 /*!
-  Returns the QTransform cast to a QMatrix.
- */
+  Returns the QTransform as an affine matrix.
+
+  \warning If a perspective transformation has been specified,
+  then the conversion will cause loss of data.
+*/
 const QMatrix &QTransform::toAffine() const
 {
@@ -1882 +1982 @@
 QTransform::TransformationType QTransform::type() const
 {
-    if (m_dirty >= m_type) {
-        if (m_dirty > TxShear && (!qFuzzyCompare(m_13 + 1, 1) || !qFuzzyCompare(m_23 + 1, 1)))
+    if(m_dirty == TxNone || m_dirty < m_type)
+        return static_cast<TransformationType>(m_type);
+
+    switch (static_cast<TransformationType>(m_dirty)) {
+    case TxProject:
+        if (!qFuzzyIsNull(m_13) || !qFuzzyIsNull(m_23) || !qFuzzyIsNull(m_33 - 1)) {
              m_type = TxProject;
-        else if (m_dirty > TxScale && (!qFuzzyCompare(affine._m12 + 1, 1) || !qFuzzyCompare(affine._m21 + 1, 1))) {
+             break;
+         }
+    case TxShear:
+    case TxRotate:
+        if (!qFuzzyIsNull(affine._m12) || !qFuzzyIsNull(affine._m21)) {
             const qreal dot = affine._m11 * affine._m12 + affine._m21 * affine._m22;
-            if (qFuzzyCompare(dot + 1, 1))
+            if (qFuzzy))
                 m_type = TxRotate;
             else
                 m_type = TxShear;
-        } else if (m_dirty > TxTranslate && (!qFuzzyCompare(affine._m11, 1) || !qFuzzyCompare(affine._m22, 1) || !qFuzzyCompare(m_33, 1)))
+            break;
+        }
+    case TxScale:
+        if (!qFuzzyIsNull(affine._m11 - 1) || !qFuzzyIsNull(affine._m22 - 1)) {
             m_type = TxScale;
-        else if (m_dirty > TxNone && (!qFuzzyCompare(affine._dx + 1, 1) || !qFuzzyCompare(affine._dy + 1, 1)))
+            break;
+        }
+    case TxTranslate:
+        if (!qFuzzyIsNull(affine._dx) || !qFuzzyIsNull(affine._dy)) {
             m_type = TxTranslate;
-        else
-            m_type = TxNone;
-
-        m_dirty = TxNone;
-    }
-
+            break;
+        }
+    case TxNone:
+        m_type = TxNone;
+        break;
+    }
+
+    m_dirty = TxNone;
     return static_cast<TransformationType>(m_type);
 }
@@ -1924 +2040 @@
 /*!
     \fn qreal QTransform::det() const
-
-    Returns the matrix's determinant.
+    \obsolete
+
+    Returns the matrix's determinant. Use determinant() instead.
 */
 
@@ -2078 +2195 @@
     \sa reset()
 */
+
+
+
+
+
+
+
+
+
+
+
 
 // returns true if the transform is uniformly scaling
@@ -2087 +2215 @@
     const QTransform::TransformationType type = transform.type();
     if (type <= QTransform::TxTranslate) {
-        *scale = 1;
+        if (scale)
+            *scale = 1;
         return true;
     } else if (type == QTransform::TxScale) {
         const qreal xScale = qAbs(transform.m11());
         const qreal yScale = qAbs(transform.m22());
-        *scale = qMax(xScale, yScale);
+        if (scale)
+            *scale = qMax(xScale, yScale);
         return qFuzzyCompare(xScale, yScale);
     }
@@ -2100 +2230 @@
     const qreal yScale = transform.m12() * transform.m12()
                          + transform.m22() * transform.m22();
-    *scale = qSqrt(qMax(xScale, yScale));
+    if (scale)
+        *scale = qSqrt(qMax(xScale, yScale));
     return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
 }