Merge branch 'qt-graphics-team-qstatictext-4.7'

4 files changed, 853 insertions, 2 deletions

diff --git a/src/gui/text/qstatictext.cpp b/src/gui/text/qstatictext.cpp
new file mode 100644
index 0000000..6cf7022
--- /dev/null
+++ b/src/gui/text/qstatictext.cpp
@@ -0,0 +1,602 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** 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.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstatictext.h"
+#include "qstatictext_p.h"
+#include <private/qtextengine_p.h>
+#include <private/qfontengine_p.h>
+
+#include <QtGui/qapplication.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QStaticText
+    \internal
+    \brief The QStaticText class enables optimized drawing of text when the text and its layout
+    is updated rarely.
+    \since 4.7
+
+    \ingroup multimedia
+    \ingroup text
+    \mainclass
+
+    QStaticText provides a way to cache layout data for a block of text so that it can be drawn
+    more efficiently than by using QPainter::drawText() in which the layout information is 
+    recalculated with every call. 
+
+    The class primarily provides an optimization for cases where text and the transformations on
+    the painter are static over several paint events. If the text or its layout is changed
+    regularly, QPainter::drawText() is the more efficient alternative. Translating the painter
+    will not cause the layout of the text to be recalculated, but will cause a very small
+    performance impact on drawStaticText(). Altering any other parts of the painter's
+    transformation or the painter's font will cause the layout of the static text to be
+    recalculated. This should be avoided as often as possible to maximize the performance
+    benefit of using QStaticText.
+
+    In addition, only affine transformations are supported by drawStaticText(). Calling
+    drawStaticText() on a projected painter will perform slightly worse than using the regular
+    drawText() call, so this should be avoided.
+
+    \code
+    class MyWidget: public QWidget
+    {
+    public:
+        MyWidget(QWidget *parent = 0) : QWidget(parent), m_staticText("This is static text")
+
+    protected:
+        void paintEvent(QPaintEvent *)
+        {
+            QPainter painter(this);
+            painter.drawStaticText(0, 0, m_staticText);
+        }
+
+    private:
+        QStaticText m_staticText;
+    };
+    \endcode
+
+    The QStaticText class can be used to mimic the behavior of QPainter::drawText() to a specific
+    point with no boundaries, and also when QPainter::drawText() is called with a bounding 
+    rectangle. 
+
+    If a bounding rectangle is not required, create a QStaticText object without setting a maximum 
+    size. The text will then occupy a single line. 
+
+    If you set a maximum size on the QStaticText object, this will bound the text. The text will
+    be formatted so that no line exceeds the given width. When the object is painted, it will 
+    be clipped at the given size. The position of the text is decided by the argument
+    passed to QPainter::drawStaticText() and can change from call to call with a minimal impact
+    on performance.
+
+    \sa QPainter::drawText(), QPainter::drawStaticText(), QTextLayout, QTextDocument
+*/
+
+/*!
+    Constructs an empty QStaticText
+*/
+QStaticText::QStaticText()    
+    : data(new QStaticTextPrivate)
+{
+}
+
+/*!
+    \fn QStaticText::QStaticText(const QString &text, const QFont &font, const QSizeF &maximumSize)
+
+    Constructs a QStaticText object with the given \a text which is to be rendered in the given
+    \a font and bounded by the given \a maximumSize. If an invalid size is passed for \a maximumSize
+    the text will be unbounded.         
+*/
+QStaticText::QStaticText(const QString &text, const QSizeF &size)
+    : data(new QStaticTextPrivate)
+{    
+    data->text = text;
+    data->maximumSize = size;
+    data->init();
+}
+
+/*!
+    Constructs a QStaticText object which is a copy of \a other.
+*/
+QStaticText::QStaticText(const QStaticText &other)    
+{
+    data = other.data;
+}
+
+/*!
+    Destroys the QStaticText.
+*/
+QStaticText::~QStaticText()
+{
+    Q_ASSERT(!data || data->ref >= 1);
+}
+
+/*!
+    \internal
+*/
+void QStaticText::detach()
+{    
+    if (data->ref != 1)
+        data.detach();
+}
+
+/*!
+  Prepares the QStaticText object for being painted with the given \a matrix and the given
+  \a font to avoid overhead when the actual drawStaticText() call is made.
+
+  When drawStaticText() is called, the layout of the QStaticText will be recalculated if the
+  painter's font or matrix is different from the one used for the currently cached layout. By
+  default, QStaticText will use a default constructed QFont and an identity matrix to create
+  its layout.
+
+  To avoid the overhead of creating the layout the first time you draw the QStaticText with
+  a painter whose matrix or font are different from the defaults, you can use the prepare()
+  function and pass in the matrix and font you expect to use when drawing the text.
+
+  \sa QPainter::setFont(), QPainter::setMatrix()
+*/
+void QStaticText::prepare(const QTransform &matrix, const QFont &font)
+{
+    data->matrix = matrix;
+    data->font = font;
+    data->init();
+}
+
+
+/*!
+    Assigns \a other to this QStaticText.
+*/
+QStaticText &QStaticText::operator=(const QStaticText &other)
+{    
+    data = other.data;
+    return *this;
+}
+
+/*!
+    Compares \a other to this QStaticText. Returns true if the texts, fonts and maximum sizes
+    are equal.
+*/
+bool QStaticText::operator==(const QStaticText &other) const
+{
+    return (data == other.data
+            || (data->text == other.data->text
+                && data->font == other.data->font
+                && data->maximumSize == other.data->maximumSize));
+}
+
+/*!
+    Compares \a other to this QStaticText. Returns true if the texts, fonts or maximum sizes
+    are different.
+*/
+bool QStaticText::operator!=(const QStaticText &other) const
+{
+    return !(*this == other);
+}
+
+/*!
+    Sets the text of the QStaticText to \a text.
+
+    \note This function will cause the layout of the text to be recalculated.
+
+    \sa text()
+*/
+void QStaticText::setText(const QString &text)
+{
+    detach();
+    data->text = text;
+    data->init();
+}
+
+/*!
+   Sets the text format of the QStaticText to \a textFormat. If \a textFormat is set to
+   Qt::AutoText (the default), the format of the text will try to be determined using the
+   function Qt::mightBeRichText(). If the text format is Qt::PlainText, then the text will be
+   displayed as is, whereas it will be interpreted as HTML if the format is Qt::RichText. HTML tags
+   that alter the font of the text, its color, or its layout are supported by QStaticText.
+
+   \note This function will cause the layout of the text to be recalculated.
+
+   \sa textFormat(), setText(), text()
+*/
+void QStaticText::setTextFormat(Qt::TextFormat textFormat)
+{
+    detach();
+    data->textFormat = textFormat;
+    data->init();
+}
+
+/*!
+  Returns the text format of the QStaticText.
+
+  \sa setTextFormat(), setText(), text()
+*/
+Qt::TextFormat QStaticText::textFormat() const
+{
+    return Qt::TextFormat(data->textFormat);
+}
+
+/*!
+    Returns the text of the QStaticText.
+
+    \sa setText()
+*/
+QString QStaticText::text() const 
+{
+    return data->text;
+}
+
+/*!
+  Sets whether the QStaticText object should use optimizations specific to the paint engine
+  backend if they are available. If \a on is set to true, backend optimizations will be turned
+  on, otherwise they will be turned off. The default value is false.
+
+  If backend optimizations are on, the paint engine used to draw the static text is allowed to
+  store data in the object which will assist it in future calls to drawStaticText. In particular,
+  when using the opengl graphics system, or when painting on a QGLWidget, turning this flag on will
+  improve performance, but increase the memory footprint of the QStaticText object.
+
+  The default value is false.
+
+  \note This function will cause the layout of the text to be recalculated.
+
+  \sa useBackendOptimizations()
+*/
+void QStaticText::setUseBackendOptimizations(bool on)
+{
+    if ((!on && !data->useBackendOptimizations)
+        || (on && data->useBackendOptimizations))
+        return;
+
+    detach();
+    data->useBackendOptimizations = on;
+    data->init();
+}
+
+/*!
+  Returns whether the QStaticText object should use optimizations specific to the paint engine
+  backend when possible. By default this setting is false.
+
+  \sa setUseBackendOptimizations()
+*/
+bool QStaticText::useBackendOptimizations() const
+{
+    return data->useBackendOptimizations;
+}
+
+/*!
+    Sets the maximum size of the QStaticText to \a maximumSize.
+
+    \note This function will cause the layout of the text to be recalculated.
+
+    \sa maximumSize()
+*/
+void QStaticText::setMaximumSize(const QSizeF &size)
+{
+    detach();
+    data->maximumSize = size;
+    data->init();
+}
+
+/*!
+    Returns the maximum size of the QStaticText.
+
+    \sa setMaximumSize()
+*/
+QSizeF QStaticText::maximumSize() const
+{
+    return data->maximumSize;
+}
+
+/*!
+  Returns the size of the bounding rect for this QStaticText.
+
+  \sa maximumSize()
+*/
+QSizeF QStaticText::size() const
+{
+    return data->actualSize;
+}
+
+QStaticTextPrivate::QStaticTextPrivate()
+        : items(0), itemCount(0), glyphPool(0), positionPool(0), needsClipRect(false),
+          useBackendOptimizations(false), textFormat(Qt::AutoText)
+{
+    ref = 1;    
+}
+
+QStaticTextPrivate::QStaticTextPrivate(const QStaticTextPrivate &other)
+    : text(other.text), font(other.font), maximumSize(other.maximumSize), matrix(other.matrix),
+      items(0), itemCount(0), glyphPool(0), positionPool(0), needsClipRect(false),
+      useBackendOptimizations(false), textFormat(other.textFormat)
+{
+    ref = 1;
+}
+
+QStaticTextPrivate::~QStaticTextPrivate()
+{
+    delete[] items;    
+    delete[] glyphPool;
+    delete[] positionPool;
+}
+
+QStaticTextPrivate *QStaticTextPrivate::get(const QStaticText *q)
+{
+    return q->data.data();
+}
+
+extern int qt_defaultDpiX();
+extern int qt_defaultDpiY();
+
+namespace {
+
+    class DrawTextItemRecorder: public QPaintEngine
+    {
+    public:
+        DrawTextItemRecorder(int expectedItemCount, QStaticTextItem *items,
+                             int expectedGlyphCount, QFixedPoint *positionPool, glyph_t *glyphPool)
+                : m_items(items),
+                  m_expectedItemCount(expectedItemCount),
+                  m_expectedGlyphCount(expectedGlyphCount),
+                  m_itemCount(0), m_glyphCount(0),
+                  m_positionPool(positionPool),
+                  m_glyphPool(glyphPool)
+        {
+        }
+
+        virtual void drawTextItem(const QPointF &position, const QTextItem &textItem)
+        {
+            const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);          
+
+            m_itemCount++;
+            m_glyphCount += ti.glyphs.numGlyphs;
+            if (m_items == 0)
+                return;
+
+            Q_ASSERT(m_itemCount <= m_expectedItemCount);
+            Q_ASSERT(m_glyphCount <= m_expectedGlyphCount);
+
+            QStaticTextItem *currentItem = (m_items + (m_itemCount - 1));
+            currentItem->fontEngine = ti.fontEngine;
+            currentItem->font = ti.font();
+            currentItem->chars = ti.chars;
+            currentItem->numChars = ti.num_chars;
+            currentItem->numGlyphs = ti.glyphs.numGlyphs;
+            currentItem->glyphs = m_glyphPool;
+            currentItem->glyphPositions = m_positionPool;
+            currentItem->color = state->pen().color();
+
+            QTransform matrix = state->transform();
+            matrix.translate(position.x(), position.y());
+
+            QVarLengthArray<glyph_t> glyphs;
+            QVarLengthArray<QFixedPoint> positions;
+            ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+            int size = glyphs.size();
+            Q_ASSERT(size == ti.glyphs.numGlyphs);
+            Q_ASSERT(size == positions.size());
+
+            memmove(currentItem->glyphs, glyphs.constData(), sizeof(glyph_t) * size);
+            memmove(currentItem->glyphPositions, positions.constData(), sizeof(QFixedPoint) * size);
+
+            m_glyphPool += size;
+            m_positionPool += size;
+        }                
+
+
+        virtual bool begin(QPaintDevice *)  { return true; }
+        virtual bool end() { return true; }
+        virtual void updateState(const QPaintEngineState &) {}
+        virtual void drawPixmap(const QRectF &, const QPixmap &, const QRectF &) {}
+        virtual Type type() const
+        {
+            return User;
+        }
+
+        int itemCount() const
+        {
+            return m_itemCount;
+        }
+
+        int glyphCount() const
+        {
+            return m_glyphCount;
+        }
+
+    private:
+        QStaticTextItem *m_items;
+        int m_itemCount;
+        int m_glyphCount;
+        int m_expectedItemCount;
+        int m_expectedGlyphCount;
+
+        glyph_t *m_glyphPool;
+        QFixedPoint *m_positionPool;
+    };
+
+    class DrawTextItemDevice: public QPaintDevice
+    {
+    public:
+        DrawTextItemDevice(int expectedItemCount = -1,  QStaticTextItem *items = 0,
+                           int expectedGlyphCount = -1, QFixedPoint *positionPool = 0,
+                           glyph_t *glyphPool = 0)
+        {
+            m_paintEngine = new DrawTextItemRecorder(expectedItemCount, items,
+                                                     expectedGlyphCount, positionPool, glyphPool);
+        }
+
+        ~DrawTextItemDevice()
+        {
+            delete m_paintEngine;
+        }
+
+        int metric(PaintDeviceMetric m) const
+        {
+            int val;
+            switch (m) {
+            case PdmWidth:
+            case PdmHeight:
+            case PdmWidthMM:
+            case PdmHeightMM:
+                val = 0;
+                break;
+            case PdmDpiX:
+            case PdmPhysicalDpiX:
+                val = qt_defaultDpiX();
+                break;
+            case PdmDpiY:
+            case PdmPhysicalDpiY:
+                val = qt_defaultDpiY();
+                break;
+            case PdmNumColors:
+                val = 16777216;
+                break;
+            case PdmDepth:
+                val = 24;
+                break;
+            default:
+                val = 0;
+                qWarning("DrawTextItemDevice::metric: Invalid metric command");
+            }
+            return val;
+        }
+
+        virtual QPaintEngine *paintEngine() const
+        {
+            return m_paintEngine;
+        }
+
+        int itemCount() const
+        {
+            return m_paintEngine->itemCount();
+        }
+
+        int glyphCount() const
+        {
+            return m_paintEngine->glyphCount();
+        }
+
+    private:
+        DrawTextItemRecorder *m_paintEngine;
+    };
+}
+
+void QStaticTextPrivate::paintText(QPainter *p)
+{
+    bool preferRichText = textFormat == Qt::RichText
+                          || (textFormat == Qt::AutoText && Qt::mightBeRichText(text));
+
+    if (!preferRichText) {
+        if (maximumSize.isValid()) {
+            QRectF boundingRect;
+            p->drawText(QRectF(QPointF(0, 0), maximumSize), Qt::TextWordWrap, text, &boundingRect);
+
+            actualSize = boundingRect.size();
+            needsClipRect = boundingRect.width() > maximumSize.width()
+                            || boundingRect.height() > maximumSize.height();
+        } else {
+            p->drawText(0, 0, text);
+            needsClipRect = false;
+
+            QFontMetrics fm(font);
+            actualSize = fm.boundingRect(text).size();
+        }
+    } else {
+        QTextDocument document;
+        document.setDefaultFont(font);
+        document.setHtml(text);
+
+        QRectF rect = maximumSize.isValid() ? QRectF(QPointF(0, 0), maximumSize) : QRectF();
+        document.adjustSize();
+        document.drawContents(p, rect);        
+        actualSize = document.size();
+        needsClipRect = maximumSize.isValid()
+                        && (actualSize.width() > maximumSize.width()
+                            || actualSize.height() > maximumSize.height());
+    }
+}
+
+void QStaticTextPrivate::init()
+{
+    delete[] items;
+    delete[] glyphPool;
+    delete[] positionPool;
+
+    position = QPointF(0, 0);
+
+    // Draw once to count number of items and glyphs, so that we can use as little memory
+    // as possible to store the data
+    DrawTextItemDevice counterDevice;
+    {
+        QPainter painter(&counterDevice);
+        painter.setFont(font);
+        painter.setTransform(matrix);
+
+        paintText(&painter);
+
+    }
+
+    itemCount = counterDevice.itemCount();    
+    items = new QStaticTextItem[itemCount];
+
+    if (useBackendOptimizations) {
+        for (int i=0; i<itemCount; ++i)
+            items[i].useBackendOptimizations = true;
+    }
+
+
+    int glyphCount = counterDevice.glyphCount();
+    glyphPool = new glyph_t[glyphCount];
+    positionPool = new QFixedPoint[glyphCount];
+
+    // Draw again to actually record the items and glyphs
+    DrawTextItemDevice recorderDevice(itemCount, items, glyphCount, positionPool, glyphPool);
+    {
+        QPainter painter(&recorderDevice);
+        painter.setFont(font);
+        painter.setTransform(matrix);
+
+        paintText(&painter);
+    }
+
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/text/qstatictext.h b/src/gui/text/qstatictext.h
new file mode 100644
index 0000000..8eeb068
--- /dev/null
+++ b/src/gui/text/qstatictext.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** 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.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTATICTEXT_H
+#define QSTATICTEXT_H
+
+#include <QtCore/qsize.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qmetatype.h>
+
+#include <QtGui/qtransform.h>
+#include <QtGui/qfont.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QStaticTextPrivate;
+class Q_GUI_EXPORT QStaticText
+{    
+public:
+    QStaticText();
+    QStaticText(const QString &text, const QSizeF &maximumSize = QSizeF());
+    QStaticText(const QStaticText &other);
+    ~QStaticText();
+
+    void setText(const QString &text);
+    QString text() const;
+
+    void setTextFormat(Qt::TextFormat textFormat);
+    Qt::TextFormat textFormat() const;
+
+    void setMaximumSize(const QSizeF &maximumSize);
+    QSizeF maximumSize() const;
+
+    QSizeF size() const;
+
+    void prepare(const QTransform &matrix, const QFont &font);
+
+    void setUseBackendOptimizations(bool on);
+    bool useBackendOptimizations() const;
+
+    QStaticText &operator=(const QStaticText &);
+    bool operator==(const QStaticText &) const;
+    bool operator!=(const QStaticText &) const;
+
+private:
+    void detach();
+
+    QExplicitlySharedDataPointer<QStaticTextPrivate> data;
+    friend class QStaticTextPrivate;
+};
+
+Q_DECLARE_METATYPE(QStaticText)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSTATICTEXT_H
diff --git a/src/gui/text/qstatictext_p.h b/src/gui/text/qstatictext_p.h
new file mode 100644
index 0000000..95bd286
--- /dev/null
+++ b/src/gui/text/qstatictext_p.h
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** 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.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTATICTEXT_P_H
+#define QSTATICTEXT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of internal files.  This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtextureglyphcache_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QStaticTextUserData
+{
+public:
+    enum Type {
+        NoUserData,
+        OpenGLUserData
+    };
+
+    QStaticTextUserData(Type t) : type(t) {}
+    virtual ~QStaticTextUserData() {}
+
+    Type type;
+};
+
+class Q_GUI_EXPORT QStaticTextItem
+{
+public:    
+    QStaticTextItem() : chars(0), numChars(0), fontEngine(0), userData(0),
+                        useBackendOptimizations(false), userDataNeedsUpdate(0) {}
+    ~QStaticTextItem() { delete userData; }
+
+    void setUserData(QStaticTextUserData *newUserData)
+    {
+        if (userData == newUserData)
+            return;
+
+        delete userData;
+        userData = newUserData;
+    }
+
+    QFixedPoint *glyphPositions;                 // 8 bytes per glyph
+    glyph_t *glyphs;                             // 4 bytes per glyph
+    const QChar *chars;                          // 2 bytes per glyph
+                                                 // =================
+                                                 // 14 bytes per glyph
+
+                                                 // 12 bytes for pointers
+    int numGlyphs;                               // 4 bytes per item
+    int numChars;                                // 4 bytes per item
+    QFontEngine *fontEngine;                     // 4 bytes per item
+    QFont font;                                  // 8 bytes per item
+    QColor color;                                // 10 bytes per item
+    QStaticTextUserData *userData;               // 8 bytes per item
+    char useBackendOptimizations : 1;            // 1 byte per item
+    char userDataNeedsUpdate : 1;                //
+                                                 // ================
+                                                 // 51 bytes per item
+};
+
+class QStaticText;
+class Q_AUTOTEST_EXPORT QStaticTextPrivate
+{
+public:
+    QStaticTextPrivate();
+    QStaticTextPrivate(const QStaticTextPrivate &other);
+    ~QStaticTextPrivate();
+
+    void init();
+    void paintText(QPainter *p);
+
+    QAtomicInt ref;                      // 4 bytes per text
+
+    QString text;                        // 4 bytes per text
+    QFont font;                          // 8 bytes per text
+    QSizeF maximumSize;                  // 16 bytes per text
+    QSizeF actualSize;                   // 16 bytes per text
+    QPointF position;                    // 16 bytes per text
+
+    QTransform matrix;                   // 80 bytes per text
+    QStaticTextItem *items;              // 4 bytes per text
+    int itemCount;                       // 4 bytes per text
+    glyph_t *glyphPool;                  // 4 bytes per text
+    QFixedPoint *positionPool;           // 4 bytes per text
+
+    char needsClipRect           : 1;    // 1 byte per text
+    char useBackendOptimizations : 1;
+    char textFormat              : 2;
+                                         // ================
+                                         // 171 bytes per text
+
+    static QStaticTextPrivate *get(const QStaticText *q);
+};
+
+QT_END_NAMESPACE
+
+#endif // QSTATICTEXT_P_H
diff --git a/src/gui/text/text.pri b/src/gui/text/text.pri
index b7615a4..9ec3142 100644
--- a/src/gui/text/text.pri
+++ b/src/gui/text/text.pri
@@ -37,7 +37,9 @@ HEADERS += \
 	text/qtexttable_p.h \
 	text/qzipreader_p.h \
 	text/qzipwriter_p.h \
-	text/qtextodfwriter_p.h
+	text/qtextodfwriter_p.h \
+	text/qstatictext_p.h \
+	text/qstatictext.h
 
 SOURCES += \
 	text/qfont.cpp \
@@ -66,7 +68,8 @@ SOURCES += \
 	text/qsyntaxhighlighter.cpp \
 	text/qcssparser.cpp \
 	text/qzip.cpp \
-	text/qtextodfwriter.cpp
+	text/qtextodfwriter.cpp \
+	text/qstatictext.cpp
 
 win32 {
 	SOURCES += \