Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 1030 insertions, 0 deletions

diff --git a/src/gui/painting/qpaintengine.cpp b/src/gui/painting/qpaintengine.cpp
new file mode 100644
index 0000000000..6eb09e5966
--- /dev/null
+++ b/src/gui/painting/qpaintengine.cpp
@@ -0,0 +1,1030 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qpaintengine.h"
+#include "qpaintengine_p.h"
+#include "qpainter_p.h"
+#include "qpolygon.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+#include <qdebug.h>
+#include <qmath.h>
+#include <private/qtextengine_p.h>
+#include <qvarlengtharray.h>
+#include <private/qfontengine_p.h>
+#include <private/qpaintengineex_p.h>
+
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QTextItem
+
+    \brief The QTextItem class provides all the information required to draw
+    text in a custom paint engine.
+
+    When you reimplement your own paint engine, you must reimplement
+    QPaintEngine::drawTextItem(), a function that takes a QTextItem as
+    one of its arguments.
+*/
+
+/*!
+  \enum QTextItem::RenderFlag
+
+  \value  RightToLeft Render the text from right to left.
+  \value  Overline    Paint a line above the text.
+  \value  Underline   Paint a line under the text.
+  \value  StrikeOut   Paint a line through the text.
+  \omitvalue Dummy
+*/
+
+
+/*!
+    \fn qreal QTextItem::descent() const
+
+    Corresponds to the \l{QFontMetrics::descent()}{descent} of the piece of text that is drawn.
+*/
+qreal QTextItem::descent() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->descent.toReal();
+}
+
+/*!
+    \fn qreal QTextItem::ascent() const
+
+    Corresponds to the \l{QFontMetrics::ascent()}{ascent} of the piece of text that is drawn.
+*/
+qreal QTextItem::ascent() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->ascent.toReal();
+}
+
+/*!
+    \fn qreal QTextItem::width() const
+
+    Specifies the total width of the text to be drawn.
+*/
+qreal QTextItem::width() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->width.toReal();
+}
+
+/*!
+    \fn QTextItem::RenderFlags QTextItem::renderFlags() const
+
+    Returns the render flags used.
+*/
+QTextItem::RenderFlags QTextItem::renderFlags() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->flags;
+}
+
+/*!
+    \fn QString QTextItem::text() const
+
+    Returns the text that should be drawn.
+*/
+QString QTextItem::text() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return QString(ti->chars, ti->num_chars);
+}
+
+/*!
+    \fn QFont QTextItem::font() const
+
+    Returns the font that should be used to draw the text.
+*/
+QFont QTextItem::font() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->f ? *ti->f : QApplication::font();
+}
+
+
+/*!
+  \class QPaintEngine
+  \ingroup painting
+
+  \brief The QPaintEngine class provides an abstract definition of how
+  QPainter draws to a given device on a given platform.
+
+  Qt 4.0 provides several premade implementations of QPaintEngine for the
+  different painter backends we support. We provide one paint engine for each
+  window system and painting framework we support. This includes X11 on
+  Unix/Linux and CoreGraphics on Mac OS X. In addition we provide QPaintEngine
+  implementations for OpenGL (accessible through QGLWidget) and PostScript
+  (accessible through QPSPrinter on X11). Additionally there is a raster-based
+  paint engine that is a fallback for when an engine does not support a certain
+  capability.
+
+  If one wants to use QPainter to draw to a different backend,
+  one must subclass QPaintEngine and reimplement all its virtual
+  functions. The QPaintEngine implementation is then made available by
+  subclassing QPaintDevice and reimplementing the virtual function
+  QPaintDevice::paintEngine().
+
+  QPaintEngine is created and owned by the QPaintDevice that created it.
+
+  The big advantage of the QPaintEngine approach opposed to
+  Qt 3's QPainter/QPaintDevice::cmd() approach is that it is now
+  possible to adapt to multiple technologies on each platform and take
+  advantage of each to the fullest.
+
+  \sa QPainter, QPaintDevice::paintEngine(), {Paint System}
+*/
+
+/*!
+  \enum QPaintEngine::PaintEngineFeature
+
+  This enum is used to describe the features or capabilities that the
+  paint engine has. If a feature is not supported by the engine,
+  QPainter will do a best effort to emulate that feature through other
+  means and pass on an alpha blended QImage to the engine with the
+  emulated results. Some features cannot be emulated: AlphaBlend and PorterDuff.
+
+  \value AlphaBlend         The engine can alpha blend primitives.
+  \value Antialiasing       The engine can use antialising to improve the appearance
+                            of rendered primitives.
+  \value BlendModes         The engine supports blending modes.
+  \value BrushStroke        The engine supports drawing strokes that
+                            contain brushes as fills, not just solid
+                            colors (e.g. a dashed gradient line of
+                            width 2).
+  \value ConicalGradientFill The engine supports conical gradient fills.
+  \value ConstantOpacity    The engine supports the feature provided by
+                            QPainter::setOpacity().
+  \value LinearGradientFill The engine supports linear gradient fills.
+  \value MaskedBrush        The engine is capable of rendering brushes that has a
+                            texture with an alpha channel or a mask.
+  \value ObjectBoundingModeGradients The engine has native support for gradients
+                            with coordinate mode QGradient::ObjectBoundingMode.
+                            Otherwise, if QPaintEngine::PatternTransform is
+                            supported, object bounding mode gradients are
+                            converted to gradients with coordinate mode
+                            QGradient::LogicalMode and a brush transform for
+                            the coordinate mapping.
+  \value PainterPaths       The engine has path support.
+  \value PaintOutsidePaintEvent The engine is capable of painting outside of
+                                paint events.
+  \value PatternBrush       The engine is capable of rendering brushes with
+                            the brush patterns specified in Qt::BrushStyle.
+  \value PatternTransform   The engine has support for transforming brush
+                            patterns.
+  \value PerspectiveTransform The engine has support for performing perspective
+                            transformations on primitives.
+  \value PixmapTransform    The engine can transform pixmaps, including
+                            rotation and shearing.
+  \value PorterDuff         The engine supports Porter-Duff operations
+  \value PrimitiveTransform The engine has support for transforming
+                            drawing primitives.
+  \value RadialGradientFill The engine supports radial gradient fills.
+  \value RasterOpModes      The engine supports bitwise raster operations.
+  \value AllFeatures        All of the above features. This enum value is usually
+                            used as a bit mask.
+*/
+
+/*!
+    \enum QPaintEngine::PolygonDrawMode
+
+    \value OddEvenMode The polygon should be drawn using OddEven fill
+    rule.
+
+    \value WindingMode The polygon should be drawn using Winding fill rule.
+
+    \value ConvexMode The polygon is a convex polygon and can be drawn
+    using specialized algorithms where available.
+
+    \value PolylineMode Only the outline of the polygon should be
+    drawn.
+
+*/
+
+/*!
+    \enum QPaintEngine::DirtyFlag
+
+    \value DirtyPen The pen is dirty and needs to be updated.
+
+    \value DirtyBrush The brush is dirty and needs to be updated.
+
+    \value DirtyBrushOrigin The brush origin is dirty and needs to
+    updated.
+
+    \value DirtyFont The font is dirty and needs to be updated.
+
+    \value DirtyBackground The background is dirty and needs to be
+    updated.
+
+    \value DirtyBackgroundMode The background mode is dirty and needs
+    to be updated.
+
+    \value DirtyTransform The transform is dirty and needs to be
+    updated.
+
+    \value DirtyClipRegion The clip region is dirty and needs to be
+    updated.
+
+    \value DirtyClipPath The clip path is dirty and needs to be
+    updated.
+
+    \value DirtyHints The render hints is dirty and needs to be
+    updated.
+
+    \value DirtyCompositionMode The composition mode is dirty and
+    needs to be updated.
+
+    \value DirtyClipEnabled Whether clipping is enabled or not is
+    dirty and needs to be updated.
+
+    \value DirtyOpacity The constant opacity has changed and needs to
+                        be updated as part of the state change in
+                        QPaintEngine::updateState().
+
+    \value AllDirty Convenience enum used internally.
+
+    These types are used by QPainter to trigger lazy updates of the
+    various states in the QPaintEngine using
+    QPaintEngine::updateState().
+
+    A paint engine must update every dirty state.
+*/
+
+/*!
+    \fn void QPaintEngine::syncState()
+
+    \internal
+
+    Updates all dirty states in this engine. This function should ONLY
+    be used when drawing with native handles directly and immediate sync
+    from QPainters state to the native state is required.
+*/
+void QPaintEngine::syncState()
+{
+    Q_ASSERT(state);
+    updateState(*state);
+
+    if (isExtended())
+        static_cast<QPaintEngineEx *>(this)->sync();
+}
+
+static QPaintEngine *qt_polygon_recursion = 0;
+struct QT_Point {
+    int x;
+    int y;
+};
+
+/*!
+    \fn void QPaintEngine::drawPolygon(const QPointF *points, int pointCount,
+    PolygonDrawMode mode)
+
+    Reimplement this virtual function to draw the polygon defined
+    by the \a pointCount first points in \a points, using mode \a
+    mode.
+
+    \note At least one of the drawPolygon() functions must be reimplemented.
+*/
+void QPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_ASSERT_X(qt_polygon_recursion != this, "QPaintEngine::drawPolygon",
+               "At least one drawPolygon function must be implemented");
+    qt_polygon_recursion = this;
+    Q_ASSERT(sizeof(QT_Point) == sizeof(QPoint));
+    QVarLengthArray<QT_Point> p(pointCount);
+    for (int i = 0; i < pointCount; ++i) {
+        p[i].x = qRound(points[i].x());
+        p[i].y = qRound(points[i].y());
+    }
+    drawPolygon((QPoint *)p.data(), pointCount, mode);
+    qt_polygon_recursion = 0;
+}
+
+struct QT_PointF {
+    qreal x;
+    qreal y;
+};
+/*!
+    \overload
+
+    Reimplement this virtual function to draw the polygon defined by the
+    \a pointCount first points in \a points, using mode \a mode.
+
+    \note At least one of the drawPolygon() functions must be reimplemented.
+*/
+void QPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_ASSERT_X(qt_polygon_recursion != this, "QPaintEngine::drawPolygon",
+               "At least one drawPolygon function must be implemented");
+    qt_polygon_recursion = this;
+    Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
+    QVarLengthArray<QT_PointF> p(pointCount);
+    for (int i=0; i<pointCount; ++i) {
+        p[i].x = points[i].x();
+        p[i].y = points[i].y();
+    }
+    drawPolygon((QPointF *)p.data(), pointCount, mode);
+    qt_polygon_recursion = 0;
+}
+
+/*!
+    \enum QPaintEngine::Type
+
+    \value X11
+    \value Windows
+    \value MacPrinter
+    \value CoreGraphics Mac OS X's Quartz2D (CoreGraphics)
+    \value QuickDraw Mac OS X's QuickDraw
+    \value QWindowSystem Qt for Embedded Linux
+    \value PostScript
+    \value OpenGL
+    \value Picture QPicture format
+    \value SVG Scalable Vector Graphics XML format
+    \value Raster
+    \value Direct3D Windows only, Direct3D based engine
+    \value Pdf Portable Document Format
+    \value OpenVG
+    \value User First user type ID
+    \value MaxUser Last user type ID
+    \value OpenGL2
+    \value PaintBuffer
+*/
+
+/*!
+    \fn bool QPaintEngine::isActive() const
+
+    Returns true if the paint engine is actively drawing; otherwise
+    returns false.
+
+    \sa setActive()
+*/
+
+/*!
+    \fn void QPaintEngine::setActive(bool state)
+
+    Sets the active state of the paint engine to \a state.
+
+    \sa isActive()
+*/
+
+/*!
+    \fn bool QPaintEngine::begin(QPaintDevice *pdev)
+
+    Reimplement this function to initialise your paint engine when
+    painting is to start on the paint device \a pdev. Return true if
+    the initialization was successful; otherwise return false.
+
+    \sa end() isActive()
+*/
+
+/*!
+    \fn bool QPaintEngine::end()
+
+    Reimplement this function to finish painting on the current paint
+    device. Return true if painting was finished successfully;
+    otherwise return false.
+
+    \sa begin() isActive()
+*/
+
+
+/*!
+    Draws the first \a pointCount points in the buffer \a points
+*/
+void QPaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+    QPainter *p = painter();
+    if (!p)
+        return;
+
+    qreal penWidth = p->pen().widthF();
+    if (penWidth == 0)
+        penWidth = 1;
+
+    bool ellipses = p->pen().capStyle() == Qt::RoundCap;
+
+    p->save();
+
+    QTransform transform;
+    if (p->pen().isCosmetic()) {
+        transform = p->transform();
+        p->setTransform(QTransform());
+    }
+
+    p->setBrush(p->pen().brush());
+    p->setPen(Qt::NoPen);
+
+    for (int i=0; i<pointCount; ++i) {
+        QPointF pos = transform.map(points[i]);
+        QRectF rect(pos.x() - penWidth / 2, pos.y() - penWidth / 2, penWidth, penWidth);
+
+        if (ellipses)
+            p->drawEllipse(rect);
+        else
+            p->drawRect(rect);
+    }
+
+    p->restore();
+}
+
+
+/*!
+    Draws the first \a pointCount points in the buffer \a points
+
+    The default implementation converts the first \a pointCount QPoints in \a points
+    to QPointFs and calls the floating point version of drawPoints.
+
+*/
+void QPaintEngine::drawPoints(const QPoint *points, int pointCount)
+{
+    Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
+    QT_PointF fp[256];
+    while (pointCount) {
+        int i = 0;
+        while (i < pointCount && i < 256) {
+            fp[i].x = points[i].x();
+            fp[i].y = points[i].y();
+            ++i;
+        }
+        drawPoints((QPointF *)(void *)fp, i);
+        points += i;
+        pointCount -= i;
+    }
+}
+
+/*!
+    \fn void QPaintEngine::drawEllipse(const QRectF &rect)
+
+    Reimplement this function to draw the largest ellipse that can be
+    contained within rectangle \a rect.
+
+    The default implementation calls drawPolygon().
+*/
+void QPaintEngine::drawEllipse(const QRectF &rect)
+{
+    QPainterPath path;
+    path.addEllipse(rect);
+    if (hasFeature(PainterPaths)) {
+        drawPath(path);
+    } else {
+        QPolygonF polygon = path.toFillPolygon();
+        drawPolygon(polygon.data(), polygon.size(), ConvexMode);
+    }
+}
+
+/*!
+    The default implementation of this function calls the floating
+    point version of this function
+*/
+void QPaintEngine::drawEllipse(const QRect &rect)
+{
+    drawEllipse(QRectF(rect));
+}
+
+/*!
+    \fn void QPaintEngine::drawPixmap(const QRectF &r, const QPixmap
+    &pm, const QRectF &sr)
+
+    Reimplement this function to draw the part of the \a pm
+    specified by the \a sr rectangle in the given \a r.
+*/
+
+
+void qt_fill_tile(QPixmap *tile, const QPixmap &pixmap)
+{
+    QPainter p(tile);
+    p.drawPixmap(0, 0, pixmap);
+    int x = pixmap.width();
+    while (x < tile->width()) {
+        p.drawPixmap(x, 0, *tile, 0, 0, x, pixmap.height());
+        x *= 2;
+    }
+    int y = pixmap.height();
+    while (y < tile->height()) {
+        p.drawPixmap(0, y, *tile, 0, 0, tile->width(), y);
+        y *= 2;
+    }
+}
+
+void qt_draw_tile(QPaintEngine *gc, qreal x, qreal y, qreal w, qreal h,
+                  const QPixmap &pixmap, qreal xOffset, qreal yOffset)
+{
+    qreal yPos, xPos, drawH, drawW, yOff, xOff;
+    yPos = y;
+    yOff = yOffset;
+    while(yPos < y + h) {
+        drawH = pixmap.height() - yOff;    // Cropping first row
+        if (yPos + drawH > y + h)           // Cropping last row
+            drawH = y + h - yPos;
+        xPos = x;
+        xOff = xOffset;
+        while(xPos < x + w) {
+            drawW = pixmap.width() - xOff; // Cropping first column
+            if (xPos + drawW > x + w)           // Cropping last column
+                drawW = x + w - xPos;
+            if (drawW > 0 && drawH > 0)
+                gc->drawPixmap(QRectF(xPos, yPos, drawW, drawH), pixmap, QRectF(xOff, yOff, drawW, drawH));
+            xPos += drawW;
+            xOff = 0;
+        }
+        yPos += drawH;
+        yOff = 0;
+    }
+}
+
+
+/*!
+    Reimplement this function to draw the \a pixmap in the given \a
+    rect, starting at the given \a p. The pixmap will be
+    drawn repeatedly until the \a rect is filled.
+*/
+void QPaintEngine::drawTiledPixmap(const QRectF &rect, const QPixmap &pixmap, const QPointF &p)
+{
+    int sw = pixmap.width();
+    int sh = pixmap.height();
+
+    if (sw*sh < 8192 && sw*sh < 16*rect.width()*rect.height()) {
+        int tw = sw, th = sh;
+        while (tw*th < 32678 && tw < rect.width()/2)
+            tw *= 2;
+        while (tw*th < 32678 && th < rect.height()/2)
+            th *= 2;
+        QPixmap tile;
+        if (pixmap.depth() == 1) {
+            tile = QBitmap(tw, th);
+        } else {
+            tile = QPixmap(tw, th);
+            if (pixmap.hasAlphaChannel())
+                tile.fill(Qt::transparent);
+        }
+        qt_fill_tile(&tile, pixmap);
+        qt_draw_tile(this, rect.x(), rect.y(), rect.width(), rect.height(), tile, p.x(), p.y());
+    } else {
+        qt_draw_tile(this, rect.x(), rect.y(), rect.width(), rect.height(), pixmap, p.x(), p.y());
+    }
+}
+
+/*!
+    \fn void QPaintEngine::drawImage(const QRectF &rectangle, const QImage
+    &image, const QRectF &sr, Qt::ImageConversionFlags flags)
+
+    Reimplement this function to draw the part of the \a image
+    specified by the \a sr rectangle in the given \a rectangle using
+    the given conversion flags \a flags, to convert it to a pixmap.
+*/
+
+void QPaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr,
+                             Qt::ImageConversionFlags flags)
+{
+    QRectF baseSize(0, 0, image.width(), image.height());
+    QImage im = image;
+    if (baseSize != sr)
+        im = im.copy(qFloor(sr.x()), qFloor(sr.y()),
+                     qCeil(sr.width()), qCeil(sr.height()));
+    QPixmap pm = QPixmap::fromImage(im, flags);
+    drawPixmap(r, pm, QRectF(QPointF(0, 0), pm.size()));
+}
+
+/*!
+    \fn Type QPaintEngine::type() const
+
+    Reimplement this function to return the paint engine \l{Type}.
+*/
+
+/*!
+    \fn void QPaintEngine::fix_neg_rect(int *x, int *y, int *w, int *h);
+
+    \internal
+*/
+
+/*!
+    \fn bool QPaintEngine::testDirty(DirtyFlags df)
+
+    \internal
+*/
+
+/*!
+    \fn void QPaintEngine::clearDirty(DirtyFlags df)
+
+    \internal
+*/
+
+/*!
+    \fn void QPaintEngine::setDirty(DirtyFlags df)
+
+    \internal
+*/
+
+/*!
+    \fn bool QPaintEngine::hasFeature(PaintEngineFeatures feature) const
+
+    Returns true if the paint engine supports the specified \a
+    feature; otherwise returns false.
+*/
+
+/*!
+    \fn bool QPaintEngine::isExtended() const
+
+    \internal
+
+    Returns true if the paint engine is a QPaintEngineEx derivative.
+*/
+
+/*!
+    \fn void QPaintEngine::updateState(const QPaintEngineState &state)
+
+    Reimplement this function to update the state of a paint engine.
+
+    When implemented, this function is responsible for checking the
+    paint engine's current \a state and update the properties that are
+    changed. Use the QPaintEngineState::state() function to find out
+    which properties that must be updated, then use the corresponding
+    \l {GetFunction}{get function} to retrieve the current values for
+    the given properties.
+
+    \sa QPaintEngineState
+*/
+
+/*!
+    Creates a paint engine with the featureset specified by \a caps.
+*/
+
+QPaintEngine::QPaintEngine(PaintEngineFeatures caps)
+    : state(0),
+      gccaps(caps),
+      active(0),
+      selfDestruct(false),
+      extended(false),
+      d_ptr(new QPaintEnginePrivate)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+  \internal
+*/
+
+QPaintEngine::QPaintEngine(QPaintEnginePrivate &dptr, PaintEngineFeatures caps)
+    : state(0),
+      gccaps(caps),
+      active(0),
+      selfDestruct(false),
+      extended(false),
+      d_ptr(&dptr)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+    Destroys the paint engine.
+*/
+QPaintEngine::~QPaintEngine()
+{
+}
+
+/*!
+    Returns the paint engine's painter.
+*/
+QPainter *QPaintEngine::painter() const
+{
+    return state ? state->painter() : 0;
+}
+
+/*!
+    The default implementation ignores the \a path and does nothing.
+*/
+
+void QPaintEngine::drawPath(const QPainterPath &)
+{
+    if (hasFeature(PainterPaths)) {
+        qWarning("QPaintEngine::drawPath: Must be implemented when feature PainterPaths is set");
+    }
+}
+
+/*!
+    This function draws the text item \a textItem at position \a p. The
+    default implementation of this function converts the text to a
+    QPainterPath and paints the resulting path.
+*/
+
+void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+
+    QPainterPath path;
+#ifndef Q_WS_MAC
+    path.setFillRule(Qt::WindingFill);
+#endif
+    if (ti.glyphs.numGlyphs)
+        ti.fontEngine->addOutlineToPath(p.x(), p.y(), ti.glyphs, &path, ti.flags);
+    if (!path.isEmpty()) {
+        bool oldAA = painter()->renderHints() & QPainter::Antialiasing;
+        painter()->setRenderHint(QPainter::Antialiasing,
+                                 bool((painter()->renderHints() & QPainter::TextAntialiasing)
+                                      && !(painter()->font().styleStrategy() & QFont::NoAntialias)));
+        painter()->fillPath(path, state->pen().brush());
+        painter()->setRenderHint(QPainter::Antialiasing, oldAA);
+    }
+}
+
+/*!
+    The default implementation splits the list of lines in \a lines
+    into \a lineCount separate calls to drawPath() or drawPolygon()
+    depending on the feature set of the paint engine.
+*/
+void QPaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+    for (int i=0; i<lineCount; ++i) {
+        QPointF pts[2] = { lines[i].p1(), lines[i].p2() };
+
+        if (pts[0] == pts[1]) {
+            if (state->pen().capStyle() != Qt::FlatCap)
+                drawPoints(pts, 1);
+            continue;
+        }
+
+        drawPolygon(pts, 2, PolylineMode);
+    }
+}
+
+/*!
+    \overload
+
+    The default implementation converts the first \a lineCount lines
+    in \a lines to a QLineF and calls the floating point version of
+    this function.
+*/
+void QPaintEngine::drawLines(const QLine *lines, int lineCount)
+{
+    struct PointF {
+        qreal x;
+        qreal y;
+    };
+    struct LineF {
+        PointF p1;
+        PointF p2;
+    };
+    Q_ASSERT(sizeof(PointF) == sizeof(QPointF));
+    Q_ASSERT(sizeof(LineF) == sizeof(QLineF));
+    LineF fl[256];
+    while (lineCount) {
+        int i = 0;
+        while (i < lineCount && i < 256) {
+            fl[i].p1.x = lines[i].x1();
+            fl[i].p1.y = lines[i].y1();
+            fl[i].p2.x = lines[i].x2();
+            fl[i].p2.y = lines[i].y2();
+            ++i;
+        }
+        drawLines((QLineF *)(void *)fl, i);
+        lines += i;
+        lineCount -= i;
+    }
+}
+
+
+/*!
+    \overload
+
+    The default implementation converts the first \a rectCount
+    rectangles in the buffer \a rects to a QRectF and calls the
+    floating point version of this function.
+*/
+void QPaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+    struct RectF {
+        qreal x;
+        qreal y;
+        qreal w;
+        qreal h;
+    };
+    Q_ASSERT(sizeof(RectF) == sizeof(QRectF));
+    RectF fr[256];
+    while (rectCount) {
+        int i = 0;
+        while (i < rectCount && i < 256) {
+            fr[i].x = rects[i].x();
+            fr[i].y = rects[i].y();
+            fr[i].w = rects[i].width();
+            fr[i].h = rects[i].height();
+            ++i;
+        }
+        drawRects((QRectF *)(void *)fr, i);
+        rects += i;
+        rectCount -= i;
+    }
+}
+
+/*!
+    Draws the first \a rectCount rectangles in the buffer \a
+    rects. The default implementation of this function calls drawPath()
+    or drawPolygon() depending on the feature set of the paint engine.
+*/
+void QPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+    if (hasFeature(PainterPaths) &&
+        !state->penNeedsResolving() &&
+        !state->brushNeedsResolving()) {
+        for (int i=0; i<rectCount; ++i) {
+            QPainterPath path;
+            path.addRect(rects[i]);
+            if (path.isEmpty())
+                continue;
+            drawPath(path);
+        }
+    } else {
+        for (int i=0; i<rectCount; ++i) {
+            QRectF rf = rects[i];
+            QPointF pts[4] = { QPointF(rf.x(), rf.y()),
+                               QPointF(rf.x() + rf.width(), rf.y()),
+                               QPointF(rf.x() + rf.width(), rf.y() + rf.height()),
+                               QPointF(rf.x(), rf.y() + rf.height()) };
+            drawPolygon(pts, 4, ConvexMode);
+        }
+    }
+}
+
+/*!
+    \internal
+    Sets the paintdevice that this engine operates on to \a device
+*/
+void QPaintEngine::setPaintDevice(QPaintDevice *device)
+{
+    d_func()->pdev = device;
+}
+
+/*!
+    Returns the device that this engine is painting on, if painting is
+    active; otherwise returns 0.
+*/
+QPaintDevice *QPaintEngine::paintDevice() const
+{
+    return d_func()->pdev;
+}
+
+#ifdef Q_WS_WIN
+/*!
+    \internal
+
+    Empty default implementation.
+*/
+
+HDC QPaintEngine::getDC() const
+{
+    return 0;
+}
+
+
+/*!
+    \internal
+
+    Empty default implementation.
+*/
+
+void QPaintEngine::releaseDC(HDC) const
+{
+}
+
+#endif
+
+/*!
+    \internal
+
+    Returns the offset from the painters origo to the engines
+    origo. This value is used by QPainter for engines who have
+    internal double buffering.
+
+    This function only makes sense when the engine is active.
+*/
+QPoint QPaintEngine::coordinateOffset() const
+{
+    return QPoint();
+}
+
+/*!
+    \internal
+
+    Sets the system clip for this engine. The system clip defines the
+    basis area that the engine has to draw in. All clips that are
+    set will be be an intersection with the system clip.
+
+    Reset the systemclip to no clip by setting an empty region.
+*/
+void QPaintEngine::setSystemClip(const QRegion &region)
+{
+    Q_D(QPaintEngine);
+    d->systemClip = region;
+    // Be backward compatible and only call d->systemStateChanged()
+    // if we currently have a system transform/viewport set.
+    if (d->hasSystemTransform || d->hasSystemViewport) {
+        d->transformSystemClip();
+        d->systemStateChanged();
+    }
+}
+
+/*!
+    \internal
+
+    Returns the system clip. The system clip is read only while the
+    painter is active. An empty region indicates that system clip
+    is not in use.
+*/
+
+QRegion QPaintEngine::systemClip() const
+{
+    return d_func()->systemClip;
+}
+
+/*!
+    \internal
+
+    Sets the target rect for drawing within the backing store. This
+    function should ONLY be used by the backing store.
+*/
+void QPaintEngine::setSystemRect(const QRect &rect)
+{
+    if (isActive()) {
+        qWarning("QPaintEngine::setSystemRect: Should not be changed while engine is active");
+        return;
+    }
+    d_func()->systemRect = rect;
+}
+
+/*!
+    \internal
+
+    Retrieves the rect for drawing within the backing store. This
+    function should ONLY be used by the backing store.
+ */
+QRect QPaintEngine::systemRect() const
+{
+    return d_func()->systemRect;
+}
+
+void QPaintEnginePrivate::drawBoxTextItem(const QPointF &p, const QTextItemInt &ti)
+{
+    if (!ti.glyphs.numGlyphs)
+        return;
+
+    // any fixes here should probably also be done in QFontEngineBox::draw
+    const int size = qRound(ti.fontEngine->ascent());
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix = QTransform::fromTranslate(p.x(), p.y() - size);
+    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    if (glyphs.size() == 0)
+        return;
+
+    QSize s(size - 3, size - 3);
+
+    QPainter *painter = q_func()->state->painter();
+    painter->save();
+    painter->setBrush(Qt::NoBrush);
+    QPen pen = painter->pen();
+    pen.setWidthF(ti.fontEngine->lineThickness().toReal());
+    painter->setPen(pen);
+    for (int k = 0; k < positions.size(); k++)
+        painter->drawRect(QRectF(positions[k].toPointF(), s));
+    painter->restore();
+}
+
+QT_END_NAMESPACE