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

**

** 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 test suite 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 <qtest.h>

#include <QTextDocument>

#include <QtDeclarative/qdeclarativeengine.h>

#include <QtDeclarative/qdeclarativecomponent.h>

#include <private/qdeclarativetext_p.h>

#include <private/qdeclarativevaluetype_p.h>

#include <QFontMetrics>

#include <QGraphicsSceneMouseEvent>

#include <qmath.h>

#include "../../../shared/util.h"

#include "testhttpserver.h"

class tst_qdeclarativetext : public QObject

{

    Q_OBJECT

public:

    tst_qdeclarativetext();

private slots:

    void text();

    void width();

    void wrap();

    void elide();

    void textFormat();

    void embeddedImages_data();

    void embeddedImages();

    // ### these tests may be trivial    

    void horizontalAlignment();

    void verticalAlignment();

    void font();

    void style();

    void color();

    void smooth();

    // QDeclarativeFontValueType

    void weight();

    void underline();

    void overline();

    void strikeout();

    void capitalization();

    void letterSpacing();

    void wordSpacing();

    void clickLink();

private:

    QStringList standard;

    QStringList richText;

    QStringList horizontalAlignmentmentStrings;

    QStringList verticalAlignmentmentStrings;

    QList<Qt::Alignment> verticalAlignmentments;

    QList<Qt::Alignment> horizontalAlignmentments;

    QStringList styleStrings;

    QList<QDeclarativeText::TextStyle> styles;

    QStringList colorStrings;

    QDeclarativeEngine engine;

};

tst_qdeclarativetext::tst_qdeclarativetext()

{

    standard << "the quick brown fox jumped over the lazy dog"

            << "the quick brown fox\n jumped over the lazy dog";

    richText << "<i>the <b>quick</b> brown <a href=\\\"http://www.google.com\\\">fox</a> jumped over the <b>lazy</b> dog</i>"

            << "<i>the <b>quick</b> brown <a href=\\\"http://www.google.com\\\">fox</a><br>jumped over the <b>lazy</b> dog</i>";

    horizontalAlignmentmentStrings << "AlignLeft"

            << "AlignRight"

            << "AlignHCenter";

    verticalAlignmentmentStrings << "AlignTop"

            << "AlignBottom"

            << "AlignVCenter";

    horizontalAlignmentments << Qt::AlignLeft

            << Qt::AlignRight

            << Qt::AlignHCenter;

    verticalAlignmentments << Qt::AlignTop

            << Qt::AlignBottom

            << Qt::AlignVCenter;

    styleStrings << "Normal"

            << "Outline"

            << "Raised"

            << "Sunken";

    styles << QDeclarativeText::Normal

            << QDeclarativeText::Outline

            << QDeclarativeText::Raised

            << QDeclarativeText::Sunken;

    colorStrings << "aliceblue"

            << "antiquewhite"

            << "aqua"

            << "darkkhaki"

            << "darkolivegreen"

            << "dimgray"

            << "palevioletred"

            << "lightsteelblue"

            << "#000000"

            << "#AAAAAA"

            << "#FFFFFF"

            << "#2AC05F";

    //

    // need a different test to do alpha channel test

    // << "#AA0011DD"

    // << "#00F16B11";

    //

}

void tst_qdeclarativetext::text()

{

    {

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData("import Qt 4.7\nText { text: \"\" }", QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->text(), QString(""));

        QVERIFY(textObject->width() == 0);

        delete textObject;

    }

    for (int i = 0; i < standard.size(); i++)

    {

        QString componentStr = "import Qt 4.7\nText { text: \"" + standard.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->text(), standard.at(i));

        QVERIFY(textObject->width() > 0);

    }

    for (int i = 0; i < richText.size(); i++)

    {

        QString componentStr = "import Qt 4.7\nText { text: \"" + richText.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QString expected = richText.at(i);

        QCOMPARE(textObject->text(), expected.replace("\\\"", "\""));

        QVERIFY(textObject->width() > 0);

    }

}

void tst_qdeclarativetext::width()

