Changeset 561 for trunk/src/gui/painting/qpaintengineex.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/qpaintengineex.cpp (modified) (23 diffs)

trunk/src/gui/painting/qpaintengineex.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** 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 have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -43 +43 @@
 #include "qpainter_p.h"
 #include "qstroker_p.h"
+#include "qbezier_p.h"
 #include <private/qpainterpath_p.h>
 
@@ -56 +57 @@
  *
  */
-
-const QRealRect &QVectorPath::controlPointRect() const
+QVectorPath::~QVectorPath()
+{
+    if (m_hints & ShouldUseCacheHint) {
+        CacheEntry *e = m_cache;
+        while (e) {
+            if (e->data)
+                e->cleanup(e->engine, e->data);
+            CacheEntry *n = e->next;
+            delete e;
+            e = n;
+        }
+    }
+}
+
+
+QRectF QVectorPath::controlPointRect() const
 {
     if (m_hints & ControlPointRect)
-        return m_cp_rect;
+        return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
 
     if (m_count == 0) {
         m_cp_rect.x1 = m_cp_rect.x2 = m_cp_rect.y1 = m_cp_rect.y2 = 0;
         m_hints |= ControlPointRect;
-        return m_cp_rect;
+        return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
     }
     Q_ASSERT(m_points && m_count > 0);
@@ -89 +104 @@
 
     m_hints |= ControlPointRect;
-    return m_cp_rect;
-}
+    return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
+}
+
+
+QVectorPath::CacheEntry *QVectorPath::addCacheData(QPaintEngineEx *engine, void *data,
+                                                   qvectorpath_cache_cleanup cleanup) const{
+    Q_ASSERT(!lookupCacheData(engine));
+    if ((m_hints & IsCachedHint) == 0) {
+        m_cache = 0;
+        m_hints |= IsCachedHint;
+    }
+    CacheEntry *e = new CacheEntry;
+    e->engine = engine;
+    e->data = data;
+    e->cleanup = cleanup;
+    e->next = m_cache;
+    m_cache = e;
+    return m_cache;
+}
+
 
 const QVectorPath &qtVectorPathForPath(const QPainterPath &path)
@@ -101 +134 @@
 QDebug Q_GUI_EXPORT &operator<<(QDebug &s, const QVectorPath &path)
 {
-    QRealRect vectorPathBounds = path.controlPointRect();
-    QRectF rf(vectorPathBounds.x1, vectorPathBounds.y1,
-              vectorPathBounds.x2 - vectorPathBounds.x1, vectorPathBounds.y2 - vectorPathBounds.y1);
+    QRectF rf = path.controlPointRect();
     s << "QVectorPath(size:" << path.elementCount()
       << " hints:" << hex << path.hints()
-      << rf << ")";
+      << rf << ')';
     return s;
 }
