1 files changed, 154 insertions, 0 deletions
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index e69512d..6f5c732 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -8846,6 +8846,160 @@ QTransform QPainter::combinedTransform() const
     return d->state->worldMatrix * d->viewTransform();
 }
 
+/*!
+    \since 4.7
+
+    This function is used to draw \a pixmap, or a sub-rectangle of \a pixmap,
+    at multiple positions with different scale, rotation and opacity. \a
+    fragments is an array of \a fragmentCount elements specifying the
+    parameters used to draw each pixmap fragment. The \a hints
+    parameter can be used to pass in drawing hints.
+
+    This function is potentially faster than multiple calls to drawPixmap(),
+    since the backend can optimize state changes.
+
+    \sa QPainter::Fragment, QPainter::FragmentHint
+*/
+
+void QPainter::drawPixmapFragments(const Fragment *fragments, int fragmentCount,
+                                   const QPixmap &pixmap, FragmentHints hints)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (d->engine->isExtended()) {
+        d->extended->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+    } else {
+        qreal oldOpacity = opacity();
+        QTransform oldTransform = transform();
+
+        for (int i = 0; i < fragmentCount; ++i) {
+            QTransform transform = oldTransform;
+            transform.translate(fragments[i].x, fragments[i].y);
+            transform.rotate(fragments[i].rotation);
+            setOpacity(oldOpacity * fragments[i].opacity);
+            setTransform(transform);
+
+            qreal w = fragments[i].scaleX * fragments[i].width;
+            qreal h = fragments[i].scaleY * fragments[i].height;
+            QRectF sourceRect(fragments[i].sourceLeft, fragments[i].sourceTop,
+                              fragments[i].width, fragments[i].height);
+            drawPixmap(QRectF(-0.5 * w, -0.5 * h, w, h), pixmap, sourceRect);
+        }
+
+        setOpacity(oldOpacity);
+        setTransform(oldTransform);
+    }
+}
+
+/*!
+    \since 4.7
+    \class QPainter::Fragment
+
+    \brief This class is used in conjunction with the
+    QPainter::drawPixmapFragments() function to specify how a pixmap, or
+    sub-rect of a pixmap, is drawn.
+
+    The \a sourceLeft, \a sourceTop, \a width and \a height variables are used
+    as a source rectangle within the pixmap passed into the
+    QPainter::drawPixmapFragments() function. The variables \a x, \a y, \a
+    width and \a height are used to calculate the target rectangle that is
+    drawn. \a x and \a y denotes the center of the target rectangle. The \a
+    width and \a heigth in the target rectangle is scaled by the \a scaleX and
+    \a scaleY values. The resulting target rectangle is then rotated \a
+    rotation degrees around the \a x, \a y center point.
+
+    \sa QPainter::drawPixmapFragments()
+*/
+
+/*!
+    \since 4.7
+
+    This is a convenience function that returns a QPainter::Fragment that is
+    initialized with the \a pos, \a sourceRect, \a scaleX, \a scaleY, \a
+    rotation, \a opacity parameters.
+*/
+
+QPainter::Fragment QPainter::Fragment::create(const QPointF &pos, const QRectF &sourceRect,
+                                              qreal scaleX, qreal scaleY, qreal rotation,
+                                              qreal opacity)
+{
+    Fragment fragment = {pos.x(), pos.y(), sourceRect.x(), sourceRect.y(), sourceRect.width(),
+                         sourceRect.height(), scaleX, scaleY, rotation, opacity};
+    return fragment;
+}
+
+/*!
+    \variable QPainter::Fragment::x
+    \brief the x coordinate of center point in the target rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::y
+    \brief the y coordinate of the center point in the target rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::sourceLeft
+    \brief the left coordinate of the source rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::sourceTop
+    \brief the top coordinate of the source rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::width
+
+    \brief the width of the source rectangle and is used to calculate the width
+    of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::height
+
+    \brief the height of the source rectangle and is used to calculate the
+    height of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::scaleX
+    \brief the horizontal scale of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::scaleY
+    \brief the vertical scale of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::Fragment::rotation
+
+    \brief the rotation of the target rectangle in degrees. The target
+    rectangle is rotated after it has been scaled.
+*/
+
+/*!
+    \variable QPainter::Fragment::opacity
+
+    \brief the opacity of the target rectangle, where 0.0 is fully transparent
+    and 1.0 is fully opaque.
+*/
+
+/*!
+    \since 4.7
+
+    \enum QPainter::FragmentHint
+
+    \value OpaqueHint Indicates that the pixmap fragments to be drawn are
+    opaque. Opaque fragments are potentially faster to draw.
+
+    \sa QPainter::drawPixmapFragments(), QPainter::Fragment
+*/
+
 void qt_draw_helper(QPainterPrivate *p, const QPainterPath &path, QPainterPrivate::DrawOperation operation)
 {
     p->draw_helper(path, operation);