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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDeclarative 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 "private/qdeclarativetext_p.h"

#include "private/qdeclarativetext_p_p.h"

#include <qdeclarativestyledtext_p.h>

#include <qdeclarativeinfo.h>

#include <qdeclarativepixmapcache_p.h>

#include <QSet>

#include <QTextLayout>

#include <QTextLine>

#include <QTextDocument>

#include <QTextCursor>

#include <QGraphicsSceneMouseEvent>

#include <QPainter>

#include <QAbstractTextDocumentLayout>

#include <qmath.h>

QT_BEGIN_NAMESPACE

extern Q_GUI_EXPORT bool qt_applefontsmoothing_enabled;

class QTextDocumentWithImageResources : public QTextDocument {

    Q_OBJECT

public:

    QTextDocumentWithImageResources(QDeclarativeText *parent);

    virtual ~QTextDocumentWithImageResources();

    void setText(const QString &);

    int resourcesLoading() const { return outstanding; }

protected:

    QVariant loadResource(int type, const QUrl &name);

private slots:

    void requestFinished();

private:

    QHash<QUrl, QDeclarativePixmap *> m_resources;

    int outstanding;

    static QSet<QUrl> errors;

};

QTextDocumentWithImageResources::QTextDocumentWithImageResources(QDeclarativeText *parent) 

: QTextDocument(parent), outstanding(0)

{

}

QTextDocumentWithImageResources::~QTextDocumentWithImageResources()

{

    if (!m_resources.isEmpty()) 

        qDeleteAll(m_resources);

}

QVariant QTextDocumentWithImageResources::loadResource(int type, const QUrl &name)

{

    QDeclarativeContext *context = qmlContext(parent());

    QUrl url = context->resolvedUrl(name);

    if (type == QTextDocument::ImageResource) {

        QHash<QUrl, QDeclarativePixmap *>::Iterator iter = m_resources.find(url);

        if (iter == m_resources.end()) {

            QDeclarativePixmap *p = new QDeclarativePixmap(context->engine(), url);

            iter = m_resources.insert(name, p);

            if (p->isLoading()) {

                p->connectFinished(this, SLOT(requestFinished()));

                outstanding++;

            }

        }

        QDeclarativePixmap *p = *iter;

        if (p->isReady()) {

            return p->pixmap();

        } else if (p->isError()) {

            if (!errors.contains(url)) {

                errors.insert(url);

                qmlInfo(parent()) << p->error();

            }

        }

    }

    return QTextDocument::loadResource(type,url); // The *resolved* URL

}

void QTextDocumentWithImageResources::requestFinished()

{

    outstanding--;

    if (outstanding == 0) {

        QDeclarativeText *textItem = static_cast<QDeclarativeText*>(parent());

        QString text = textItem->text();

#ifndef QT_NO_TEXTHTMLPARSER

        setHtml(text);

#else

        setPlainText(text);

#endif

        QDeclarativeTextPrivate *d = QDeclarativeTextPrivate::get(textItem);

        d->updateLayout();

        d->markImgDirty();

    }

}

void QTextDocumentWithImageResources::setText(const QString &text)

{

    if (!m_resources.isEmpty()) {

        qWarning("CLEAR");

        qDeleteAll(m_resources);

        m_resources.clear();

        outstanding = 0;

    }

#ifndef QT_NO_TEXTHTMLPARSER

    setHtml(text);

#else

    setPlainText(text);

#endif

}

QSet<QUrl> QTextDocumentWithImageResources::errors;

/*!

    \qmlclass Text QDeclarativeText

    \brief The Text item allows you to add formatted text to a scene.

    \inherits Item

    A Text item can display both plain and rich text. For example:

    \qml

    Text { text: "Hello World!"; font.family: "Helvetica"; font.pointSize: 24; color: "red" }

    Text { text: "<b>Hello</b> <i>World!</i>" }

    \endqml

    \image declarative-text.png

    If height and width are not explicitly set, Text will attempt to determine how

    much room is needed and set it accordingly. Unless \l wrapMode is set, it will always

    prefer width to height (all text will be placed on a single line).

    The \l elide property can alternatively be used to fit a single line of

    plain text to a set width.

    Note that the \l{Supported HTML Subset} is limited. Also, if the text contains

    HTML img tags that load remote images, the text is reloaded.

    Text provides read-only text. For editable text, see \l TextEdit.

    \sa {declarative/text/fonts}{Fonts example}

*/