{

    // uses Font metrics to find the width for standard and document to find the width for rich

    {

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData("import Qt 4.7\nText { text: \"\" }", QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->width(), 0.);

    }

    for (int i = 0; i < standard.size(); i++)

    {

        QVERIFY(!Qt::mightBeRichText(standard.at(i))); // self-test

        QFont f;

        QFontMetricsF fm(f);

        qreal metricWidth = fm.size(Qt::TextExpandTabs && Qt::TextShowMnemonic, standard.at(i)).width();

        metricWidth = qCeil(metricWidth);

        QString componentStr = "import Qt 4.7\nText { text: \"" + standard.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->width(), qreal(metricWidth));

        QVERIFY(textObject->textFormat() == QDeclarativeText::AutoText); // setting text doesn't change format

    }

    for (int i = 0; i < richText.size(); i++)

    {

        QVERIFY(Qt::mightBeRichText(richText.at(i))); // self-test

        QTextDocument document;

        document.setHtml(richText.at(i));

        document.setDocumentMargin(0);

        int documentWidth = document.idealWidth();

        QString componentStr = "import Qt 4.7\nText { text: \"" + richText.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->width(), qreal(documentWidth));

        QVERIFY(textObject->textFormat() == QDeclarativeText::AutoText); // setting text doesn't change format

    }

}

void tst_qdeclarativetext::wrap()

{

    int textHeight = 0;

    // for specified width and wrap set true

    {

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData("import Qt 4.7\nText { text: \"Hello\"; wrapMode: Text.WordWrap; width: 300 }", QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        textHeight = textObject->height();

        QVERIFY(textObject != 0);

        QVERIFY(textObject->wrapMode() == QDeclarativeText::WordWrap);

        QCOMPARE(textObject->width(), 300.);

    }

    for (int i = 0; i < standard.size(); i++)

    {

        QString componentStr = "import Qt 4.7\nText { wrapMode: Text.WordWrap; width: 30; text: \"" + standard.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->width(), 30.);

        QVERIFY(textObject->height() > textHeight);

        int oldHeight = textObject->height();

        textObject->setWidth(100);

        QVERIFY(textObject->height() < oldHeight);

    }

    for (int i = 0; i < richText.size(); i++)

    {

        QString componentStr = "import Qt 4.7\nText { wrapMode: Text.WordWrap; width: 30; text: \"" + richText.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->width(), 30.);

        QVERIFY(textObject->height() > textHeight);

        qreal oldHeight = textObject->height();

        textObject->setWidth(100);

        QVERIFY(textObject->height() < oldHeight);

    }

    // richtext again with a fixed height

    for (int i = 0; i < richText.size(); i++)

    {

        QString componentStr = "import Qt 4.7\nText { wrapMode: Text.WordWrap; width: 30; height: 50; text: \"" + richText.at(i) + "\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QCOMPARE(textObject->width(), 30.);

        QVERIFY(textObject->implicitHeight() > textHeight);

        qreal oldHeight = textObject->implicitHeight();

        textObject->setWidth(100);

        QVERIFY(textObject->implicitHeight() < oldHeight);

    }

}

void tst_qdeclarativetext::elide()

