Changeset 846 for trunk/src/gui/painting/qstroker.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/painting/qstroker.cpp (modified) (17 diffs)

trunk/src/gui/painting/qstroker.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -121 +121 @@
 {
 public:
-    QSubpathFlatIterator(const QDataBuffer<QStrokerOps::Element> *path)
-        : m_path(path), m_pos(0), m_curve_index(-1) { }
+    QSubpathFlatIterator(const QDataBuffer<QStrokerOps::Element> *path, qreal threshold)
+        : m_path(path), m_pos(0), m_curve_index(-1), m_curve_threshold(threshold) { }
 
     inline bool hasNext() const { return m_curve_index >= 0 || m_pos < m_path->size(); }
@@ -153 +153 @@
                                                   qt_fixed_to_real(m_path->at(m_pos+1).y)),
                                           QPointF(qt_fixed_to_real(m_path->at(m_pos+2).x),
-                                                  qt_fixed_to_real(m_path->at(m_pos+2).y))).toPolygon();
+                                                  qt_fixed_to_real(m_path->at(m_pos+2).y))).toPolygon(m_curve_threshold);
             m_curve_index = 1;
             e.type = QPainterPath::LineToElement;
@@ -170 +170 @@
     QPolygonF m_curve;
     int m_curve_index;
+    qreal m_curve_threshold;
 };
 
@@ -188 +189 @@
 
 QStrokerOps::QStrokerOps()
-    : m_customData(0), m_moveTo(0), m_lineTo(0), m_cubicTo(0)
+    : m_elements(0)
+    , m_curveThreshold(qt_real_to_fixed(0.25))
+    , m_dashThreshold(qt_real_to_fixed(0.25))
+    , m_customData(0)
+    , m_moveTo(0)
+    , m_lineTo(0)
+    , m_cubicTo(0)
 {
 }
@@ -195 +202 @@
 {
 }