QDeclarativeText::QDeclarativeText(QDeclarativeItem *parent)

  : QDeclarativeItem(*(new QDeclarativeTextPrivate), parent)

{

}

QDeclarativeText::~QDeclarativeText()

{

}

QDeclarativeTextPrivate::~QDeclarativeTextPrivate()

{

}

/*!

    \qmlproperty string Text::font.family

    Sets the family name of the font.

    The family name is case insensitive and may optionally include a foundry name, e.g. "Helvetica [Cronyx]".

    If the family is available from more than one foundry and the foundry isn't specified, an arbitrary foundry is chosen.

    If the family isn't available a family will be set using the font matching algorithm.

*/

/*!

    \qmlproperty bool Text::font.bold

    Sets whether the font weight is bold.

*/

/*!

    \qmlproperty enumeration Text::font.weight

    Sets the font's weight.

    The weight can be one of:

    \list

    \o Font.Light

    \o Font.Normal - the default

    \o Font.DemiBold

    \o Font.Bold

    \o Font.Black

    \endlist

    \qml

    Text { text: "Hello"; font.weight: Font.DemiBold }

    \endqml

*/

/*!

    \qmlproperty bool Text::font.italic

    Sets whether the font has an italic style.

*/

/*!

    \qmlproperty bool Text::font.underline

    Sets whether the text is underlined.

*/

/*!

    \qmlproperty bool Text::font.strikeout

    Sets whether the font has a strikeout style.

*/

/*!

    \qmlproperty real Text::font.pointSize

    Sets the font size in points. The point size must be greater than zero.

*/

/*!

    \qmlproperty int Text::font.pixelSize

    Sets the font size in pixels.

    Using this function makes the font device dependent.

    Use \c pointSize to set the size of the font in a device independent manner.

*/

/*!

    \qmlproperty real Text::font.letterSpacing

    Sets the letter spacing for the font.

    Letter spacing changes the default spacing between individual letters in the font.

    A positive value increases the letter spacing by the corresponding pixels; a negative value decreases the spacing.

*/

/*!

    \qmlproperty real Text::font.wordSpacing

    Sets the word spacing for the font.

    Word spacing changes the default spacing between individual words.

    A positive value increases the word spacing by a corresponding amount of pixels,

    while a negative value decreases the inter-word spacing accordingly.

*/

/*!

    \qmlproperty enumeration Text::font.capitalization

    Sets the capitalization for the text.

    \list

    \o Font.MixedCase - This is the normal text rendering option where no capitalization change is applied.

    \o Font.AllUppercase - This alters the text to be rendered in all uppercase type.

    \o Font.AllLowercase	 - This alters the text to be rendered in all lowercase type.

    \o Font.SmallCaps -	This alters the text to be rendered in small-caps type.

    \o Font.Capitalize - This alters the text to be rendered with the first character of each word as an uppercase character.

    \endlist

    \qml

    Text { text: "Hello"; font.capitalization: Font.AllLowercase }

    \endqml

*/

QFont QDeclarativeText::font() const

{

    Q_D(const QDeclarativeText);

    return d->font;

}

void QDeclarativeText::setFont(const QFont &font)

{

    Q_D(QDeclarativeText);

    if (d->font == font)

        return;

    d->font = font;

    d->updateLayout();

    d->markImgDirty();

    emit fontChanged(d->font);

}

void QDeclarativeText::setText(const QString &n)

{

    Q_D(QDeclarativeText);

    if (d->text == n)

        return;

    d->richText = d->format == RichText || (d->format == AutoText && Qt::mightBeRichText(n));

    if (d->richText) {

        if (isComponentComplete()) {

            d->ensureDoc();

            d->doc->setText(n);

        }

    }

    d->text = n;

    d->updateLayout();

    d->markImgDirty();

    emit textChanged(d->text);

}

/*!

    \qmlproperty string Text::text

    The text to display. Text supports both plain and rich text strings.

    The item will try to automatically determine whether the text should

    be treated as rich text. This determination is made using Qt::mightBeRichText().

*/