{

    for (QDeclarativeText::TextElideMode m = QDeclarativeText::ElideLeft; m<=QDeclarativeText::ElideNone; m=QDeclarativeText::TextElideMode(int(m)+1)) {

        const char* elidename[]={"ElideLeft", "ElideRight", "ElideMiddle", "ElideNone"};

        QString elide = "elide: Text." + QString(elidename[int(m)]) + ";";

        // XXX Poor coverage.

        {

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(("import Qt 4.7\nText { text: \"\"; "+elide+" width: 100 }").toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QCOMPARE(textObject->elideMode(), m);

            QCOMPARE(textObject->width(), 100.);

        }

        for (int i = 0; i < standard.size(); i++)

        {

            QString componentStr = "import Qt 4.7\nText { "+elide+" width: 100; text: \"" + standard.at(i) + "\" }";

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QCOMPARE(textObject->elideMode(), m);

            QCOMPARE(textObject->width(), 100.);

        }

        // richtext - does nothing

        for (int i = 0; i < richText.size(); i++)

        {

            QString componentStr = "import Qt 4.7\nText { "+elide+" width: 100; text: \"" + richText.at(i) + "\" }";

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QCOMPARE(textObject->elideMode(), m);

            QCOMPARE(textObject->width(), 100.);

        }

    }

}

void tst_qdeclarativetext::textFormat()

{

    {

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData("import Qt 4.7\nText { text: \"Hello\"; textFormat: Text.RichText }", QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QVERIFY(textObject->textFormat() == QDeclarativeText::RichText);

    }

    {

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData("import Qt 4.7\nText { text: \"<b>Hello</b>\"; textFormat: Text.PlainText }", QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QVERIFY(textObject != 0);

        QVERIFY(textObject->textFormat() == QDeclarativeText::PlainText);

    }

}

//the alignment tests may be trivial o.oa

void tst_qdeclarativetext::horizontalAlignment()

{

    //test one align each, and then test if two align fails.

    for (int i = 0; i < standard.size(); i++)

    {

        for (int j=0; j < horizontalAlignmentmentStrings.size(); j++)

        {

            QString componentStr = "import Qt 4.7\nText { horizontalAlignment: \"" + horizontalAlignmentmentStrings.at(j) + "\"; text: \"" + standard.at(i) + "\" }";

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QCOMPARE((int)textObject->hAlign(), (int)horizontalAlignmentments.at(j));

        }

    }

    for (int i = 0; i < richText.size(); i++)

    {

        for (int j=0; j < horizontalAlignmentmentStrings.size(); j++)

        {

            QString componentStr = "import Qt 4.7\nText { horizontalAlignment: \"" + horizontalAlignmentmentStrings.at(j) + "\"; text: \"" + richText.at(i) + "\" }";

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QCOMPARE((int)textObject->hAlign(), (int)horizontalAlignmentments.at(j));

        }

    }

}

void tst_qdeclarativetext::verticalAlignment()

{

    //test one align each, and then test if two align fails.

    for (int i = 0; i < standard.size(); i++)

    {

        for (int j=0; j < verticalAlignmentmentStrings.size(); j++)

        {

            QString componentStr = "import Qt 4.7\nText { verticalAlignment: \"" + verticalAlignmentmentStrings.at(j) + "\"; text: \"" + standard.at(i) + "\" }";

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QVERIFY(textObject != 0);

            QCOMPARE((int)textObject->vAlign(), (int)verticalAlignmentments.at(j));

        }

    }

    for (int i = 0; i < richText.size(); i++)

    {

        for (int j=0; j < verticalAlignmentmentStrings.size(); j++)

        {

            QString componentStr = "import Qt 4.7\nText { verticalAlignment: \"" + verticalAlignmentmentStrings.at(j) + "\"; text: \"" + richText.at(i) + "\" }";

            QDeclarativeComponent textComponent(&engine);

            textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

            QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

            QVERIFY(textObject != 0);

            QCOMPARE((int)textObject->vAlign(), (int)verticalAlignmentments.at(j));

        }

    }

}

void tst_qdeclarativetext::font()

{

    //test size, then bold, then italic, then family

    {

        QString componentStr = "import Qt 4.7\nText { font.pointSize: 40; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE(textObject->font().pointSize(), 40);

        QCOMPARE(textObject->font().bold(), false);

        QCOMPARE(textObject->font().italic(), false);

    }

    {

        QString componentStr = "import Qt 4.7\nText { font.pixelSize: 40; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE(textObject->font().pixelSize(), 40);

        QCOMPARE(textObject->font().bold(), false);

        QCOMPARE(textObject->font().italic(), false);

    }

    { 

        QString componentStr = "import Qt 4.7\nText { font.bold: true; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE(textObject->font().bold(), true);

        QCOMPARE(textObject->font().italic(), false);

    }

    { 

        QString componentStr = "import Qt 4.7\nText { font.italic: true; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE(textObject->font().italic(), true);

        QCOMPARE(textObject->font().bold(), false);

    }

    { 

        QString componentStr = "import Qt 4.7\nText { font.family: \"Helvetica\"; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE(textObject->font().family(), QString("Helvetica"));

        QCOMPARE(textObject->font().bold(), false);

        QCOMPARE(textObject->font().italic(), false);

    }

    { 

        QString componentStr = "import Qt 4.7\nText { font.family: \"\"; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE(textObject->font().family(), QString(""));

    }

}

void tst_qdeclarativetext::style()

{

    //test style

    for (int i = 0; i < styles.size(); i++)

    { 

        QString componentStr = "import Qt 4.7\nText { style: \"" + styleStrings.at(i) + "\"; styleColor: \"white\"; text: \"Hello World\" }";

        QDeclarativeComponent textComponent(&engine);

        textComponent.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));

        QDeclarativeText *textObject = qobject_cast<QDeclarativeText*>(textComponent.create());

        QCOMPARE((int)textObject->style(), (int)styles.at(i));

        QCOMPARE(textObject->styleColor(), QColor("white"));

    }

}