-
 
 /*!
@@ -239 +245 @@
         return;
 
+    setCurveThresholdFromTransform(QTransform());
     begin(customData);
     int count = path.elementCount();
@@ -309 +316 @@
     if (!pointCount)
         return;
+
+    setCurveThresholdFromTransform(QTransform());
     begin(data);
     if (matrix.isIdentity()) {
@@ -349 +358 @@
     }
 
+    setCurveThresholdFromTransform(QTransform());
     begin(data);
     moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y()));
@@ -367 +377 @@
     m_strokeWidth = qt_real_to_fixed(1);
     m_miterLimit = qt_real_to_fixed(2);
-    m_curveThreshold = qt_real_to_fixed(0.25);
 }
 
 QStroker::~QStroker()
 {
-
 }
 
@@ -603 +611 @@
             QLineF miterLine(QPointF(qt_fixed_to_real(focal_x),
                                      qt_fixed_to_real(focal_y)), isect);
-            if (miterLine.length() > qt_fixed_to_real(m_strokeWidth * m_miterLimit) / 2) {
+            if (type == QLineF::NoIntersection || miterLine.length() > qt_fixed_to_real(m_strokeWidth * m_miterLimit) / 2) {
                 emitLineTo(qt_real_to_fixed(nextLine.x1()),
                            qt_real_to_fixed(nextLine.y1()));
@@ -1044 +1052 @@
 }
 
+static inline bool lineRectIntersectsRect(qfixed2d p1, qfixed2d p2, const qfixed2d &tl, const qfixed2d &br)
+{
+    return ((p1.x > tl.x || p2.x > tl.x) && (p1.x < br.x || p2.x < br.x)
+        && (p1.y > tl.y || p2.y > tl.y) && (p1.y < br.y || p2.y < br.y));
+}
+
+// If the line intersects the rectangle, this function will return true.
+static bool lineIntersectsRect(qfixed2d p1, qfixed2d p2, const qfixed2d &tl, const qfixed2d &br)
+{
+    if (!lineRectIntersectsRect(p1, p2, tl, br))
+        return false;
+    if (p1.x == p2.x || p1.y == p2.y)
+        return true;
+
+    if (p1.y > p2.y)
+        qSwap(p1, p2); // make p1 above p2
+    qfixed2d u;
+    qfixed2d v;
+    qfixed2d w = {p2.x - p1.x, p2.y - p1.y};
+    if (p1.x < p2.x) {
+        // backslash
+        u.x = tl.x - p1.x; u.y = br.y - p1.y;
+        v.x = br.x - p1.x; v.y = tl.y - p1.y;
+    } else {
+        // slash
+        u.x = tl.x - p1.x; u.y = tl.y - p1.y;
+        v.x = br.x - p1.x; v.y = br.y - p1.y;
+    }
+#if defined(QFIXED_IS_26_6) || defined(QFIXED_IS_16_16)
+    qint64 val1 = qint64(u.x) * qint64(w.y) - qint64(u.y) * qint64(w.x);
+    qint64 val2 = qint64(v.x) * qint64(w.y) - qint64(v.y) * qint64(w.x);
+    return (val1 < 0 && val2 > 0) || (val1 > 0 && val2 < 0);
+#elif defined(QFIXED_IS_32_32)
+    // Cannot do proper test because it may overflow.
+    return true;
+#else
+    qreal val1 = u.x * w.y - u.y * w.x;
+    qreal val2 = v.x * w.y - v.y * w.x;
+    return (val1 < 0 && val2 > 0) || (val1 > 0 && val2 < 0);
+#endif
+}
 
 void QDashStroker::processCurrentSubpath()
@@ -1068 +1117 @@
         return;
 
+    qreal invSumLength = qreal(1) / sumLength;
+
     Q_ASSERT(dashCount > 0);
 
-    dashCount = (dashCount / 2) * 2; // Round down to even number
+    dashCount = dashCount & -2; // Round down to even number
 
     int idash = 0; // Index to current dash
@@ -1078 +1129 @@
 
     // make sure doffset is in range [0..sumLength)
-    doffset -= qFloor(doffset / sumLength) * sumLength;
+    doffset -= qFloor(doffset * invSumLength) * sumLength;
 
     while (doffset >= dashes[idash]) {
         doffset -= dashes[idash];
-        idash = (idash + 1) % dashCount;
+        if (++idash >= dashCount)
+            idash = 0;
     }
 
@@ -1092 +1144 @@
     QPainterPath dashPath;
 
-    QSubpathFlatIterator it(&m_elements);
+    QSubpathFlatIterator it(&m_elements, m_dashThreshold);
     qfixed2d prev = it.next();
 
@@ -1120 +1172 @@
 
         bool done = pos >= estop;
+
+        if (clipping) {
+            // Check if the entire line can be clipped away.
+            if (!lineIntersectsRect(prev, e, clip_tl, clip_br)) {
+                // Cut away full dash sequences.
+                elen -= qFloor(elen * invSumLength) * sumLength;
+                // Update dash offset.
+                while (!done) {
+                    qreal dpos = pos + dashes[idash] - doffset - estart;
+
+                    Q_ASSERT(dpos >= 0);
+
+                    if (dpos > elen) { // dash extends this line
+                        doffset = dashes[idash] - (dpos - elen); // subtract the part already used
+                        pos = estop; // move pos to next path element
+                        done = true;
+                    } else { // Dash is on this line
+                        pos = dpos + estart;
+                        done = pos >= estop;
+                        if (++idash >= dashCount)
+                            idash = 0;
+                        doffset = 0; // full segment so no offset on next.
+                    }
+                }
+                hasMoveTo = false;
+                move_to_pos = e;
+            }
+        }
+
         // Dash away...
         while (!done) {
             QPointF p2;
 
-            int idash_incr = 0;
             bool has_offset = doffset > 0;
+            bool evenDash = (idash & 1) == 0;
             qreal dpos = pos + dashes[idash] - doffset - estart;
 
@@ -1139 +1220 @@
                 pos = dpos + estart;
                 done = pos >= estop;
-                idash_incr = 1;
+                if (++idash >= dashCount)
+                    idash = 0;
                 doffset = 0; // full segment so no offset on next.
             }
 
-            if (idash % 2 == 0) {
+            if (evenDash) {
                 line_to_pos.x = qt_real_to_fixed(p2.x());
                 line_to_pos.y = qt_real_to_fixed(p2.y());
 
-                // If we have an offset, we're continuing a dash
-                // from a previous element and should only
-                // continue the current dash, without starting a
-                // new subpath.
-                if (!has_offset || !hasMoveTo) {
-                    emitMoveTo(move_to_pos.x, move_to_pos.y);
-                    hasMoveTo = true;
+                if (!clipping
+                    || lineRectIntersectsRect(move_to_pos, line_to_pos, clip_tl, clip_br))
+                {
+                    // If we have an offset, we're continuing a dash
+                    // from a previous element and should only
+                    // continue the current dash, without starting a
+                    // new subpath.
+                    if (!has_offset || !hasMoveTo) {
+                        emitMoveTo(move_to_pos.x, move_to_pos.y);
+                        hasMoveTo = true;
+                    }
+
+                    emitLineTo(line_to_pos.x, line_to_pos.y);
+                } else {
+                    hasMoveTo = false;
                 }
-
-                if (!clipping
-                    // if move_to is inside...
-                    || (move_to_pos.x > clip_tl.x && move_to_pos.x < clip_br.x
-                     && move_to_pos.y > clip_tl.y && move_to_pos.y < clip_br.y)
-                    // Or if line_to is inside...
-                    || (line_to_pos.x > clip_tl.x && line_to_pos.x < clip_br.x
-                     && line_to_pos.y > clip_tl.y && line_to_pos.y < clip_br.y))
-                {
-                    emitLineTo(line_to_pos.x, line_to_pos.y);
-                }
+                move_to_pos = line_to_pos;
             } else {
                 move_to_pos.x = qt_real_to_fixed(p2.x());
                 move_to_pos.y = qt_real_to_fixed(p2.y());
             }
-
-            idash = (idash + idash_incr) % dashCount;
         }