QString QDeclarativeText::text() const

{

    Q_D(const QDeclarativeText);

    return d->text;

}

void QDeclarativeText::setColor(const QColor &color)

{

    Q_D(QDeclarativeText);

    if (d->color == color)

        return;

    d->color = color;

    d->markImgDirty();

    emit colorChanged(d->color);

}

/*!

    \qmlproperty color Text::color

    The text color.

    \qml

    //green text using hexadecimal notation

    Text { color: "#00FF00"; ... }

    //steelblue text using SVG color name

    Text { color: "steelblue"; ... }

    \endqml

*/

QColor QDeclarativeText::color() const

{

    Q_D(const QDeclarativeText);

    return d->color;

}

/*!

    \qmlproperty enumeration Text::style

    Set an additional text style.

    Supported text styles are:

    \list

    \o Text.Normal - the default

    \o Text.Outline

    \o Text.Raised

    \o Text.Sunken

    \endlist

    \qml

    Row {

        Text { font.pointSize: 24; text: "Normal" }

        Text { font.pointSize: 24; text: "Raised"; style: Text.Raised; styleColor: "#AAAAAA" }

        Text { font.pointSize: 24; text: "Outline";style: Text.Outline; styleColor: "red" }

        Text { font.pointSize: 24; text: "Sunken"; style: Text.Sunken; styleColor: "#AAAAAA" }

    }

    \endqml

    \image declarative-textstyle.png

*/

QDeclarativeText::TextStyle QDeclarativeText::style() const

{

    Q_D(const QDeclarativeText);

    return d->style;

}

void QDeclarativeText::setStyle(QDeclarativeText::TextStyle style)

{

    Q_D(QDeclarativeText);

    if (d->style == style)

        return;

    d->style = style;

    d->markImgDirty();

    emit styleChanged(d->style);

}

void QDeclarativeText::setStyleColor(const QColor &color)

{

    Q_D(QDeclarativeText);

    if (d->styleColor == color)

        return;

    d->styleColor = color;

    d->markImgDirty();

    emit styleColorChanged(d->styleColor);

}

/*!

    \qmlproperty color Text::styleColor

    Defines the secondary color used by text styles.

    \c styleColor is used as the outline color for outlined text, and as the

    shadow color for raised or sunken text. If no style has been set, it is not

    used at all.

    \qml

    Text { font.pointSize: 18; text: "hello"; style: Text.Raised; styleColor: "gray" }

    \endqml

    \sa style

 */

QColor QDeclarativeText::styleColor() const

{

    Q_D(const QDeclarativeText);

    return d->styleColor;

}

/*!

    \qmlproperty enumeration Text::horizontalAlignment

    \qmlproperty enumeration Text::verticalAlignment

    Sets the horizontal and vertical alignment of the text within the Text items

    width and height.  By default, the text is top-left aligned.

    The valid values for \c horizontalAlignment are \c Text.AlignLeft, \c Text.AlignRight and

    \c Text.AlignHCenter.  The valid values for \c verticalAlignment are \c Text.AlignTop, \c Text.AlignBottom

    and \c Text.AlignVCenter.

    Note that for a single line of text, the size of the text is the area of the text. In this common case,

    all alignments are equivalent. If you want the text to be, say, centered in it parent, then you will

    need to either modify the Item::anchors, or set horizontalAlignment to Text.AlignHCenter and bind the width to 

    that of the parent.

*/

QDeclarativeText::HAlignment QDeclarativeText::hAlign() const

{

    Q_D(const QDeclarativeText);

    return d->hAlign;

}

void QDeclarativeText::setHAlign(HAlignment align)

{

    Q_D(QDeclarativeText);

    if (d->hAlign == align)

        return;

    d->hAlign = align;

    update();

    emit horizontalAlignmentChanged(align);

}

QDeclarativeText::VAlignment QDeclarativeText::vAlign() const

{

    Q_D(const QDeclarativeText);

    return d->vAlign;

}

void QDeclarativeText::setVAlign(VAlignment align)

{

    Q_D(QDeclarativeText);

    if (d->vAlign == align)

        return;

    d->vAlign = align;

    update();

    emit verticalAlignmentChanged(align);

}

/*!

    \qmlproperty enumeration Text::wrapMode