/****************************************************************************

**

** 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("<");

        else if (plain.at(i) == QLatin1Char('>'))

            rich += QLatin1String(">");

        else if (plain.at(i) == QLatin1Char('&'))

            rich += QLatin1String("&");

        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("<");

            else if (plain[i] == QLatin1Char('>'))

                rich += QLatin1String(">");

            else if (plain[i] == QLatin1Char('&'))

                rich += QLatin1String("&");

            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

{