@@ -139 +170 @@
 
 
+void QPaintEngineExPrivate::replayClipOperations()
+{
+    Q_Q(QPaintEngineEx);
+
+    QPainter *p = q->painter();
+    if (!p || !p->d_ptr)
+        return;
+
+    QList<QPainterClipInfo> clipInfo = p->d_ptr->state->clipInfo;
+
+    QTransform transform = q->state()->matrix;
+
+    for (int i = 0; i <  clipInfo.size(); ++i) {
+        const QPainterClipInfo &info = clipInfo.at(i);
+
+        if (info.matrix != q->state()->matrix) {
+            q->state()->matrix = info.matrix;
+            q->transformChanged();
+        }
+
+        switch (info.clipType) {
+        case QPainterClipInfo::RegionClip:
+            q->clip(info.region, info.operation);
+            break;
+        case QPainterClipInfo::PathClip:
+            q->clip(info.path, info.operation);
+            break;
+        case QPainterClipInfo::RectClip:
+            q->clip(info.rect, info.operation);
+            break;
+        case QPainterClipInfo::RectFClip: {
+            qreal right = info.rectf.x() + info.rectf.width();
+            qreal bottom = info.rectf.y() + info.rectf.height();
+            qreal pts[] = { info.rectf.x(), info.rectf.y(),
+                            right, info.rectf.y(),
+                            right, bottom,
+                            info.rectf.x(), bottom };
+            QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);
+            q->clip(vp, info.operation);
+            break;
+            }
+        }
+    }
+
+    if (transform != q->state()->matrix) {
+        q->state()->matrix = transform;
+        q->transformChanged();
+    }
+}
+
+
+bool QPaintEngineExPrivate::hasClipOperations() const
+{
+    Q_Q(const QPaintEngineEx);
+
+    QPainter *p = q->painter();
+    if (!p || !p->d_ptr)
+        return false;
+
+    QList<QPainterClipInfo> clipInfo = p->d_ptr->state->clipInfo;
+
+    return !clipInfo.isEmpty();
+}
 
 /*******************************************************************************
@@ -219 +313 @@
 };
 
+
+static QPainterPath::ElementType qpaintengineex_roundedrect_types[] = {
+    QPainterPath::MoveToElement,
+    QPainterPath::LineToElement,
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::LineToElement,
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::LineToElement,
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::LineToElement,
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement
+};
+
+
+
 static void qpaintengineex_moveTo(qreal x, qreal y, void *data) {
     ((StrokeHandler *) data)->pts.add(x);
@@ -245 +362 @@
 }
 
+QPaintEngineEx::QPaintEngineEx()
+    : QPaintEngine(*new QPaintEngineExPrivate, AllFeatures)
+{
+    extended = true;
+}
+
 QPaintEngineEx::QPaintEngineEx(QPaintEngineExPrivate &data)
     : QPaintEngine(data, AllFeatures)
@@ -250 +373 @@
     extended = true;
 }
-
 
 QPainterState *QPaintEngineEx::createState(QPainterState *orig) const
@@ -297 +419 @@
         } else {
             // ### re-enable...
-//             if (pen.isCosmetic()) {
-//                 d->dashStroker->setClipRect(d->deviceRect);
-//             } else {
-//                 QRectF clipRect = s->matrix.inverted().mapRect(QRectF(d->deviceRect));
-//                 d->dashStroker->setClipRect(clipRect);
-//             }
+            if (pen.isCosmetic()) {
+                d->dasher.setClipRect(d->exDeviceRect);
+            } else {
+                QRectF clipRect = state()->matrix.inverted().mapRect(QRectF(d->exDeviceRect));
+                d->dasher.setClipRect(clipRect);
+            }
             d->dasher.setDashPattern(pen.dashPattern());
             d->dasher.setDashOffset(pen.dashOffset());
@@ -319 +441 @@
     const qreal *lastPoint = points + (pointCount<<1);
 
-    d->activeStroker->begin(d->strokeHandler);
     d->strokeHandler->types.reset();
     d->strokeHandler->pts.reset();
@@ -325 +446 @@
     // Some engines might decide to optimize for the non-shape hint later on...
     uint flags = QVectorPath::WindingFill;
+
+    if (path.elementCount() > 2)
+        flags |= QVectorPath::NonConvexShapeMask;
+
     if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)
-        flags |= QVectorPath::CurvedShapeHint;
+        flags |= QVectorPath::CurvedShapeMask;
 
     // ### Perspective Xforms are currently not supported...
-    qreal txscale = 1;
-    if (!(pen.isCosmetic() || (qt_scaleForTransform(state()->matrix, &txscale) && txscale != 1))) {
+    if (!pen.isCosmetic()) {
         // We include cosmetic pens in this case to avoid having to
         // change the current transform. Normal transformed,
         // non-cosmetic pens will be transformed as part of fill
         // later, so they are also covered here..
+        d->activeStroker->begin(d->strokeHandler);
         if (types) {
             while (points < lastPoint) {
@@ -354 +479 @@
                     points += 6;
                     types += 3;
-                    flags |= QVectorPath::CurvedShapeHint;
+                    flags |= QVectorPath::CurvedShapeMask;
                     break;
                 default:
@@ -383 +508 @@
                                d->strokeHandler->types.size(),
                                d->strokeHandler->types.data(),
-                               QVectorPath::WindingFill);
+                               flags);
         fill(strokePath, pen.brush());
     } else {
-        const qreal strokeWidth = d->stroker.strokeWidth();
-        d->stroker.setStrokeWidth(strokeWidth * txscale);
         // For cosmetic pens we need a bit of trickery... We to process xform the input points
-        if (types) {
-            while (points < lastPoint) {
-                switch (*types) {
-                case QPainterPath::MoveToElement: {
-                    QPointF pt = (*(QPointF *) points) * state()->matrix;
-                    d->activeStroker->moveTo(pt.x(), pt.y());
+        if (state()->matrix.type() >= QTransform::TxProject) {
+            QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());
+            d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());
+        } else {
+            d->activeStroker->begin(d->strokeHandler);
+            if (types) {
+                while (points < lastPoint) {
+                    switch (*types) {
+                    case QPainterPath::MoveToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->moveTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::LineToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->lineTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::CurveToElement: {
+                        QPointF c1 = ((QPointF *) points)[0] * state()->matrix;
+                        QPointF c2 = ((QPointF *) points)[1] * state()->matrix;
+                        QPointF e =  ((QPointF *) points)[2] * state()->matrix;
+                        d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
+                        points += 6;
+                        types += 3;
+                        flags |= QVectorPath::CurvedShapeMask;
+                        break;
+                    }
+                    default:
+                        break;
+                    }
+                }
+                if (path.hasImplicitClose()) {
+                    QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
+                    d->activeStroker->lineTo(pt.x(), pt.y());
+                }
+
+            } else {
+                QPointF p = ((QPointF *)points)[0] * state()->matrix;
+                d->activeStroker->moveTo(p.x(), p.y());
+                points += 2;
+                ++types;
+                while (points < lastPoint) {
+                    QPointF p = ((QPointF *)points)[0] * state()->matrix;
+                    d->activeStroker->lineTo(p.x(), p.y());
                     points += 2;
                     ++types;
-                    break;
                 }
-                case QPainterPath::LineToElement: {
-                    QPointF pt = (*(QPointF *) points) * state()->matrix;
-                    d->activeStroker->lineTo(pt.x(), pt.y());
-                    points += 2;
-                    ++types;
-                    break;
-                }
-                case QPainterPath::CurveToElement: {
-                    QPointF c1 = ((QPointF *) points)[0] * state()->matrix;
-                    QPointF c2 = ((QPointF *) points)[1] * state()->matrix;
-                    QPointF e =  ((QPointF *) points)[2] * state()->matrix;
-                    d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
-                    points += 6;
-                    types += 3;
-                    flags |= QVectorPath::CurvedShapeHint;
-                    break;
-                }
-                default:
-                    break;
-                }
+                if (path.hasImplicitClose())
+                    d->activeStroker->lineTo(p.x(), p.y());
             }
-            if (path.hasImplicitClose()) {
-                QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
-                d->activeStroker->lineTo(pt.x(), pt.y());
-            }
-
-        } else {
-            QPointF p = ((QPointF *)points)[0] * state()->matrix;
-            d->activeStroker->moveTo(p.x(), p.y());
-            points += 2;
-            ++types;
-            while (points < lastPoint) {
-                QPointF p = ((QPointF *)points)[0] * state()->matrix;
-                d->activeStroker->lineTo(p.x(), p.y());
-                points += 2;
-                ++types;
-            }
-            if (path.hasImplicitClose())
-                d->activeStroker->lineTo(p.x(), p.y());
-        }
-
-        d->activeStroker->end();
-        d->stroker.setStrokeWidth(strokeWidth);
+            d->activeStroker->end();
+        }
+
         QVectorPath strokePath(d->strokeHandler->pts.data(),
                                d->strokeHandler->types.size(),
                                d->strokeHandler->types.data(),
-                               QVectorPath::WindingFill);
+                               flags);
 
         QTransform xform = state()->matrix;
@@ -464 +592 @@
 void QPaintEngineEx::draw(const QVectorPath &path)
 {
-    fill(path, state()->brush);
-    stroke(path, state()->pen);
+    const QBrush &brush = state()->brush;
+    if (qbrush_style(brush) != Qt::NoBrush)
+        fill(path, brush);
+
+    const QPen &pen = state()->pen;
+    if (qpen_style(pen) != Qt::NoPen && qbrush_style(qpen_brush(pen)) != Qt::NoBrush)
+        stroke(path, pen);
 }
 
@@ -484 +617 @@
 void QPaintEngineEx::clip(const QRegion &region, Qt::ClipOperation op)
 {
+    if (region.rectCount() == 1)
+        clip(region.boundingRect(), op);
+
     QVector<QRect> rects = region.rects();
     if (rects.size() <= 32) {
@@ -600 +736 @@
 }
 
+
+void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                                     Qt::SizeMode mode)
+{
+    qreal x1 = rect.left();
+    qreal x2 = rect.right();
+    qreal y1 = rect.top();
+    qreal y2 = rect.bottom();
+
+    if (mode == Qt::RelativeSize) {
+        xRadius = xRadius * rect.width() / 200.;
+        yRadius = yRadius * rect.height() / 200.;
+    }
+
+    xRadius = qMin(xRadius, rect.width() / 2);
+    yRadius = qMin(yRadius, rect.height() / 2);
+
+    qreal pts[] = {
+        x1 + xRadius, y1,                   // MoveTo
+        x2 - xRadius, y1,                   // LineTo
+        x2 - (1 - KAPPA) * xRadius, y1,     // CurveTo
+        x2, y1 + (1 - KAPPA) * yRadius,
+        x2, y1 + yRadius,
+        x2, y2 - yRadius,                   // LineTo
+        x2, y2 - (1 - KAPPA) * yRadius,     // CurveTo
+        x2 - (1 - KAPPA) * xRadius, y2,
+        x2 - xRadius, y2,
+        x1 + xRadius, y2,                   // LineTo
+        x1 + (1 - KAPPA) * xRadius, y2,           // CurveTo
+        x1, y2 - (1 - KAPPA) * yRadius,
+        x1, y2 - yRadius,
+        x1, y1 + yRadius,                   // LineTo
+        x1, y1 + KAPPA * yRadius,           // CurveTo
+        x1 + (1 - KAPPA) * xRadius, y1,
+        x1 + xRadius, y1
+    };
+
+    QVectorPath path(pts, 17, qpaintengineex_roundedrect_types, QVectorPath::RoundedRectHint);
+    draw(path);
+}
+
+
+
 void QPaintEngineEx::drawLines(const QLine *lines, int lineCount)
 {
@@ -685 +864 @@
                 pts[++oset] = points[i].y();
             }
-            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::NonCurvedShapeHint);
+            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
             stroke(path, pen);
             pointCount -= 16;
@@ -716 +895 @@
                 pts[++oset] = points[i].y();
             }
-            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::NonCurvedShapeHint);
+            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
             stroke(path, pen);
             pointCount -= 16;
@@ -778 +957 @@
 {
     QBrush brush(state()->pen.color(), pixmap);
-    QTransform xform;
-    xform.translate(-s.x(), -s.y());
+    QTransform xform = QTransform::fromTranslate(r.x() - s.x(), r.y() - s.y());
     brush.setTransform(xform);
 
@@ -791 +969 @@
 }
 
+void QPaintEngineEx::drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints /*hints*/)
+{
+    qreal oldOpacity = state()->opacity;
+    QTransform oldTransform = state()->matrix;
+
+    for (int i = 0; i < dataCount; ++i) {
+        QTransform transform = oldTransform;
+        transform.translate(drawingData[i].point.x(), drawingData[i].point.y());
+        transform.rotate(drawingData[i].rotation);
+        state()->opacity = oldOpacity * drawingData[i].opacity;
+        state()->matrix = transform;
+        opacityChanged();
+        transformChanged();
+
+        qreal w = drawingData[i].scaleX * drawingData[i].source.width();
+        qreal h = drawingData[i].scaleY * drawingData[i].source.height();
+        drawPixmap(QRectF(-0.5 * w, -0.5 * h, w, h), pixmap, drawingData[i].source);
+    }
+
+    state()->opacity = oldOpacity;
+    state()->matrix = oldTransform;
+    opacityChanged();
+    transformChanged();
+}
+
 void QPaintEngineEx::setState(QPainterState *s)
 {