diff -r 000000000000 -r 1918ee327afb src/gui/text/qtextdocument.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/text/qtextdocument.cpp	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,2940 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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 "qtextdocument.h"
+#include <qtextformat.h>
+#include "qtextdocumentlayout_p.h"
+#include "qtextdocumentfragment.h"
+#include "qtextdocumentfragment_p.h"
+#include "qtexttable.h"
+#include "qtextlist.h"
+#include <qdebug.h>
+#include <qregexp.h>
+#include <qvarlengtharray.h>
+#include <qtextcodec.h>
+#include <qthread.h>
+#include "qtexthtmlparser_p.h"
+#include "qpainter.h"
+#include "qprinter.h"
+#include "qtextedit.h"
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qdir.h>
+#include <qapplication.h>
+#include "qtextcontrol_p.h"
+#include "private/qtextedit_p.h"
+
+#include "qtextdocument_p.h"
+#include <private/qprinter_p.h>
+
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_CORE_EXPORT unsigned int qt_int_sqrt(unsigned int n);
+
+/*!
+    Returns true if the string \a text is likely to be rich text;
+    otherwise returns false.
+
+    This function uses a fast and therefore simple heuristic. It
+    mainly checks whether there is something that looks like a tag
+    before the first line break. Although the result may be correct
+    for common cases, there is no guarantee.
+
+    This function is defined in the \c <QTextDocument> header file.
+*/
+bool Qt::mightBeRichText(const QString& text)
+{
+    if (text.isEmpty())
+        return false;
+    int start = 0;
+
+    while (start < text.length() && text.at(start).isSpace())
+        ++start;
+
+    // skip a leading <?xml ... ?> as for example with xhtml
+    if (text.mid(start, 5) == QLatin1String("<?xml")) {
+        while (start < text.length()) {
+            if (text.at(start) == QLatin1Char('?')
+                && start + 2 < text.length()
+                && text.at(start + 1) == QLatin1Char('>')) {
+                start += 2;
+                break;
+            }
+            ++start;
+        }
+
+        while (start < text.length() && text.at(start).isSpace())
+            ++start;
+    }
+
+    if (text.mid(start, 5).toLower() == QLatin1String("<!doc"))
+        return true;
+    int open = start;
+    while (open < text.length() && text.at(open) != QLatin1Char('<')
+            && text.at(open) != QLatin1Char('\n')) {
+        if (text.at(open) == QLatin1Char('&') &&  text.mid(open+1,3) == QLatin1String("lt;"))
+            return true; // support desperate attempt of user to see <...>
+        ++open;
+    }
+    if (open < text.length() && text.at(open) == QLatin1Char('<')) {
+        const int close = text.indexOf(QLatin1Char('>'), open);
+        if (close > -1) {
+            QString tag;
+            for (int i = open+1; i < close; ++i) {
+                if (text[i].isDigit() || text[i].isLetter())
+                    tag += text[i];
+                else if (!tag.isEmpty() && text[i].isSpace())
+                    break;
+                else if (!text[i].isSpace() && (!tag.isEmpty() || text[i] != QLatin1Char('!')))
+                    return false; // that's not a tag
+            }
+#ifndef QT_NO_TEXTHTMLPARSER
+            return QTextHtmlParser::lookupElement(tag.toLower()) != -1;
+#else
+            return false;
+#endif // QT_NO_TEXTHTMLPARSER
+        }
+    }
+    return false;
+}
+
+/*!
+    Converts the plain text string \a plain to a HTML string with
+    HTML metacharacters \c{<}, \c{>}, and \c{&} replaced by HTML
+    entities.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_gui_text_qtextdocument.cpp 0
+
+    This function is defined in the \c <QTextDocument> header file.
+
+    \sa convertFromPlainText(), mightBeRichText()
+*/
+QString Qt::escape(const QString& plain)
+{
+    QString rich;
+    rich.reserve(int(plain.length() * 1.1));
+    for (int i = 0; i < plain.length(); ++i) {
+        if (plain.at(i) == QLatin1Char('<'))
+            rich += QLatin1String("&lt;");
+        else if (plain.at(i) == QLatin1Char('>'))
+            rich += QLatin1String("&gt;");
+        else if (plain.at(i) == QLatin1Char('&'))
+            rich += QLatin1String("&amp;");
+        else
+            rich += plain.at(i);
+    }
+    return rich;
+}
+
+/*!
+    \fn QString Qt::convertFromPlainText(const QString &plain, WhiteSpaceMode mode)
+
+    Converts the plain text string \a plain to an HTML-formatted
+    paragraph while preserving most of its look.
+
+    \a mode defines how whitespace is handled.
+
+    This function is defined in the \c <QTextDocument> header file.
+
+    \sa escape(), mightBeRichText()
+*/
+QString Qt::convertFromPlainText(const QString &plain, Qt::WhiteSpaceMode mode)
+{
+    int col = 0;
+    QString rich;
+    rich += QLatin1String("<p>");
+    for (int i = 0; i < plain.length(); ++i) {
+        if (plain[i] == QLatin1Char('\n')){
+            int c = 1;
+            while (i+1 < plain.length() && plain[i+1] == QLatin1Char('\n')) {
+                i++;
+                c++;
+            }
+            if (c == 1)
+                rich += QLatin1String("<br>\n");
+            else {
+                rich += QLatin1String("</p>\n");
+                while (--c > 1)
+                    rich += QLatin1String("<br>\n");
+                rich += QLatin1String("<p>");
+            }
+            col = 0;
+        } else {
+            if (mode == Qt::WhiteSpacePre && plain[i] == QLatin1Char('\t')){
+                rich += QChar(0x00a0U);
+                ++col;
+                while (col % 8) {
+                    rich += QChar(0x00a0U);
+                    ++col;
+                }
+            }
+            else if (mode == Qt::WhiteSpacePre && plain[i].isSpace())
+                rich += QChar(0x00a0U);
+            else if (plain[i] == QLatin1Char('<'))
+                rich += QLatin1String("&lt;");
+            else if (plain[i] == QLatin1Char('>'))
+                rich += QLatin1String("&gt;");
+            else if (plain[i] == QLatin1Char('&'))
+                rich += QLatin1String("&amp;");
+            else
+                rich += plain[i];
+            ++col;
+        }
+    }
+    if (col != 0)
+        rich += QLatin1String("</p>");
+    return rich;
+}
+
+#ifndef QT_NO_TEXTCODEC
+/*!
+    \internal
+
+    This function is defined in the \c <QTextDocument> header file.
+*/
+QTextCodec *Qt::codecForHtml(const QByteArray &ba)
+{
+    return QTextCodec::codecForHtml(ba);
+}
+#endif
+
+/*!
+    \class QTextDocument
+    \reentrant
+
+    \brief The QTextDocument class holds formatted text that can be
+    viewed and edited using a QTextEdit.
+
+    \ingroup richtext-processing
+
+
+    QTextDocument is a container for structured rich text documents, providing
+    support for styled text and various types of document elements, such as
+    lists, tables, frames, and images.
+    They can be created for use in a QTextEdit, or used independently.
+
+    Each document element is described by an associated format object. Each
+    format object is treated as a unique object by QTextDocuments, and can be
+    passed to objectForFormat() to obtain the document element that it is
+    applied to.
+
+    A QTextDocument can be edited programmatically using a QTextCursor, and
+    its contents can be examined by traversing the document structure. The
+    entire document structure is stored as a hierarchy of document elements
+    beneath the root frame, found with the rootFrame() function. Alternatively,
+    if you just want to iterate over the textual contents of the document you
+    can use begin(), end(), and findBlock() to retrieve text blocks that you
+    can examine and iterate over.
+
+    The layout of a document is determined by the documentLayout();
+    you can create your own QAbstractTextDocumentLayout subclass and
+    set it using setDocumentLayout() if you want to use your own
+    layout logic. The document's title and other meta-information can be
+    obtained by calling the metaInformation() function. For documents that
+    are exposed to users through the QTextEdit class, the document title
+    is also available via the QTextEdit::documentTitle() function.
+
+    The toPlainText() and toHtml() convenience functions allow you to retrieve the
+    contents of the document as plain text and HTML.
+    The document's text can be searched using the find() functions.
+
+    Undo/redo of operations performed on the document can be controlled using
+    the setUndoRedoEnabled() function. The undo/redo system can be controlled
+    by an editor widget through the undo() and redo() slots; the document also
+    provides contentsChanged(), undoAvailable(), and redoAvailable() signals
+    that inform connected editor widgets about the state of the undo/redo
+    system.
+
+    \sa QTextCursor, QTextEdit, \link richtext.html Rich Text Processing\endlink , {Text Object Example}
+*/
+
+/*!
+    \property QTextDocument::defaultFont
+    \brief the default font used to display the document's text
+*/
+
+/*!
+    \property QTextDocument::defaultTextOption
+    \brief the default text option will be set on all \l{QTextLayout}s in the document.
+
+    When \l{QTextBlock}s are created, the defaultTextOption is set on their
+    QTextLayout. This allows setting global properties for the document such as the
+    default word wrap mode.
+ */
+
+/*!
+    Constructs an empty QTextDocument with the given \a parent.
+*/
+QTextDocument::QTextDocument(QObject *parent)
+    : QObject(*new QTextDocumentPrivate, parent)
+{
+    Q_D(QTextDocument);
+    d->init();
+}
+
+/*!
+    Constructs a QTextDocument containing the plain (unformatted) \a text
+    specified, and with the given \a parent.
+*/
+QTextDocument::QTextDocument(const QString &text, QObject *parent)
+    : QObject(*new QTextDocumentPrivate, parent)
+{
+    Q_D(QTextDocument);
+    d->init();
+    QTextCursor(this).insertText(text);
+}
+
+/*!
+    \internal
+*/
+QTextDocument::QTextDocument(QTextDocumentPrivate &dd, QObject *parent)
+    : QObject(dd, parent)
+{
+    Q_D(QTextDocument);
+    d->init();
+}
+
+/*!
+    Destroys the document.
+*/
+QTextDocument::~QTextDocument()
+{
+}
+
+
+/*!
+  Creates a new QTextDocument that is a copy of this text document. \a
+  parent is the parent of the returned text document.
+*/
+QTextDocument *QTextDocument::clone(QObject *parent) const
+{
+    Q_D(const QTextDocument);
+    QTextDocument *doc = new QTextDocument(parent);
+    QTextCursor(doc).insertFragment(QTextDocumentFragment(this));
+    doc->rootFrame()->setFrameFormat(rootFrame()->frameFormat());
+    QTextDocumentPrivate *priv = doc->d_func();
+    priv->title = d->title;
+    priv->url = d->url;
+    priv->pageSize = d->pageSize;
+    priv->indentWidth = d->indentWidth;
+    priv->defaultTextOption = d->defaultTextOption;
+    priv->setDefaultFont(d->defaultFont());
+    priv->resources = d->resources;
+    priv->cachedResources.clear();
+#ifndef QT_NO_CSSPARSER
+    priv->defaultStyleSheet = d->defaultStyleSheet;
+    priv->parsedDefaultStyleSheet = d->parsedDefaultStyleSheet;
+#endif
+    return doc;
+}
+
+/*!
+    Returns true if the document is empty; otherwise returns false.
+*/
+bool QTextDocument::isEmpty() const
+{
+    Q_D(const QTextDocument);
+    /* because if we're empty we still have one single paragraph as
+     * one single fragment */
+    return d->length() <= 1;
+}
+
+/*!
+  Clears the document.
+*/
+void QTextDocument::clear()
+{
+    Q_D(QTextDocument);
+    d->clear();
+    d->resources.clear();
+}
+
+/*!
+    \since 4.2
+
+    Undoes the last editing operation on the document if undo is
+    available. The provided \a cursor is positioned at the end of the
+    location where the edition operation was undone.
+
+    See the \l {Overview of Qt's Undo Framework}{Qt Undo Framework}
+    documentation for details.
+
+    \sa undoAvailable(), isUndoRedoEnabled()
+*/
+void QTextDocument::undo(QTextCursor *cursor)
+{
+    Q_D(QTextDocument);
+    const int pos = d->undoRedo(true);
+    if (cursor && pos >= 0) {
+        *cursor = QTextCursor(this);
+        cursor->setPosition(pos);
+    }
+}
+
+/*!
+    \since 4.2
+    Redoes the last editing operation on the document if \link
+    QTextDocument::isRedoAvailable() redo is available\endlink.
+
+    The provided \a cursor is positioned at the end of the location where
+    the edition operation was redone.
+*/
+void QTextDocument::redo(QTextCursor *cursor)
+{
+    Q_D(QTextDocument);
+    const int pos = d->undoRedo(false);
+    if (cursor && pos >= 0) {
+        *cursor = QTextCursor(this);
+        cursor->setPosition(pos);
+    }
+}
+
+/*!
+    \overload
+
+*/
+void QTextDocument::undo()
+{
+    Q_D(QTextDocument);
+    d->undoRedo(true);
+}
+
+/*!
+    \overload
+    Redoes the last editing operation on the document if \link
+    QTextDocument::isRedoAvailable() redo is available\endlink.
+*/
+void QTextDocument::redo()
+{
+    Q_D(QTextDocument);
+    d->undoRedo(false);
+}
+
+/*!
+    \internal
+
+    Appends a custom undo \a item to the undo stack.
+*/
+void QTextDocument::appendUndoItem(QAbstractUndoItem *item)
+{
+    Q_D(QTextDocument);
+    d->appendUndoItem(item);
+}
+
+/*!
+    \property QTextDocument::undoRedoEnabled
+    \brief whether undo/redo are enabled for this document
+
+    This defaults to true. If disabled, the undo stack is cleared and
+    no items will be added to it.
+*/
+void QTextDocument::setUndoRedoEnabled(bool enable)
+{
+    Q_D(QTextDocument);
+    d->enableUndoRedo(enable);
+}
+
+bool QTextDocument::isUndoRedoEnabled() const
+{
+    Q_D(const QTextDocument);
+    return d->isUndoRedoEnabled();
+}
+
+/*!
+    \property QTextDocument::maximumBlockCount
+    \since 4.2
+    \brief Specifies the limit for blocks in the document.
+
+    Specifies the maximum number of blocks the document may have. If there are
+    more blocks in the document that specified with this property blocks are removed
+    from the beginning of the document.
+
+    A negative or zero value specifies that the document may contain an unlimited
+    amount of blocks.
+
+    The default value is 0.
+
+    Note that setting this property will apply the limit immediately to the document
+    contents.
+
+    Setting this property also disables the undo redo history.
+
+    This property is undefined in documents with tables or frames.
+*/
+int QTextDocument::maximumBlockCount() const
+{
+    Q_D(const QTextDocument);
+    return d->maximumBlockCount;
+}
+
+void QTextDocument::setMaximumBlockCount(int maximum)
+{
+    Q_D(QTextDocument);
+    d->maximumBlockCount = maximum;
+    d->ensureMaximumBlockCount();
+    setUndoRedoEnabled(false);
+}
+
+/*!
+    \since 4.3
+
+    The default text option is used on all QTextLayout objects in the document.
+    This allows setting global properties for the document such as the default
+    word wrap mode.
+*/
+QTextOption QTextDocument::defaultTextOption() const
+{
+    Q_D(const QTextDocument);
+    return d->defaultTextOption;
+}
+
+/*!
+    \since 4.3
+
+    Sets the default text option.
+*/
+void QTextDocument::setDefaultTextOption(const QTextOption &option)
+{
+    Q_D(QTextDocument);
+    d->defaultTextOption = option;
+    if (d->lout)
+        d->lout->documentChanged(0, 0, d->length());
+}
+
+/*!
+    \fn void QTextDocument::markContentsDirty(int position, int length)
+
+    Marks the contents specified by the given \a position and \a length
+    as "dirty", informing the document that it needs to be laid out
+    again.
+*/
+void QTextDocument::markContentsDirty(int from, int length)
+{
+    Q_D(QTextDocument);
+    if (!d->inContentsChange)
+        d->beginEditBlock();
+    d->documentChange(from, length);
+    if (!d->inContentsChange)
+        d->endEditBlock();
+}
+
+/*!
+    \property QTextDocument::useDesignMetrics
+    \since 4.1
+    \brief whether the document uses design metrics of fonts to improve the accuracy of text layout
+
+    If this property is set to true, the layout will use design metrics.
+    Otherwise, the metrics of the paint device as set on
+    QAbstractTextDocumentLayout::setPaintDevice() will be used.
+
+    Using design metrics makes a layout have a width that is no longer dependent on hinting
+    and pixel-rounding. This means that WYSIWYG text layout becomes possible because the width
+    scales much more linearly based on paintdevice metrics than it would otherwise.
+
+    By default, this property is false.
+*/
+
+void QTextDocument::setUseDesignMetrics(bool b)
+{
+    Q_D(QTextDocument);
+    if (b == d->defaultTextOption.useDesignMetrics())
+        return;
+    d->defaultTextOption.setUseDesignMetrics(b);
+    if (d->lout)
+        d->lout->documentChanged(0, 0, d->length());
+}
+
+bool QTextDocument::useDesignMetrics() const
+{
+    Q_D(const QTextDocument);
+    return d->defaultTextOption.useDesignMetrics();
+}
+
+/*!
+    \since 4.2
+
+    Draws the content of the document with painter \a p, clipped to \a rect.
+    If \a rect is a null rectangle (default) then the document is painted unclipped.
+*/
+void QTextDocument::drawContents(QPainter *p, const QRectF &rect)
+{
+    p->save();
+    QAbstractTextDocumentLayout::PaintContext ctx;
+    if (rect.isValid()) {
+        p->setClipRect(rect);
+        ctx.clip = rect;
+    }
+    documentLayout()->draw(p, ctx);
+    p->restore();
+}
+
+/*!
+    \property QTextDocument::textWidth
+    \since 4.2
+
+    The text width specifies the preferred width for text in the document. If
+    the text (or content in general) is wider than the specified with it is broken
+    into multiple lines and grows vertically. If the text cannot be broken into multiple
+    lines to fit into the specified text width it will be larger and the size() and the
+    idealWidth() property will reflect that.
+
+    If the text width is set to -1 then the text will not be broken into multiple lines
+    unless it is enforced through an explicit line break or a new paragraph.
+
+    The default value is -1.
+
+    Setting the text width will also set the page height to -1, causing the document to
+    grow or shrink vertically in a continuous way. If you want the document layout to break
+    the text into multiple pages then you have to set the pageSize property instead.
+
+    \sa size(), idealWidth(), pageSize()
+*/
+void QTextDocument::setTextWidth(qreal width)
+{
+    Q_D(QTextDocument);
+    QSizeF sz = d->pageSize;
+    sz.setWidth(width);
+    sz.setHeight(-1);
+    setPageSize(sz);
+}
+
+qreal QTextDocument::textWidth() const
+{
+    Q_D(const QTextDocument);
+    return d->pageSize.width();
+}
+
+/*!
+    \since 4.2
+
+    Returns the ideal width of the text document. The ideal width is the actually used width
+    of the document without optional alignments taken into account. It is always <= size().width().
+
+    \sa adjustSize(), textWidth
+*/
+qreal QTextDocument::idealWidth() const
+{
+    if (QTextDocumentLayout *lout = qobject_cast<QTextDocumentLayout *>(documentLayout()))
+        return lout->idealWidth();
+    return textWidth();
+}
+
+/*!
+    \property QTextDocument::documentMargin
+    \since 4.5
+
+     The margin around the document. The default is 4.
+*/
+qreal QTextDocument::documentMargin() const
+{
+    Q_D(const QTextDocument);
+    return d->documentMargin;
+}
+
+void QTextDocument::setDocumentMargin(qreal margin)
+{
+    Q_D(QTextDocument);
+    if (d->documentMargin != margin) {
+        d->documentMargin = margin;
+
+        QTextFrame* root = rootFrame();
+        QTextFrameFormat format = root->frameFormat();
+        format.setMargin(margin);
+        root->setFrameFormat(format);
+
+        if (d->lout)
+            d->lout->documentChanged(0, 0, d->length());
+    }
+}
+
+
+/*!
+    \property QTextDocument::indentWidth
+    \since 4.4
+
+    Returns the width used for text list and text block indenting.
+
+    The indent properties of QTextListFormat and QTextBlockFormat specify
+    multiples of this value. The default indent width is 40.
+*/
+qreal QTextDocument::indentWidth() const
+{
+    Q_D(const QTextDocument);
+    return d->indentWidth;
+}
+
+
+/*!
+    \since 4.4
+
+    Sets the \a width used for text list and text block indenting.
+
+    The indent properties of QTextListFormat and QTextBlockFormat specify
+    multiples of this value. The default indent width is 40 .
+
+    \sa indentWidth()
+*/
+void QTextDocument::setIndentWidth(qreal width)
+{
+    Q_D(QTextDocument);
+    if (d->indentWidth != width) {
+        d->indentWidth = width;
+        if (d->lout)
+            d->lout->documentChanged(0, 0, d->length());
+    }
+}
+
+
+
+
+/*!
+    \since 4.2
+
+    Adjusts the document to a reasonable size.
+
+    \sa idealWidth(), textWidth, size
+*/
+void QTextDocument::adjustSize()
+{
+    // Pull this private function in from qglobal.cpp
+    QFont f = defaultFont();
+    QFontMetrics fm(f);
+    int mw =  fm.width(QLatin1Char('x')) * 80;
+    int w = mw;
+    setTextWidth(w);
+    QSizeF size = documentLayout()->documentSize();
+    if (size.width() != 0) {
+        w = qt_int_sqrt((uint)(5 * size.height() * size.width() / 3));
+        setTextWidth(qMin(w, mw));
+
+        size = documentLayout()->documentSize();
+        if (w*3 < 5*size.height()) {
+            w = qt_int_sqrt((uint)(2 * size.height() * size.width()));
+            setTextWidth(qMin(w, mw));
+        }
+    }
+    setTextWidth(idealWidth());
+}
+
+/*!
+    \property QTextDocument::size
+    \since 4.2
+
+    Returns the actual size of the document.
+    This is equivalent to documentLayout()->documentSize();
+
+    The size of the document can be changed either by setting
+    a text width or setting an entire page size.
+
+    Note that the width is always >= pageSize().width().
+
+    By default, for a newly-created, empty document, this property contains
+    a configuration-dependent size.
+
+    \sa setTextWidth(), setPageSize(), idealWidth()
+*/
+QSizeF QTextDocument::size() const
+{
+    return documentLayout()->documentSize();
+}
+
+/*!
+    \property QTextDocument::blockCount
+    \since 4.2
+
+    Returns the number of text blocks in the document.
+
+    The value of this property is undefined in documents with tables or frames.
+
+    By default, if defined, this property contains a value of 1.
+    \sa lineCount(), characterCount()
+*/
+int QTextDocument::blockCount() const
+{
+    Q_D(const QTextDocument);
+    return d->blockMap().numNodes();
+}
+
+
+/*!
+  \since 4.5
+
+  Returns the number of lines of this document (if the layout supports
+  this). Otherwise, this is identical to the number of blocks.
+
+  \sa blockCount(), characterCount()
+ */
+int QTextDocument::lineCount() const
+{
+    Q_D(const QTextDocument);
+    return d->blockMap().length(2);
+}
+
+/*!
+  \since 4.5
+
+  Returns the number of characters of this document.
+
+  \sa blockCount(), characterAt()
+ */
+int QTextDocument::characterCount() const
+{
+    Q_D(const QTextDocument);
+    return d->length();
+}
+
+/*!
+  \since 4.5
+
+  Returns the character at position \a pos, or a null character if the
+  position is out of range.
+
+  \sa characterCount()
+ */
+QChar QTextDocument::characterAt(int pos) const
+{
+    Q_D(const QTextDocument);
+    if (pos < 0 || pos >= d->length())
+        return QChar();
+    QTextDocumentPrivate::FragmentIterator fragIt = d->find(pos);
+    const QTextFragmentData * const frag = fragIt.value();
+    const int offsetInFragment = qMax(0, pos - fragIt.position());
+    return d->text.at(frag->stringPosition + offsetInFragment);
+}
+
+
+/*!
+    \property QTextDocument::defaultStyleSheet
+    \since 4.2
+
+    The default style sheet is applied to all newly HTML formatted text that is
+    inserted into the document, for example using setHtml() or QTextCursor::insertHtml().
+
+    The style sheet needs to be compliant to CSS 2.1 syntax.
+
+    \bold{Note:} Changing the default style sheet does not have any effect to the existing content
+    of the document.
+
+    \sa {Supported HTML Subset}
+*/
+
+#ifndef QT_NO_CSSPARSER
+void QTextDocument::setDefaultStyleSheet(const QString &sheet)
+{
+    Q_D(QTextDocument);
+    d->defaultStyleSheet = sheet;
+    QCss::Parser parser(sheet);
+    d->parsedDefaultStyleSheet = QCss::StyleSheet();
+    d->parsedDefaultStyleSheet.origin = QCss::StyleSheetOrigin_UserAgent;
+    parser.parse(&d->parsedDefaultStyleSheet);
+}
+
+QString QTextDocument::defaultStyleSheet() const
+{
+    Q_D(const QTextDocument);
+    return d->defaultStyleSheet;
+}
+#endif // QT_NO_CSSPARSER
+
+/*!
+    \fn void QTextDocument::contentsChanged()
+
+    This signal is emitted whenever the document's content changes; for
+    example, when text is inserted or deleted, or when formatting is applied.
+
+    \sa contentsChange()
+*/
+
+/*!
+    \fn void QTextDocument::contentsChange(int position, int charsRemoved, int charsAdded)
+
+    This signal is emitted whenever the document's content changes; for
+    example, when text is inserted or deleted, or when formatting is applied.
+
+    Information is provided about the \a position of the character in the
+    document where the change occurred, the number of characters removed
+    (\a charsRemoved), and the number of characters added (\a charsAdded).
+
+    The signal is emitted before the document's layout manager is notified
+    about the change. This hook allows you to implement syntax highlighting
+    for the document.
+
+    \sa QAbstractTextDocumentLayout::documentChanged(), contentsChanged()
+*/
+
+
+/*!
+    \fn QTextDocument::undoAvailable(bool available);
+
+    This signal is emitted whenever undo operations become available
+    (\a available is true) or unavailable (\a available is false).
+
+    See the \l {Overview of Qt's Undo Framework}{Qt Undo Framework}
+    documentation for details.
+
+    \sa undo(), isUndoRedoEnabled()
+*/
+
+/*!
+    \fn QTextDocument::redoAvailable(bool available);
+
+    This signal is emitted whenever redo operations become available
+    (\a available is true) or unavailable (\a available is false).
+*/
+
+/*!
+    \fn QTextDocument::cursorPositionChanged(const QTextCursor &cursor);
+
+    This signal is emitted whenever the position of a cursor changed
+    due to an editing operation. The cursor that changed is passed in
+    \a cursor.  If you need a signal when the cursor is moved with the
+    arrow keys you can use the \l{QTextEdit::}{cursorPositionChanged()} signal in
+    QTextEdit.
+*/
+
+/*!
+    \fn QTextDocument::blockCountChanged(int newBlockCount);
+    \since 4.3
+
+    This signal is emitted when the total number of text blocks in the
+    document changes. The value passed in \a newBlockCount is the new
+    total.
+*/
+
+/*!
+    \fn QTextDocument::documentLayoutChanged();
+    \since 4.4
+
+    This signal is emitted when a new document layout is set.
+
+    \sa setDocumentLayout()
+
+*/
+
+
+/*!
+    Returns true if undo is available; otherwise returns false.
+*/
+bool QTextDocument::isUndoAvailable() const
+{
+    Q_D(const QTextDocument);
+    return d->isUndoAvailable();
+}
+
+/*!
+    Returns true if redo is available; otherwise returns false.
+*/
+bool QTextDocument::isRedoAvailable() const
+{
+    Q_D(const QTextDocument);
+    return d->isRedoAvailable();
+}
+
+
+/*! \since 4.4
+
+    Returns the document's revision (if undo is enabled).
+
+    The revision is guaranteed to increase when a document that is not
+    modified is edited.
+
+    \sa QTextBlock::revision(), isModified()
+ */
+int QTextDocument::revision() const
+{
+    Q_D(const QTextDocument);
+    return d->revision;
+}
+
+
+
+/*!
+    Sets the document to use the given \a layout. The previous layout
+    is deleted.
+
+    \sa documentLayoutChanged()
+*/
+void QTextDocument::setDocumentLayout(QAbstractTextDocumentLayout *layout)
+{
+    Q_D(QTextDocument);
+    d->setLayout(layout);
+}
+
+/*!
+    Returns the document layout for this document.
+*/
+QAbstractTextDocumentLayout *QTextDocument::documentLayout() const
+{
+    Q_D(const QTextDocument);
+    if (!d->lout) {
+        QTextDocument *that = const_cast<QTextDocument *>(this);
+        that->d_func()->setLayout(new QTextDocumentLayout(that));
+    }
+    return d->lout;
+}
+
+
+/*!
+    Returns meta information about the document of the type specified by
+    \a info.
+
+    \sa setMetaInformation()
+*/
+QString QTextDocument::metaInformation(MetaInformation info) const
+{
+    Q_D(const QTextDocument);
+    switch (info) {
+    case DocumentTitle:
+        return d->title;
+    case DocumentUrl:
+        return d->url;
+    }
+    return QString();
+}
+
+/*!
+    Sets the document's meta information of the type specified by \a info
+    to the given \a string.
+
+    \sa metaInformation()
+*/
+void QTextDocument::setMetaInformation(MetaInformation info, const QString &string)
+{
+    Q_D(QTextDocument);
+    switch (info) {
+    case DocumentTitle:
+        d->title = string;
+        break;
+    case DocumentUrl:
+        d->url = string;
+        break;
+    }
+}
+
+/*!
+    Returns the plain text contained in the document. If you want
+    formatting information use a QTextCursor instead.
+
+    \sa toHtml()
+*/
+QString QTextDocument::toPlainText() const
+{
+    Q_D(const QTextDocument);
+    QString txt = d->plainText();
+
+    QChar *uc = txt.data();
+    QChar *e = uc + txt.size();
+
+    for (; uc != e; ++uc) {
+        switch (uc->unicode()) {
+        case 0xfdd0: // QTextBeginningOfFrame
+        case 0xfdd1: // QTextEndOfFrame
+        case QChar::ParagraphSeparator:
+        case QChar::LineSeparator:
+            *uc = QLatin1Char('\n');
+            break;
+        case QChar::Nbsp:
+            *uc = QLatin1Char(' ');
+            break;
+        default:
+            ;
+        }
+    }
+    return txt;
+}
+
+/*!
+    Replaces the entire contents of the document with the given plain
+    \a text.
+
+    \sa setHtml()
+*/
+void QTextDocument::setPlainText(const QString &text)
+{
+    Q_D(QTextDocument);
+    bool previousState = d->isUndoRedoEnabled();
+    d->enableUndoRedo(false);
+    d->beginEditBlock();
+    d->clear();
+    QTextCursor(this).insertText(text);
+    d->endEditBlock();
+    d->enableUndoRedo(previousState);
+}
+
+/*!
+    Replaces the entire contents of the document with the given
+    HTML-formatted text in the \a html string.
+
+    The HTML formatting is respected as much as possible; for example,
+    "<b>bold</b> text" will produce text where the first word has a font
+    weight that gives it a bold appearance: "\bold{bold} text".
+
+    \note It is the responsibility of the caller to make sure that the
+    text is correctly decoded when a QString containing HTML is created
+    and passed to setHtml().
+
+    \sa setPlainText(), {Supported HTML Subset}
+*/
+
+#ifndef QT_NO_TEXTHTMLPARSER
+
+void QTextDocument::setHtml(const QString &html)
+{
+    Q_D(QTextDocument);
+    bool previousState = d->isUndoRedoEnabled();
+    d->enableUndoRedo(false);
+    d->beginEditBlock();
+    d->clear();
+    QTextHtmlImporter(this, html, QTextHtmlImporter::ImportToDocument).import();
+    d->endEditBlock();
+    d->enableUndoRedo(previousState);
+}
+
+#endif // QT_NO_TEXTHTMLPARSER
+
+/*!
+    \enum QTextDocument::FindFlag
+
+    This enum describes the options available to QTextDocument's find function. The options
+    can be OR-ed together from the following list:
+
+    \value FindBackward Search backwards instead of forwards.
+    \value FindCaseSensitively By default find works case insensitive. Specifying this option
+    changes the behaviour to a case sensitive find operation.
+    \value FindWholeWords Makes find match only complete words.
+*/
+
+/*!
+    \enum QTextDocument::MetaInformation
+
+    This enum describes the different types of meta information that can be
+    added to a document.
+
+    \value DocumentTitle    The title of the document.
+    \value DocumentUrl      The url of the document. The loadResource() function uses
+                            this url as the base when loading relative resources.
+
+    \sa metaInformation(), setMetaInformation()
+*/
+
+/*!
+    \fn QTextCursor QTextDocument::find(const QString &subString, int position, FindFlags options) const
+
+    \overload
+
+    Finds the next occurrence of the string, \a subString, in the document.
+    The search starts at the given \a position, and proceeds forwards
+    through the document unless specified otherwise in the search options.
+    The \a options control the type of search performed.
+
+    Returns a cursor with the match selected if \a subString
+    was found; otherwise returns a null cursor.
+
+    If the \a position is 0 (the default) the search begins from the beginning
+    of the document; otherwise it begins at the specified position.
+*/
+QTextCursor QTextDocument::find(const QString &subString, int from, FindFlags options) const
+{
+    QRegExp expr(subString);
+    expr.setPatternSyntax(QRegExp::FixedString);
+    expr.setCaseSensitivity((options & QTextDocument::FindCaseSensitively) ? Qt::CaseSensitive : Qt::CaseInsensitive);
+
+    return find(expr, from, options);
+}
+
+/*!
+    \fn QTextCursor QTextDocument::find(const QString &subString, const QTextCursor &cursor, FindFlags options) const
+
+    Finds the next occurrence of the string, \a subString, in the document.
+    The search starts at the position of the given \a cursor, and proceeds
+    forwards through the document unless specified otherwise in the search
+    options. The \a options control the type of search performed.
+
+    Returns a cursor with the match selected if \a subString was found; otherwise
+    returns a null cursor.
+
+    If the given \a cursor has a selection, the search begins after the
+    selection; otherwise it begins at the cursor's position.
+
+    By default the search is case-sensitive, and can match text anywhere in the
+    document.
+*/
+QTextCursor QTextDocument::find(const QString &subString, const QTextCursor &from, FindFlags options) const
+{
+    int pos = 0;
+    if (!from.isNull()) {
+        if (options & QTextDocument::FindBackward)
+            pos = from.selectionStart();
+        else
+            pos = from.selectionEnd();
+    }
+    QRegExp expr(subString);
+    expr.setPatternSyntax(QRegExp::FixedString);
+    expr.setCaseSensitivity((options & QTextDocument::FindCaseSensitively) ? Qt::CaseSensitive : Qt::CaseInsensitive);
+
+    return find(expr, pos, options);
+}
+
+
+static bool findInBlock(const QTextBlock &block, const QRegExp &expression, int offset,
+                        QTextDocument::FindFlags options, QTextCursor &cursor)
+{
+    const QRegExp expr(expression);
+    QString text = block.text();
+    text.replace(QChar::Nbsp, QLatin1Char(' '));
+
+    int idx = -1;
+    while (offset >=0 && offset <= text.length()) {
+        idx = (options & QTextDocument::FindBackward) ?
+               expr.lastIndexIn(text, offset) : expr.indexIn(text, offset);
+        if (idx == -1)
+            return false;
+
+        if (options & QTextDocument::FindWholeWords) {
+            const int start = idx;
+            const int end = start + expr.matchedLength();
+            if ((start != 0 && text.at(start - 1).isLetterOrNumber())
+                || (end != text.length() && text.at(end).isLetterOrNumber())) {
+                //if this is not a whole word, continue the search in the string
+                offset = (options & QTextDocument::FindBackward) ? idx-1 : end+1;
+                idx = -1;
+                continue;
+            }
+        }
+        //we have a hit, return the cursor for that.
+        break;
+    }
+    if (idx == -1)
+        return false;
+    cursor = QTextCursor(block.docHandle(), block.position() + idx);
+    cursor.setPosition(cursor.position() + expr.matchedLength(), QTextCursor::KeepAnchor);
+    return true;
+}
+
+/*!
+    \fn QTextCursor QTextDocument::find(const QRegExp & expr, int position, FindFlags options) const
+
+    \overload
+
+    Finds the next occurrence, matching the regular expression, \a expr, in the document.
+    The search starts at the given \a position, and proceeds forwards
+    through the document unless specified otherwise in the search options.
+    The \a options control the type of search performed. The FindCaseSensitively
+    option is ignored for this overload, use QRegExp::caseSensitivity instead.
+
+    Returns a cursor with the match selected if a match was found; otherwise
+    returns a null cursor.
+
+    If the \a position is 0 (the default) the search begins from the beginning
+    of the document; otherwise it begins at the specified position.
+*/
+QTextCursor QTextDocument::find(const QRegExp & expr, int from, FindFlags options) const
+{
+    Q_D(const QTextDocument);
+
+    if (expr.isEmpty())
+        return QTextCursor();
+
+    int pos = from;
+    //the cursor is positioned between characters, so for a backward search
+    //do not include the character given in the position.
+    if (options & FindBackward) {
+        --pos ;
+        if(pos < 0)
+            return QTextCursor();
+    }
+
+    QTextCursor cursor;
+    QTextBlock block = d->blocksFind(pos);
+
+    if (!(options & FindBackward)) {
+       int blockOffset = qMax(0, pos - block.position());
+        while (block.isValid()) {
+            if (findInBlock(block, expr, blockOffset, options, cursor))
+                return cursor;
+            blockOffset = 0;
+            block = block.next();
+        }
+    } else {
+        int blockOffset = pos - block.position();
+        while (block.isValid()) {
+            if (findInBlock(block, expr, blockOffset, options, cursor))
+                return cursor;
+            block = block.previous();
+            blockOffset = block.length() - 1;
+        }
+    }
+
+    return QTextCursor();
+}
+
+/*!
+    \fn QTextCursor QTextDocument::find(const QRegExp &expr, const QTextCursor &cursor, FindFlags options) const
+
+    Finds the next occurrence, matching the regular expression, \a expr, in the document.
+    The search starts at the position of the given \a cursor, and proceeds
+    forwards through the document unless specified otherwise in the search
+    options. The \a options control the type of search performed. The FindCaseSensitively
+    option is ignored for this overload, use QRegExp::caseSensitivity instead.
+
+    Returns a cursor with the match selected if a match was found; otherwise
+    returns a null cursor.
+
+    If the given \a cursor has a selection, the search begins after the
+    selection; otherwise it begins at the cursor's position.
+
+    By default the search is case-sensitive, and can match text anywhere in the
+    document.
+*/
+QTextCursor QTextDocument::find(const QRegExp &expr, const QTextCursor &from, FindFlags options) const
+{
+    int pos = 0;
+    if (!from.isNull()) {
+        if (options & QTextDocument::FindBackward)
+            pos = from.selectionStart();
+        else
+            pos = from.selectionEnd();
+    }
+    return find(expr, pos, options);
+}
+
+
+/*!
+    \fn QTextObject *QTextDocument::createObject(const QTextFormat &format)
+
+    Creates and returns a new document object (a QTextObject), based
+    on the given \a format.
+
+    QTextObjects will always get created through this method, so you
+    must reimplement it if you use custom text objects inside your document.
+*/
+QTextObject *QTextDocument::createObject(const QTextFormat &f)
+{
+    QTextObject *obj = 0;
+    if (f.isListFormat())
+        obj = new QTextList(this);
+    else if (f.isTableFormat())
+        obj = new QTextTable(this);
+    else if (f.isFrameFormat())
+        obj = new QTextFrame(this);
+
+    return obj;
+}
+
+/*!
+    \internal
+
+    Returns the frame that contains the text cursor position \a pos.
+*/
+QTextFrame *QTextDocument::frameAt(int pos) const
+{
+    Q_D(const QTextDocument);
+    return d->frameAt(pos);
+}
+
+/*!
+    Returns the document's root frame.
+*/
+QTextFrame *QTextDocument::rootFrame() const
+{
+    Q_D(const QTextDocument);
+    return d->rootFrame();
+}
+
+/*!
+    Returns the text object associated with the given \a objectIndex.
+*/
+QTextObject *QTextDocument::object(int objectIndex) const
+{
+    Q_D(const QTextDocument);
+    return d->objectForIndex(objectIndex);
+}
+
+/*!
+    Returns the text object associated with the format \a f.
+*/
+QTextObject *QTextDocument::objectForFormat(const QTextFormat &f) const
+{
+    Q_D(const QTextDocument);
+    return d->objectForFormat(f);
+}
+
+
+/*!
+    Returns the text block that contains the \a{pos}-th character.
+*/
+QTextBlock QTextDocument::findBlock(int pos) const
+{
+    Q_D(const QTextDocument);
+    return QTextBlock(docHandle(), d->blockMap().findNode(pos));
+}
+
+/*!
+    \since 4.4
+    Returns the text block with the specified \a blockNumber.
+
+    \sa QTextBlock::blockNumber()
+*/
+QTextBlock QTextDocument::findBlockByNumber(int blockNumber) const
+{
+    Q_D(const QTextDocument);
+    return QTextBlock(docHandle(), d->blockMap().findNode(blockNumber, 1));
+}
+
+/*!
+    \since 4.5
+    Returns the text block that contains the specified \a lineNumber.
+
+    \sa QTextBlock::firstLineNumber()
+*/
+QTextBlock QTextDocument::findBlockByLineNumber(int lineNumber) const
+{
+    Q_D(const QTextDocument);
+    return QTextBlock(docHandle(), d->blockMap().findNode(lineNumber, 2));
+}
+
+/*!
+    Returns the document's first text block.
+
+    \sa firstBlock()
+*/
+QTextBlock QTextDocument::begin() const
+{
+    Q_D(const QTextDocument);
+    return QTextBlock(docHandle(), d->blockMap().begin().n);
+}
+
+/*!
+    This function returns a block to test for the end of the document
+    while iterating over it.
+
+    \snippet doc/src/snippets/textdocumentendsnippet.cpp 0
+
+    The block returned is invalid and represents the block after the
+    last block in the document. You can use lastBlock() to retrieve the
+    last valid block of the document.
+
+    \sa lastBlock()
+*/
+QTextBlock QTextDocument::end() const
+{
+    return QTextBlock(docHandle(), 0);
+}
+
+/*!
+    \since 4.4
+    Returns the document's first text block.
+*/
+QTextBlock QTextDocument::firstBlock() const
+{
+    Q_D(const QTextDocument);
+    return QTextBlock(docHandle(), d->blockMap().begin().n);
+}
+
+/*!
+    \since 4.4
+    Returns the document's last (valid) text block.
+*/
+QTextBlock QTextDocument::lastBlock() const
+{
+    Q_D(const QTextDocument);
+    return QTextBlock(docHandle(), d->blockMap().last().n);
+}
+
+/*!
+    \property QTextDocument::pageSize
+    \brief the page size that should be used for laying out the document
+
+    By default, for a newly-created, empty document, this property contains
+    an undefined size.
+
+    \sa modificationChanged()
+*/
+
+void QTextDocument::setPageSize(const QSizeF &size)
+{
+    Q_D(QTextDocument);
+    d->pageSize = size;
+    if (d->lout)
+        d->lout->documentChanged(0, 0, d->length());
+}
+
+QSizeF QTextDocument::pageSize() const
+{
+    Q_D(const QTextDocument);
+    return d->pageSize;
+}
+
+/*!
+  returns the number of pages in this document.
+*/
+int QTextDocument::pageCount() const
+{
+    return documentLayout()->pageCount();
+}
+
+/*!
+    Sets the default \a font to use in the document layout.
+*/
+void QTextDocument::setDefaultFont(const QFont &font)
+{
+    Q_D(QTextDocument);
+    d->setDefaultFont(font);
+    if (d->lout)
+        d->lout->documentChanged(0, 0, d->length());
+}
+
+/*!
+    Returns the default font to be used in the document layout.
+*/
+QFont QTextDocument::defaultFont() const
+{
+    Q_D(const QTextDocument);
+    return d->defaultFont();
+}
+
+/*!
+    \fn QTextDocument::modificationChanged(bool changed)
+
+    This signal is emitted whenever the content of the document
+    changes in a way that affects the modification state. If \a
+    changed is true, the document has been modified; otherwise it is
+    false.
+
+    For example, calling setModified(false) on a document and then
+    inserting text causes the signal to get emitted. If you undo that
+    operation, causing the document to return to its original
+    unmodified state, the signal will get emitted again.
+*/
+
+/*!
+    \property QTextDocument::modified
+    \brief whether the document has been modified by the user
+
+    By default, this property is false.
+
+    \sa modificationChanged()
+*/
+
+bool QTextDocument::isModified() const
+{
+    return docHandle()->isModified();
+}
+
+void QTextDocument::setModified(bool m)
+{
+    docHandle()->setModified(m);
+}
+
+#ifndef QT_NO_PRINTER
+static void printPage(int index, QPainter *painter, const QTextDocument *doc, const QRectF &body, const QPointF &pageNumberPos)
+{
+    painter->save();
+    painter->translate(body.left(), body.top() - (index - 1) * body.height());
+    QRectF view(0, (index - 1) * body.height(), body.width(), body.height());
+
+    QAbstractTextDocumentLayout *layout = doc->documentLayout();
+    QAbstractTextDocumentLayout::PaintContext ctx;
+
+    painter->setClipRect(view);
+    ctx.clip = view;
+
+    // don't use the system palette text as default text color, on HP/UX
+    // for example that's white, and white text on white paper doesn't
+    // look that nice
+    ctx.palette.setColor(QPalette::Text, Qt::black);
+
+    layout->draw(painter, ctx);
+
+    if (!pageNumberPos.isNull()) {
+        painter->setClipping(false);
+        painter->setFont(QFont(doc->defaultFont()));
+        const QString pageString = QString::number(index);
+
+        painter->drawText(qRound(pageNumberPos.x() - painter->fontMetrics().width(pageString)),
+                          qRound(pageNumberPos.y() + view.top()),
+                          pageString);
+    }
+
+    painter->restore();
+}
+
+extern int qt_defaultDpi();
+
+/*!
+    Prints the document to the given \a printer. The QPrinter must be
+    set up before being used with this function.
+
+    This is only a convenience method to print the whole document to the printer.
+
+    If the document is already paginated through a specified height in the pageSize()
+    property it is printed as-is.
+
+    If the document is not paginated, like for example a document used in a QTextEdit,
+    then a temporary copy of the document is created and the copy is broken into
+    multiple pages according to the size of the QPrinter's paperRect(). By default
+    a 2 cm margin is set around the document contents. In addition the current page
+    number is printed at the bottom of each page.
+
+    Note that QPrinter::Selection is not supported as print range with this function since
+    the selection is a property of QTextCursor. If you have a QTextEdit associated with
+    your QTextDocument then you can use QTextEdit's print() function because QTextEdit has
+    access to the user's selection.
+
+    \sa QTextEdit::print()
+*/
+
+void QTextDocument::print(QPrinter *printer) const
+{
+    Q_D(const QTextDocument);
+
+    if (!printer || !printer->isValid())
+        return;
+
+    if (!d->title.isEmpty())
+        printer->setDocName(d->title);
+
+    bool documentPaginated = d->pageSize.isValid() && !d->pageSize.isNull()
+                             && d->pageSize.height() != INT_MAX;
+
+    if (!documentPaginated && !printer->fullPage() && !printer->d_func()->hasCustomPageMargins)
+        printer->setPageMargins(23.53, 23.53, 23.53, 23.53, QPrinter::Millimeter);
+
+    QPainter p(printer);
+
+    // Check that there is a valid device to print to.
+    if (!p.isActive())
+        return;
+
+    const QTextDocument *doc = this;
+    QTextDocument *clonedDoc = 0;
+    (void)doc->documentLayout(); // make sure that there is a layout
+
+    QRectF body = QRectF(QPointF(0, 0), d->pageSize);
+    QPointF pageNumberPos;
+
+    if (documentPaginated) {
+        qreal sourceDpiX = qt_defaultDpi();
+        qreal sourceDpiY = sourceDpiX;
+
+        QPaintDevice *dev = doc->documentLayout()->paintDevice();
+        if (dev) {
+            sourceDpiX = dev->logicalDpiX();
+            sourceDpiY = dev->logicalDpiY();
+        }
+
+        const qreal dpiScaleX = qreal(printer->logicalDpiX()) / sourceDpiX;
+        const qreal dpiScaleY = qreal(printer->logicalDpiY()) / sourceDpiY;
+
+        // scale to dpi
+        p.scale(dpiScaleX, dpiScaleY);
+
+        QSizeF scaledPageSize = d->pageSize;
+        scaledPageSize.rwidth() *= dpiScaleX;
+        scaledPageSize.rheight() *= dpiScaleY;
+
+        const QSizeF printerPageSize(printer->pageRect().size());
+
+        // scale to page
+        p.scale(printerPageSize.width() / scaledPageSize.width(),
+                printerPageSize.height() / scaledPageSize.height());
+    } else {
+        doc = clone(const_cast<QTextDocument *>(this));
+        clonedDoc = const_cast<QTextDocument *>(doc);
+
+        for (QTextBlock srcBlock = firstBlock(), dstBlock = clonedDoc->firstBlock();
+             srcBlock.isValid() && dstBlock.isValid();
+             srcBlock = srcBlock.next(), dstBlock = dstBlock.next()) {
+            dstBlock.layout()->setAdditionalFormats(srcBlock.layout()->additionalFormats());
+        }
+
+        QAbstractTextDocumentLayout *layout = doc->documentLayout();
+        layout->setPaintDevice(p.device());
+
+        int dpiy = p.device()->logicalDpiY();
+        int margin = 0;
+        if (printer->fullPage() && !printer->d_func()->hasCustomPageMargins) {
+            // for compatibility
+            margin = (int) ((2/2.54)*dpiy); // 2 cm margins
+            QTextFrameFormat fmt = doc->rootFrame()->frameFormat();
+            fmt.setMargin(margin);
+            doc->rootFrame()->setFrameFormat(fmt);
+        }
+
+        QRectF pageRect(printer->pageRect());
+        body = QRectF(0, 0, pageRect.width(), pageRect.height());
+        pageNumberPos = QPointF(body.width() - margin,
+                                body.height() - margin
+                                + QFontMetrics(doc->defaultFont(), p.device()).ascent()
+                                + 5 * dpiy / 72.0);
+        clonedDoc->setPageSize(body.size());
+    }
+
+    int docCopies;
+    int pageCopies;
+    if (printer->collateCopies() == true){
+        docCopies = 1;
+        pageCopies = printer->numCopies();
+    } else {
+        docCopies = printer->numCopies();
+        pageCopies = 1;
+    }
+
+    int fromPage = printer->fromPage();
+    int toPage = printer->toPage();
+    bool ascending = true;
+
+    if (fromPage == 0 && toPage == 0) {
+        fromPage = 1;
+        toPage = doc->pageCount();
+    }
+    // paranoia check
+    fromPage = qMax(1, fromPage);
+    toPage = qMin(doc->pageCount(), toPage);
+
+    if (printer->pageOrder() == QPrinter::LastPageFirst) {
+        int tmp = fromPage;
+        fromPage = toPage;
+        toPage = tmp;
+        ascending = false;
+    }
+
+    for (int i = 0; i < docCopies; ++i) {
+
+        int page = fromPage;
+        while (true) {
+            for (int j = 0; j < pageCopies; ++j) {
+                if (printer->printerState() == QPrinter::Aborted
+                    || printer->printerState() == QPrinter::Error)
+                    goto UserCanceled;
+                printPage(page, &p, doc, body, pageNumberPos);
+                if (j < pageCopies - 1)
+                    printer->newPage();
+            }
+
+            if (page == toPage)
+                break;
+
+            if (ascending)
+                ++page;
+            else
+                --page;
+
+            printer->newPage();
+        }
+
+        if ( i < docCopies - 1)
+            printer->newPage();
+    }
+
+UserCanceled:
+    delete clonedDoc;
+}
+#endif
+
+/*!
+    \enum QTextDocument::ResourceType
+
+    This enum describes the types of resources that can be loaded by
+    QTextDocument's loadResource() function.
+
+    \value HtmlResource  The resource contains HTML.
+    \value ImageResource The resource contains image data.
+                         Currently supported data types are QVariant::Pixmap and
+                         QVariant::Image. If the corresponding variant is of type
+                         QVariant::ByteArray then Qt attempts to load the image using
+                         QImage::loadFromData. QVariant::Icon is currently not supported.
+                         The icon needs to be converted to one of the supported types first,
+                         for example using QIcon::pixmap.
+    \value StyleSheetResource The resource contains CSS.
+    \value UserResource  The first available value for user defined
+                         resource types.
+
+    \sa loadResource()
+*/
+
+/*!
+    Returns data of the specified \a type from the resource with the
+    given \a name.
+
+    This function is called by the rich text engine to request data that isn't
+    directly stored by QTextDocument, but still associated with it. For example,
+    images are referenced indirectly by the name attribute of a QTextImageFormat
+    object.
+
+    Resources are cached internally in the document. If a resource can
+    not be found in the cache, loadResource is called to try to load
+    the resource. loadResource should then use addResource to add the
+    resource to the cache.
+
+    \sa QTextDocument::ResourceType
+*/
+QVariant QTextDocument::resource(int type, const QUrl &name) const
+{
+    Q_D(const QTextDocument);
+    QVariant r = d->resources.value(name);
+    if (!r.isValid()) {
+        r = d->cachedResources.value(name);
+        if (!r.isValid())
+            r = const_cast<QTextDocument *>(this)->loadResource(type, name);
+    }
+    return r;
+}
+
+/*!
+    Adds the resource \a resource to the resource cache, using \a
+    type and \a name as identifiers. \a type should be a value from
+    QTextDocument::ResourceType.
+
+    For example, you can add an image as a resource in order to reference it
+    from within the document:
+
+    \snippet snippets/textdocument-resources/main.cpp Adding a resource
+
+    The image can be inserted into the document using the QTextCursor API:
+
+    \snippet snippets/textdocument-resources/main.cpp Inserting an image with a cursor
+
+    Alternatively, you can insert images using the HTML \c img tag:
+
+    \snippet snippets/textdocument-resources/main.cpp Inserting an image using HTML
+*/
+void QTextDocument::addResource(int type, const QUrl &name, const QVariant &resource)
+{
+    Q_UNUSED(type);
+    Q_D(QTextDocument);
+    d->resources.insert(name, resource);
+}
+
+/*!
+    Loads data of the specified \a type from the resource with the
+    given \a name.
+
+    This function is called by the rich text engine to request data that isn't
+    directly stored by QTextDocument, but still associated with it. For example,
+    images are referenced indirectly by the name attribute of a QTextImageFormat
+    object.
+
+    When called by Qt, \a type is one of the values of
+    QTextDocument::ResourceType.
+
+    If the QTextDocument is a child object of a QTextEdit, QTextBrowser,
+    or a QTextDocument itself then the default implementation tries
+    to retrieve the data from the parent.
+*/
+QVariant QTextDocument::loadResource(int type, const QUrl &name)
+{
+    Q_D(QTextDocument);
+    QVariant r;
+
+    QTextDocument *doc = qobject_cast<QTextDocument *>(parent());
+    if (doc) {
+        r = doc->loadResource(type, name);
+    }
+#ifndef QT_NO_TEXTEDIT
+    else if (QTextEdit *edit = qobject_cast<QTextEdit *>(parent())) {
+        QUrl resolvedName = edit->d_func()->resolveUrl(name);
+        r = edit->loadResource(type, resolvedName);
+    }
+#endif
+#ifndef QT_NO_TEXTCONTROL
+    else if (QTextControl *control = qobject_cast<QTextControl *>(parent())) {
+        r = control->loadResource(type, name);
+    }
+#endif
+
+    // if resource was not loaded try to load it here
+    if (!doc && r.isNull() && name.isRelative()) {
+        QUrl currentURL = d->url;
+        QUrl resourceUrl = name;
+
+        // For the second case QUrl can merge "#someanchor" with "foo.html"
+        // correctly to "foo.html#someanchor"
+        if (!(currentURL.isRelative()
+              || (currentURL.scheme() == QLatin1String("file")
+                  && !QFileInfo(currentURL.toLocalFile()).isAbsolute()))
+            || (name.hasFragment() && name.path().isEmpty())) {
+            resourceUrl =  currentURL.resolved(name);
+        } else {
+            // this is our last resort when current url and new url are both relative
+            // we try to resolve against the current working directory in the local
+            // file system.
+            QFileInfo fi(currentURL.toLocalFile());
+            if (fi.exists()) {
+                resourceUrl =
+                    QUrl::fromLocalFile(fi.absolutePath() + QDir::separator()).resolved(name);
+            }
+        }
+
+        QString s = resourceUrl.toLocalFile();
+        QFile f(s);
+        if (!s.isEmpty() && f.open(QFile::ReadOnly)) {
+            r = f.readAll();
+            f.close();
+        }
+    }
+
+    if (!r.isNull()) {
+        if (type == ImageResource && r.type() == QVariant::ByteArray) {
+            if (qApp->thread() != QThread::currentThread()) {
+                // must use images in non-GUI threads
+                QImage image;
+                image.loadFromData(r.toByteArray());
+                if (!image.isNull())
+                    r = image;
+            } else {
+                QPixmap pm;
+                pm.loadFromData(r.toByteArray());
+                if (!pm.isNull())
+                    r = pm;
+            }
+        }
+        d->cachedResources.insert(name, r);
+    }
+    return r;
+}
+
+static QTextFormat formatDifference(const QTextFormat &from, const QTextFormat &to)
+{
+    QTextFormat diff = to;
+
+    const QMap<int, QVariant> props = to.properties();
+    for (QMap<int, QVariant>::ConstIterator it = props.begin(), end = props.end();
+         it != end; ++it)
+        if (it.value() == from.property(it.key()))
+            diff.clearProperty(it.key());
+
+    return diff;
+}
+
+QTextHtmlExporter::QTextHtmlExporter(const QTextDocument *_doc)
+    : doc(_doc), fragmentMarkers(false)
+{
+    const QFont defaultFont = doc->defaultFont();
+    defaultCharFormat.setFont(defaultFont);
+    // don't export those for the default font since we cannot turn them off with CSS
+    defaultCharFormat.clearProperty(QTextFormat::FontUnderline);
+    defaultCharFormat.clearProperty(QTextFormat::FontOverline);
+    defaultCharFormat.clearProperty(QTextFormat::FontStrikeOut);
+    defaultCharFormat.clearProperty(QTextFormat::TextUnderlineStyle);
+}
+
+/*!
+    Returns the document in HTML format. The conversion may not be
+    perfect, especially for complex documents, due to the limitations
+    of HTML.
+*/
+QString QTextHtmlExporter::toHtml(const QByteArray &encoding, ExportMode mode)
+{
+    html = QLatin1String("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" "
+            "\"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
+            "<html><head><meta name=\"qrichtext\" content=\"1\" />");
+    html.reserve(doc->docHandle()->length());
+
+    fragmentMarkers = (mode == ExportFragment);
+
+    if (!encoding.isEmpty())
+        html += QString::fromLatin1("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=%1\" />").arg(QString::fromAscii(encoding));
+
+    QString title  = doc->metaInformation(QTextDocument::DocumentTitle);
+    if (!title.isEmpty())
+        html += QString::fromLatin1("<title>") + title + QString::fromLatin1("</title>");
+    html += QLatin1String("<style type=\"text/css\">\n");
+    html += QLatin1String("p, li { white-space: pre-wrap; }\n");
+    html += QLatin1String("</style>");
+    html += QLatin1String("</head><body");
+
+    if (mode == ExportEntireDocument) {
+        html += QLatin1String(" style=\"");
+
+        emitFontFamily(defaultCharFormat.fontFamily());
+
+        if (defaultCharFormat.hasProperty(QTextFormat::FontPointSize)) {
+            html += QLatin1String(" font-size:");
+            html += QString::number(defaultCharFormat.fontPointSize());
+            html += QLatin1String("pt;");
+        }
+
+        html += QLatin1String(" font-weight:");
+        html += QString::number(defaultCharFormat.fontWeight() * 8);
+        html += QLatin1Char(';');
+
+        html += QLatin1String(" font-style:");
+        html += (defaultCharFormat.fontItalic() ? QLatin1String("italic") : QLatin1String("normal"));
+        html += QLatin1Char(';');
+
+        // do not set text-decoration on the default font since those values are /always/ propagated
+        // and cannot be turned off with CSS
+
+        html += QLatin1Char('\"');
+
+        const QTextFrameFormat fmt = doc->rootFrame()->frameFormat();
+        emitBackgroundAttribute(fmt);
+
+    } else {
+        defaultCharFormat = QTextCharFormat();
+    }
+    html += QLatin1Char('>');
+
+    QTextFrameFormat rootFmt = doc->rootFrame()->frameFormat();
+    rootFmt.clearProperty(QTextFormat::BackgroundBrush);
+
+    QTextFrameFormat defaultFmt;
+    defaultFmt.setMargin(doc->documentMargin());
+
+    if (rootFmt == defaultFmt)
+        emitFrame(doc->rootFrame()->begin());
+    else
+        emitTextFrame(doc->rootFrame());
+
+    html += QLatin1String("</body></html>");
+    return html;
+}
+
+void QTextHtmlExporter::emitAttribute(const char *attribute, const QString &value)
+{
+    html += QLatin1Char(' ');
+    html += QLatin1String(attribute);
+    html += QLatin1String("=\"");
+    html += value;
+    html += QLatin1Char('"');
+}
+
+bool QTextHtmlExporter::emitCharFormatStyle(const QTextCharFormat &format)
+{
+    bool attributesEmitted = false;
+
+    {
+        const QString family = format.fontFamily();
+        if (!family.isEmpty() && family != defaultCharFormat.fontFamily()) {
+            emitFontFamily(family);
+            attributesEmitted = true;
+        }
+    }
+
+    if (format.hasProperty(QTextFormat::FontPointSize)
+        && format.fontPointSize() != defaultCharFormat.fontPointSize()) {
+        html += QLatin1String(" font-size:");
+        html += QString::number(format.fontPointSize());
+        html += QLatin1String("pt;");
+        attributesEmitted = true;
+    } else if (format.hasProperty(QTextFormat::FontSizeAdjustment)) {
+        static const char * const sizeNames[] = {
+            "small", "medium", "large", "x-large", "xx-large"
+        };
+        const char *name = 0;
+        const int idx = format.intProperty(QTextFormat::FontSizeAdjustment) + 1;
+        if (idx >= 0 && idx <= 4) {
+            name = sizeNames[idx];
+        }
+        if (name) {
+            html += QLatin1String(" font-size:");
+            html += QLatin1String(name);
+            html += QLatin1Char(';');
+            attributesEmitted = true;
+        }
+    }
+
+    if (format.hasProperty(QTextFormat::FontWeight)
+        && format.fontWeight() != defaultCharFormat.fontWeight()) {
+        html += QLatin1String(" font-weight:");
+        html += QString::number(format.fontWeight() * 8);
+        html += QLatin1Char(';');
+        attributesEmitted = true;
+    }
+
+    if (format.hasProperty(QTextFormat::FontItalic)
+        && format.fontItalic() != defaultCharFormat.fontItalic()) {
+        html += QLatin1String(" font-style:");
+        html += (format.fontItalic() ? QLatin1String("italic") : QLatin1String("normal"));
+        html += QLatin1Char(';');
+        attributesEmitted = true;
+    }
+
+    QLatin1String decorationTag(" text-decoration:");
+    html += decorationTag;
+    bool hasDecoration = false;
+    bool atLeastOneDecorationSet = false;
+
+    if ((format.hasProperty(QTextFormat::FontUnderline) || format.hasProperty(QTextFormat::TextUnderlineStyle))
+        && format.fontUnderline() != defaultCharFormat.fontUnderline()) {
+        hasDecoration = true;
+        if (format.fontUnderline()) {
+            html += QLatin1String(" underline");
+            atLeastOneDecorationSet = true;
+        }
+    }
+
+    if (format.hasProperty(QTextFormat::FontOverline)
+        && format.fontOverline() != defaultCharFormat.fontOverline()) {
+        hasDecoration = true;
+        if (format.fontOverline()) {
+            html += QLatin1String(" overline");
+            atLeastOneDecorationSet = true;
+        }
+    }
+
+    if (format.hasProperty(QTextFormat::FontStrikeOut)
+        && format.fontStrikeOut() != defaultCharFormat.fontStrikeOut()) {
+        hasDecoration = true;
+        if (format.fontStrikeOut()) {
+            html += QLatin1String(" line-through");
+            atLeastOneDecorationSet = true;
+        }
+    }
+
+    if (hasDecoration) {
+        if (!atLeastOneDecorationSet)
+            html += QLatin1String("none");
+        html += QLatin1Char(';');
+        attributesEmitted = true;
+    } else {
+        html.chop(qstrlen(decorationTag.latin1()));
+    }
+
+    if (format.foreground() != defaultCharFormat.foreground()
+        && format.foreground().style() != Qt::NoBrush) {
+        html += QLatin1String(" color:");
+        html += format.foreground().color().name();
+        html += QLatin1Char(';');
+        attributesEmitted = true;
+    }
+
+    if (format.background() != defaultCharFormat.background()
+        && format.background().style() == Qt::SolidPattern) {
+        html += QLatin1String(" background-color:");
+        html += format.background().color().name();
+        html += QLatin1Char(';');
+        attributesEmitted = true;
+    }
+
+    if (format.verticalAlignment() != defaultCharFormat.verticalAlignment()
+        && format.verticalAlignment() != QTextCharFormat::AlignNormal)
+    {
+        html += QLatin1String(" vertical-align:");
+
+        QTextCharFormat::VerticalAlignment valign = format.verticalAlignment();
+        if (valign == QTextCharFormat::AlignSubScript)
+            html += QLatin1String("sub");
+        else if (valign == QTextCharFormat::AlignSuperScript)
+            html += QLatin1String("super");
+        else if (valign == QTextCharFormat::AlignMiddle)
+            html += QLatin1String("middle");
+        else if (valign == QTextCharFormat::AlignTop)
+            html += QLatin1String("top");
+        else if (valign == QTextCharFormat::AlignBottom)
+            html += QLatin1String("bottom");
+
+        html += QLatin1Char(';');
+        attributesEmitted = true;
+    }
+
+    if (format.fontCapitalization() != QFont::MixedCase) {
+        const QFont::Capitalization caps = format.fontCapitalization();
+        if (caps == QFont::AllUppercase)
+            html += QLatin1String(" text-transform:uppercase;");
+        else if (caps == QFont::AllLowercase)
+            html += QLatin1String(" text-transform:lowercase;");
+        else if (caps == QFont::SmallCaps)
+            html += QLatin1String(" font-variant:small-caps;");
+        attributesEmitted = true;
+    }
+
+    if (format.fontWordSpacing() != 0.0) {
+        html += QLatin1String(" word-spacing:");
+        html += QString::number(format.fontWordSpacing());
+        html += QLatin1String("px;");
+        attributesEmitted = true;
+    }
+
+    return attributesEmitted;
+}
+
+void QTextHtmlExporter::emitTextLength(const char *attribute, const QTextLength &length)
+{
+    if (length.type() == QTextLength::VariableLength) // default
+        return;
+
+    html += QLatin1Char(' ');
+    html += QLatin1String(attribute);
+    html += QLatin1String("=\"");
+    html += QString::number(length.rawValue());
+
+    if (length.type() == QTextLength::PercentageLength)
+        html += QLatin1String("%\"");
+    else
+        html += QLatin1Char('\"');
+}
+
+void QTextHtmlExporter::emitAlignment(Qt::Alignment align)
+{
+    if (align & Qt::AlignLeft)
+        return;
+    else if (align & Qt::AlignRight)
+        html += QLatin1String(" align=\"right\"");
+    else if (align & Qt::AlignHCenter)
+        html += QLatin1String(" align=\"center\"");
+    else if (align & Qt::AlignJustify)
+        html += QLatin1String(" align=\"justify\"");
+}
+
+void QTextHtmlExporter::emitFloatStyle(QTextFrameFormat::Position pos, StyleMode mode)
+{
+    if (pos == QTextFrameFormat::InFlow)
+        return;
+
+    if (mode == EmitStyleTag)
+        html += QLatin1String(" style=\"float:");
+    else
+        html += QLatin1String(" float:");
+
+    if (pos == QTextFrameFormat::FloatLeft)
+        html += QLatin1String(" left;");
+    else if (pos == QTextFrameFormat::FloatRight)
+        html += QLatin1String(" right;");
+    else
+        Q_ASSERT_X(0, "QTextHtmlExporter::emitFloatStyle()", "pos should be a valid enum type");
+
+    if (mode == EmitStyleTag)
+        html += QLatin1Char('\"');
+}
+
+void QTextHtmlExporter::emitBorderStyle(QTextFrameFormat::BorderStyle style)
+{
+    Q_ASSERT(style <= QTextFrameFormat::BorderStyle_Outset);
+
+    html += QLatin1String(" border-style:");
+
+    switch (style) {
+    case QTextFrameFormat::BorderStyle_None:
+        html += QLatin1String("none");
+        break;
+    case QTextFrameFormat::BorderStyle_Dotted:
+        html += QLatin1String("dotted");
+        break;
+    case QTextFrameFormat::BorderStyle_Dashed:
+        html += QLatin1String("dashed");
+        break;
+    case QTextFrameFormat::BorderStyle_Solid:
+        html += QLatin1String("solid");
+        break;
+    case QTextFrameFormat::BorderStyle_Double:
+        html += QLatin1String("double");
+        break;
+    case QTextFrameFormat::BorderStyle_DotDash:
+        html += QLatin1String("dot-dash");
+        break;
+    case QTextFrameFormat::BorderStyle_DotDotDash:
+        html += QLatin1String("dot-dot-dash");
+        break;
+    case QTextFrameFormat::BorderStyle_Groove:
+        html += QLatin1String("groove");
+        break;
+    case QTextFrameFormat::BorderStyle_Ridge:
+        html += QLatin1String("ridge");
+        break;
+    case QTextFrameFormat::BorderStyle_Inset:
+        html += QLatin1String("inset");
+        break;
+    case QTextFrameFormat::BorderStyle_Outset:
+        html += QLatin1String("outset");
+        break;
+    default:
+        Q_ASSERT(false);
+        break;
+    };
+
+    html += QLatin1Char(';');
+}
+
+void QTextHtmlExporter::emitPageBreakPolicy(QTextFormat::PageBreakFlags policy)
+{
+    if (policy & QTextFormat::PageBreak_AlwaysBefore)
+        html += QLatin1String(" page-break-before:always;");
+
+    if (policy & QTextFormat::PageBreak_AlwaysAfter)
+        html += QLatin1String(" page-break-after:always;");
+}
+
+void QTextHtmlExporter::emitFontFamily(const QString &family)
+{
+    html += QLatin1String(" font-family:");
+
+    QLatin1Char quote('\'');
+    if (family.contains(quote))
+        quote = QLatin1Char('\"');
+
+    html += quote;
+    html += family;
+    html += quote;
+    html += QLatin1Char(';');
+}
+
+void QTextHtmlExporter::emitMargins(const QString &top, const QString &bottom, const QString &left, const QString &right)
+{
+    html += QLatin1String(" margin-top:");
+    html += top;
+    html += QLatin1String("px;");
+
+    html += QLatin1String(" margin-bottom:");
+    html += bottom;
+    html += QLatin1String("px;");
+
+    html += QLatin1String(" margin-left:");
+    html += left;
+    html += QLatin1String("px;");
+
+    html += QLatin1String(" margin-right:");
+    html += right;
+    html += QLatin1String("px;");
+}
+
+void QTextHtmlExporter::emitFragment(const QTextFragment &fragment)
+{
+    const QTextCharFormat format = fragment.charFormat();
+
+    bool closeAnchor = false;
+
+    if (format.isAnchor()) {
+        const QString name = format.anchorName();
+        if (!name.isEmpty()) {
+            html += QLatin1String("<a name=\"");
+            html += name;
+            html += QLatin1String("\"></a>");
+        }
+        const QString href = format.anchorHref();
+        if (!href.isEmpty()) {
+            html += QLatin1String("<a href=\"");
+            html += href;
+            html += QLatin1String("\">");
+            closeAnchor = true;
+        }
+    }
+
+    QString txt = fragment.text();
+    const bool isObject = txt.contains(QChar::ObjectReplacementCharacter);
+    const bool isImage = isObject && format.isImageFormat();
+
+    QLatin1String styleTag("<span style=\"");
+    html += styleTag;
+
+    bool attributesEmitted = false;
+    if (!isImage)
+        attributesEmitted = emitCharFormatStyle(format);
+    if (attributesEmitted)
+        html += QLatin1String("\">");
+    else
+        html.chop(qstrlen(styleTag.latin1()));
+
+    if (isObject) {
+        for (int i = 0; isImage && i < txt.length(); ++i) {
+            QTextImageFormat imgFmt = format.toImageFormat();
+
+            html += QLatin1String("<img");
+
+            if (imgFmt.hasProperty(QTextFormat::ImageName))
+                emitAttribute("src", imgFmt.name());
+
+            if (imgFmt.hasProperty(QTextFormat::ImageWidth))
+                emitAttribute("width", QString::number(imgFmt.width()));
+
+            if (imgFmt.hasProperty(QTextFormat::ImageHeight))
+                emitAttribute("height", QString::number(imgFmt.height()));
+
+            if (imgFmt.verticalAlignment() == QTextCharFormat::AlignMiddle)
+                html += QLatin1String(" style=\"vertical-align: middle;\"");
+            else if (imgFmt.verticalAlignment() == QTextCharFormat::AlignTop)
+                html += QLatin1String(" style=\"vertical-align: top;\"");
+
+            if (QTextFrame *imageFrame = qobject_cast<QTextFrame *>(doc->objectForFormat(imgFmt)))
+                emitFloatStyle(imageFrame->frameFormat().position());
+
+            html += QLatin1String(" />");
+        }
+    } else {
+        Q_ASSERT(!txt.contains(QChar::ObjectReplacementCharacter));
+
+        txt = Qt::escape(txt);
+
+        // split for [\n{LineSeparator}]
+        QString forcedLineBreakRegExp = QString::fromLatin1("[\\na]");
+        forcedLineBreakRegExp[3] = QChar::LineSeparator;
+
+        const QStringList lines = txt.split(QRegExp(forcedLineBreakRegExp));
+        for (int i = 0; i < lines.count(); ++i) {
+            if (i > 0)
+                html += QLatin1String("<br />"); // space on purpose for compatibility with Netscape, Lynx & Co.
+            html += lines.at(i);
+        }
+    }
+
+    if (attributesEmitted)
+        html += QLatin1String("</span>");
+
+    if (closeAnchor)
+        html += QLatin1String("</a>");
+}
+
+static bool isOrderedList(int style)
+{
+    return style == QTextListFormat::ListDecimal || style == QTextListFormat::ListLowerAlpha
+           || style == QTextListFormat::ListUpperAlpha
+           || style == QTextListFormat::ListUpperRoman
+           || style == QTextListFormat::ListLowerRoman
+	   ;
+}
+
+void QTextHtmlExporter::emitBlockAttributes(const QTextBlock &block)
+{
+    QTextBlockFormat format = block.blockFormat();
+    emitAlignment(format.alignment());
+
+    Qt::LayoutDirection dir = format.layoutDirection();
+    if (dir == Qt::LeftToRight) {
+        // assume default to not bloat the html too much
+        // html += QLatin1String(" dir='ltr'");
+    } else {
+        html += QLatin1String(" dir='rtl'");
+    }
+
+    QLatin1String style(" style=\"");
+    html += style;
+
+    const bool emptyBlock = block.begin().atEnd();
+    if (emptyBlock) {
+        html += QLatin1String("-qt-paragraph-type:empty;");
+    }
+
+    emitMargins(QString::number(format.topMargin()),
+                QString::number(format.bottomMargin()),
+                QString::number(format.leftMargin()),
+                QString::number(format.rightMargin()));
+
+    html += QLatin1String(" -qt-block-indent:");
+    html += QString::number(format.indent());
+    html += QLatin1Char(';');
+
+    html += QLatin1String(" text-indent:");
+    html += QString::number(format.textIndent());
+    html += QLatin1String("px;");
+
+    if (block.userState() != -1) {
+        html += QLatin1String(" -qt-user-state:");
+        html += QString::number(block.userState());
+        html += QLatin1Char(';');
+    }
+
+    emitPageBreakPolicy(format.pageBreakPolicy());
+
+    QTextCharFormat diff;
+    if (emptyBlock) { // only print character properties when we don't expect them to be repeated by actual text in the parag
+        const QTextCharFormat blockCharFmt = block.charFormat();
+        diff = formatDifference(defaultCharFormat, blockCharFmt).toCharFormat();
+    }
+
+    diff.clearProperty(QTextFormat::BackgroundBrush);
+    if (format.hasProperty(QTextFormat::BackgroundBrush)) {
+        QBrush bg = format.background();
+        if (bg.style() != Qt::NoBrush)
+            diff.setProperty(QTextFormat::BackgroundBrush, format.property(QTextFormat::BackgroundBrush));
+    }
+
+    if (!diff.properties().isEmpty())
+        emitCharFormatStyle(diff);
+
+    html += QLatin1Char('"');
+
+}
+
+void QTextHtmlExporter::emitBlock(const QTextBlock &block)
+{
+    if (block.begin().atEnd()) {
+        // ### HACK, remove once QTextFrame::Iterator is fixed
+        int p = block.position();
+        if (p > 0)
+            --p;
+        QTextDocumentPrivate::FragmentIterator frag = doc->docHandle()->find(p);
+        QChar ch = doc->docHandle()->buffer().at(frag->stringPosition);
+        if (ch == QTextBeginningOfFrame
+            || ch == QTextEndOfFrame)
+            return;
+    }
+
+    html += QLatin1Char('\n');
+
+    // save and later restore, in case we 'change' the default format by
+    // emitting block char format information
+    QTextCharFormat oldDefaultCharFormat = defaultCharFormat;
+
+    QTextList *list = block.textList();
+    if (list) {
+        if (list->itemNumber(block) == 0) { // first item? emit <ul> or appropriate
+            const QTextListFormat format = list->format();
+            const int style = format.style();
+            switch (style) {
+                case QTextListFormat::ListDecimal: html += QLatin1String("<ol"); break;
+                case QTextListFormat::ListDisc: html += QLatin1String("<ul"); break;
+                case QTextListFormat::ListCircle: html += QLatin1String("<ul type=\"circle\""); break;
+                case QTextListFormat::ListSquare: html += QLatin1String("<ul type=\"square\""); break;
+                case QTextListFormat::ListLowerAlpha: html += QLatin1String("<ol type=\"a\""); break;
+                case QTextListFormat::ListUpperAlpha: html += QLatin1String("<ol type=\"A\""); break;
+                case QTextListFormat::ListLowerRoman: html += QLatin1String("<ol type=\"i\""); break;
+                case QTextListFormat::ListUpperRoman: html += QLatin1String("<ol type=\"I\""); break;
+                default: html += QLatin1String("<ul"); // ### should not happen
+            }
+
+            html += QLatin1String(" style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px;");
+
+            if (format.hasProperty(QTextFormat::ListIndent)) {
+                html += QLatin1String(" -qt-list-indent: ");
+                html += QString::number(format.indent());
+                html += QLatin1Char(';');
+            }
+
+            html += QLatin1String("\">");
+        }
+
+        html += QLatin1String("<li");
+
+        const QTextCharFormat blockFmt = formatDifference(defaultCharFormat, block.charFormat()).toCharFormat();
+        if (!blockFmt.properties().isEmpty()) {
+            html += QLatin1String(" style=\"");
+            emitCharFormatStyle(blockFmt);
+            html += QLatin1Char('\"');
+
+            defaultCharFormat.merge(block.charFormat());
+        }
+    }
+
+    const QTextBlockFormat blockFormat = block.blockFormat();
+    if (blockFormat.hasProperty(QTextFormat::BlockTrailingHorizontalRulerWidth)) {
+        html += QLatin1String("<hr");
+
+        QTextLength width = blockFormat.lengthProperty(QTextFormat::BlockTrailingHorizontalRulerWidth);
+        if (width.type() != QTextLength::VariableLength)
+            emitTextLength("width", width);
+        else
+            html += QLatin1Char(' ');
+
+        html += QLatin1String("/>");
+        return;
+    }
+
+    const bool pre = blockFormat.nonBreakableLines();
+    if (pre) {
+        if (list)
+            html += QLatin1Char('>');
+        html += QLatin1String("<pre");
+    } else if (!list) {
+        html += QLatin1String("<p");
+    }
+
+    emitBlockAttributes(block);
+
+    html += QLatin1Char('>');
+
+    QTextBlock::Iterator it = block.begin();
+    if (fragmentMarkers && !it.atEnd() && block == doc->begin())
+        html += QLatin1String("<!--StartFragment-->");
+
+    for (; !it.atEnd(); ++it)
+        emitFragment(it.fragment());
+
+    if (fragmentMarkers && block.position() + block.length() == doc->docHandle()->length())
+        html += QLatin1String("<!--EndFragment-->");
+
+    if (pre)
+        html += QLatin1String("</pre>");
+    else if (list)
+        html += QLatin1String("</li>");
+    else
+        html += QLatin1String("</p>");
+
+    if (list) {
+        if (list->itemNumber(block) == list->count() - 1) { // last item? close list
+            if (isOrderedList(list->format().style()))
+                html += QLatin1String("</ol>");
+            else
+                html += QLatin1String("</ul>");
+        }
+    }
+
+    defaultCharFormat = oldDefaultCharFormat;
+}
+
+extern bool qHasPixmapTexture(const QBrush& brush);
+
+QString QTextHtmlExporter::findUrlForImage(const QTextDocument *doc, qint64 cacheKey, bool isPixmap)
+{
+    QString url;
+    if (!doc)
+        return url;
+
+    if (QTextDocument *parent = qobject_cast<QTextDocument *>(doc->parent()))
+        return findUrlForImage(parent, cacheKey, isPixmap);
+
+    if (doc && doc->docHandle()) {
+        QTextDocumentPrivate *priv = doc->docHandle();
+        QMap<QUrl, QVariant>::const_iterator it = priv->cachedResources.constBegin();
+        for (; it != priv->cachedResources.constEnd(); ++it) {
+
+            const QVariant &v = it.value();
+            if (v.type() == QVariant::Image && !isPixmap) {
+                if (qvariant_cast<QImage>(v).cacheKey() == cacheKey)
+                    break;
+            }
+
+            if (v.type() == QVariant::Pixmap && isPixmap) {
+                if (qvariant_cast<QPixmap>(v).cacheKey() == cacheKey)
+                    break;
+            }
+        }
+
+        if (it != priv->cachedResources.constEnd())
+            url = it.key().toString();
+    }
+
+    return url;
+}
+
+void QTextDocumentPrivate::mergeCachedResources(const QTextDocumentPrivate *priv)
+{
+    if (!priv)
+        return;
+
+    cachedResources.unite(priv->cachedResources);
+}
+
+void QTextHtmlExporter::emitBackgroundAttribute(const QTextFormat &format)
+{
+    if (format.hasProperty(QTextFormat::BackgroundImageUrl)) {
+        QString url = format.property(QTextFormat::BackgroundImageUrl).toString();
+        emitAttribute("background", url);
+    } else {
+        const QBrush &brush = format.background();
+        if (brush.style() == Qt::SolidPattern) {
+            emitAttribute("bgcolor", brush.color().name());
+        } else if (brush.style() == Qt::TexturePattern) {
+            const bool isPixmap = qHasPixmapTexture(brush);
+            const qint64 cacheKey = isPixmap ? brush.texture().cacheKey() : brush.textureImage().cacheKey();
+
+            const QString url = findUrlForImage(doc, cacheKey, isPixmap);
+
+            if (!url.isEmpty())
+                emitAttribute("background", url);
+        }
+    }
+}
+
+void QTextHtmlExporter::emitTable(const QTextTable *table)
+{
+    QTextTableFormat format = table->format();
+
+    html += QLatin1String("\n<table");
+
+    if (format.hasProperty(QTextFormat::FrameBorder))
+        emitAttribute("border", QString::number(format.border()));
+
+    emitFrameStyle(format, TableFrame);
+
+    emitAlignment(format.alignment());
+    emitTextLength("width", format.width());
+
+    if (format.hasProperty(QTextFormat::TableCellSpacing))
+        emitAttribute("cellspacing", QString::number(format.cellSpacing()));
+    if (format.hasProperty(QTextFormat::TableCellPadding))
+        emitAttribute("cellpadding", QString::number(format.cellPadding()));
+
+    emitBackgroundAttribute(format);
+
+    html += QLatin1Char('>');
+
+    const int rows = table->rows();
+    const int columns = table->columns();
+
+    QVector<QTextLength> columnWidths = format.columnWidthConstraints();
+    if (columnWidths.isEmpty()) {
+        columnWidths.resize(columns);
+        columnWidths.fill(QTextLength());
+    }
+    Q_ASSERT(columnWidths.count() == columns);
+
+    QVarLengthArray<bool> widthEmittedForColumn(columns);
+    for (int i = 0; i < columns; ++i)
+        widthEmittedForColumn[i] = false;
+
+    const int headerRowCount = qMin(format.headerRowCount(), rows);
+    if (headerRowCount > 0)
+        html += QLatin1String("<thead>");
+
+    for (int row = 0; row < rows; ++row) {
+        html += QLatin1String("\n<tr>");
+
+        for (int col = 0; col < columns; ++col) {
+            const QTextTableCell cell = table->cellAt(row, col);
+
+            // for col/rowspans
+            if (cell.row() != row)
+                continue;
+
+            if (cell.column() != col)
+                continue;
+
+            html += QLatin1String("\n<td");
+
+            if (!widthEmittedForColumn[col] && cell.columnSpan() == 1) {
+                emitTextLength("width", columnWidths.at(col));
+                widthEmittedForColumn[col] = true;
+            }
+
+            if (cell.columnSpan() > 1)
+                emitAttribute("colspan", QString::number(cell.columnSpan()));
+
+            if (cell.rowSpan() > 1)
+                emitAttribute("rowspan", QString::number(cell.rowSpan()));
+
+            const QTextTableCellFormat cellFormat = cell.format().toTableCellFormat();
+            emitBackgroundAttribute(cellFormat);
+
+            QTextCharFormat oldDefaultCharFormat = defaultCharFormat;
+
+            QTextCharFormat::VerticalAlignment valign = cellFormat.verticalAlignment();
+
+            QString styleString;
+            if (valign >= QTextCharFormat::AlignMiddle && valign <= QTextCharFormat::AlignBottom) {
+                styleString += QLatin1String(" vertical-align:");
+                switch (valign) {
+                case QTextCharFormat::AlignMiddle:
+                    styleString += QLatin1String("middle");
+                    break;
+                case QTextCharFormat::AlignTop:
+                    styleString += QLatin1String("top");
+                    break;
+                case QTextCharFormat::AlignBottom:
+                    styleString += QLatin1String("bottom");
+                    break;
+                default:
+                    break;
+                }
+                styleString += QLatin1Char(';');
+
+                QTextCharFormat temp;
+                temp.setVerticalAlignment(valign);
+                defaultCharFormat.merge(temp);
+            }
+
+            if (cellFormat.hasProperty(QTextFormat::TableCellLeftPadding))
+                styleString += QLatin1String(" padding-left:") + QString::number(cellFormat.leftPadding()) + QLatin1Char(';');
+            if (cellFormat.hasProperty(QTextFormat::TableCellRightPadding))
+                styleString += QLatin1String(" padding-right:") + QString::number(cellFormat.rightPadding()) + QLatin1Char(';');
+            if (cellFormat.hasProperty(QTextFormat::TableCellTopPadding))
+                styleString += QLatin1String(" padding-top:") + QString::number(cellFormat.topPadding()) + QLatin1Char(';');
+            if (cellFormat.hasProperty(QTextFormat::TableCellBottomPadding))
+                styleString += QLatin1String(" padding-bottom:") + QString::number(cellFormat.bottomPadding()) + QLatin1Char(';');
+
+            if (!styleString.isEmpty())
+                html += QLatin1String(" style=\"") + styleString + QLatin1Char('\"');
+
+            html += QLatin1Char('>');
+
+            emitFrame(cell.begin());
+
+            html += QLatin1String("</td>");
+
+            defaultCharFormat = oldDefaultCharFormat;
+        }
+
+        html += QLatin1String("</tr>");
+        if (headerRowCount > 0 && row == headerRowCount - 1)
+            html += QLatin1String("</thead>");
+    }
+
+    html += QLatin1String("</table>");
+}
+
+void QTextHtmlExporter::emitFrame(QTextFrame::Iterator frameIt)
+{
+    if (!frameIt.atEnd()) {
+        QTextFrame::Iterator next = frameIt;
+        ++next;
+        if (next.atEnd()
+            && frameIt.currentFrame() == 0
+            && frameIt.parentFrame() != doc->rootFrame()
+            && frameIt.currentBlock().begin().atEnd())
+            return;
+    }
+
+    for (QTextFrame::Iterator it = frameIt;
+         !it.atEnd(); ++it) {
+        if (QTextFrame *f = it.currentFrame()) {
+            if (QTextTable *table = qobject_cast<QTextTable *>(f)) {
+                emitTable(table);
+            } else {
+                emitTextFrame(f);
+            }
+        } else if (it.currentBlock().isValid()) {
+            emitBlock(it.currentBlock());
+        }
+    }
+}
+
+void QTextHtmlExporter::emitTextFrame(const QTextFrame *f)
+{
+    FrameType frameType = f->parentFrame() ? TextFrame : RootFrame;
+
+    html += QLatin1String("\n<table");
+    QTextFrameFormat format = f->frameFormat();
+
+    if (format.hasProperty(QTextFormat::FrameBorder))
+        emitAttribute("border", QString::number(format.border()));
+
+    emitFrameStyle(format, frameType);
+
+    emitTextLength("width", format.width());
+    emitTextLength("height", format.height());
+
+    // root frame's bcolor goes in the <body> tag
+    if (frameType != RootFrame)
+        emitBackgroundAttribute(format);
+
+    html += QLatin1Char('>');
+    html += QLatin1String("\n<tr>\n<td style=\"border: none;\">");
+    emitFrame(f->begin());
+    html += QLatin1String("</td></tr></table>");
+}
+
+void QTextHtmlExporter::emitFrameStyle(const QTextFrameFormat &format, FrameType frameType)
+{
+    QLatin1String styleAttribute(" style=\"");
+    html += styleAttribute;
+    const int originalHtmlLength = html.length();
+
+    if (frameType == TextFrame)
+        html += QLatin1String("-qt-table-type: frame;");
+    else if (frameType == RootFrame)
+        html += QLatin1String("-qt-table-type: root;");
+
+    const QTextFrameFormat defaultFormat;
+
+    emitFloatStyle(format.position(), OmitStyleTag);
+    emitPageBreakPolicy(format.pageBreakPolicy());
+
+    if (format.borderBrush() != defaultFormat.borderBrush()) {
+        html += QLatin1String(" border-color:");
+        html += format.borderBrush().color().name();
+        html += QLatin1Char(';');
+    }
+
+    if (format.borderStyle() != defaultFormat.borderStyle())
+        emitBorderStyle(format.borderStyle());
+
+    if (format.hasProperty(QTextFormat::FrameMargin)
+        || format.hasProperty(QTextFormat::FrameLeftMargin)
+        || format.hasProperty(QTextFormat::FrameRightMargin)
+        || format.hasProperty(QTextFormat::FrameTopMargin)
+        || format.hasProperty(QTextFormat::FrameBottomMargin))
+        emitMargins(QString::number(format.topMargin()),
+                    QString::number(format.bottomMargin()),
+                    QString::number(format.leftMargin()),
+                    QString::number(format.rightMargin()));
+
+    if (html.length() == originalHtmlLength) // nothing emitted?
+        html.chop(qstrlen(styleAttribute.latin1()));
+    else
+        html += QLatin1Char('\"');
+}
+
+/*!
+    Returns a string containing an HTML representation of the document.
+
+    The \a encoding parameter specifies the value for the charset attribute
+    in the html header. For example if 'utf-8' is specified then the
+    beginning of the generated html will look like this:
+    \snippet doc/src/snippets/code/src_gui_text_qtextdocument.cpp 1
+
+    If no encoding is specified then no such meta information is generated.
+
+    If you later on convert the returned html string into a byte array for
+    transmission over a network or when saving to disk you should specify
+    the encoding you're going to use for the conversion to a byte array here.
+
+    \sa {Supported HTML Subset}
+*/
+#ifndef QT_NO_TEXTHTMLPARSER
+QString QTextDocument::toHtml(const QByteArray &encoding) const
+{
+    return QTextHtmlExporter(this).toHtml(encoding);
+}
+#endif // QT_NO_TEXTHTMLPARSER
+
+/*!
+    Returns a vector of text formats for all the formats used in the document.
+*/
+QVector<QTextFormat> QTextDocument::allFormats() const
+{
+    Q_D(const QTextDocument);
+    return d->formatCollection()->formats;
+}
+
+
+/*!
+  \internal
+
+  So that not all classes have to be friends of each other...
+*/
+QTextDocumentPrivate *QTextDocument::docHandle() const
+{
+    Q_D(const QTextDocument);
+    return const_cast<QTextDocumentPrivate *>(d);
+}
+
+/*!
+    \since 4.4
+    \fn QTextDocument::undoCommandAdded()
+
+    This signal is emitted  every time a new level of undo is added to the QTextDocument.
+*/
+
+QT_END_NAMESPACE