1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 

    46 #include <qtextdocument.h>

    47 #include <qdebug.h>

    48 

    49 #include <qtextcursor.h>

    50 #include <qtextdocumentfragment.h>

    51 #include <qtextformat.h>

    52 #include <qtextobject.h>

    53 #include <qtexttable.h>

    54 #include <qabstracttextdocumentlayout.h>

    55 #include <qtextlist.h>

    56 #include <qtextcodec.h>

    57 #include <qurl.h>

    58 #include <qpainter.h>

    59 #include <qfontmetrics.h>

    60 #include <qimage.h>

    61 #include <qtextlayout.h>

    62 #include "common.h"

    63 

    64 

    65 QT_FORWARD_DECLARE_CLASS(QTextDocument)

    66 

    67 //TESTED_CLASS=

    68 //TESTED_FILES=

    69 

    70 class tst_QTextDocument : public QObject

    71 {

    72     Q_OBJECT

    73 

    74 public:

    75     tst_QTextDocument();

    76     virtual ~tst_QTextDocument();

    77 

    78 public slots:

    79     void init();

    80     void cleanup();

    81 private slots:

    82     void getSetCheck();

    83     void isEmpty();

    84     void find_data();

    85     void find();

    86     void find2();

    87     void findWithRegExp_data();

    88     void findWithRegExp();

    89     void findMultiple();

    90     void basicIsModifiedChecks();

    91     void moreIsModified();

    92     void isModified2();

    93     void isModified3();

    94     void isModified4();

    95     void noundo_basicIsModifiedChecks();

    96     void noundo_moreIsModified();

    97     void noundo_isModified2();

    98     void noundo_isModified3();

    99     void mightBeRichText();

   100 

   101     void task240325();

   102 

   103     void stylesheetFont_data();

   104     void stylesheetFont();

   105 

   106     void toHtml_data();

   107     void toHtml();

   108     void toHtml2();

   109 

   110     void setFragmentMarkersInHtmlExport();

   111 

   112     void toHtmlBodyBgColor();

   113     void toHtmlRootFrameProperties();

   114     void capitalizationHtmlInExport();

   115     void wordspacingHtmlExport();

   116 

   117     void cursorPositionChanged();

   118     void cursorPositionChangedOnSetText();

   119 

   120     void textFrameIterator();

   121 

   122     void codecForHtml();

   123 

   124     void markContentsDirty();

   125 

   126     void clonePreservesMetaInformation();

   127     void clonePreservesPageSize();

   128     void clonePreservesPageBreakPolicies();

   129     void clonePreservesDefaultFont();

   130     void clonePreservesRootFrameFormat();

   131     void clonePreservesResources();

   132     void clonePreservesUserStates();

   133     void clonePreservesIndentWidth();

   134     void blockCount();

   135     void defaultStyleSheet();

   136 

   137     void resolvedFontInEmptyFormat();

   138 

   139     void defaultRootFrameMargin();

   140 

   141     void clearResources();

   142 

   143     void setPlainText();

   144     void toPlainText();

   145 

   146     void deleteTextObjectsOnClear();

   147 

   148     void maximumBlockCount();

   149     void adjustSize();

   150     void initialUserData();

   151 

   152     void html_defaultFont();

   153 

   154     void blockCountChanged();

   155 

   156     void nonZeroDocumentLengthOnClear();

   157 

   158     void setTextPreservesUndoRedoEnabled();

   159 

   160     void firstLast();

   161 

   162     void backgroundImage_toHtml();

   163     void backgroundImage_toHtml2();

   164     void backgroundImage_clone();

   165     void backgroundImage_copy();

   166 

   167     void documentCleanup();

   168 

   169     void characterAt();

   170     void revisions();

   171     void revisionWithUndoCompressionAndUndo();

   172 

   173     void testUndoCommandAdded();

   174 

   175     void testUndoBlocks();

   176 

   177     void receiveCursorPositionChangedAfterContentsChange();

   178 

   179 private:

   180     void backgroundImage_checkExpectedHtml(const QTextDocument &doc);

   181 

   182     QTextDocument *doc;

   183     QTextCursor cursor;

   184     QFont defaultFont;

   185     QString htmlHead;

   186     QString htmlTail;

   187 };

   188 

   189 class MyAbstractTextDocumentLayout : public QAbstractTextDocumentLayout

   190 {

   191 public:

   192     MyAbstractTextDocumentLayout(QTextDocument *doc) : QAbstractTextDocumentLayout(doc) {}

   193     void draw(QPainter *, const PaintContext &) {}

   194     int hitTest(const QPointF &, Qt::HitTestAccuracy) const { return 0; }

   195     int pageCount() const { return 0; }

   196     QSizeF documentSize() const { return QSizeF(); }

   197     QRectF frameBoundingRect(QTextFrame *) const { return QRectF(); }

   198     QRectF blockBoundingRect(const QTextBlock &) const { return QRectF(); }

   199     void documentChanged(int, int, int) {}

   200 };

   201 

   202 // Testing get/set functions

   203 void tst_QTextDocument::getSetCheck()

   204 {

   205     QTextDocument obj1;

   206     // QAbstractTextDocumentLayout * QTextDocument::documentLayout()

   207     // void QTextDocument::setDocumentLayout(QAbstractTextDocumentLayout *)

   208     QPointer<MyAbstractTextDocumentLayout> var1 = new MyAbstractTextDocumentLayout(0);

   209     obj1.setDocumentLayout(var1);

   210     QCOMPARE(static_cast<QAbstractTextDocumentLayout *>(var1), obj1.documentLayout());

   211     obj1.setDocumentLayout((QAbstractTextDocumentLayout *)0);

   212     QVERIFY(var1.isNull());

   213     QVERIFY(obj1.documentLayout());

   214 

   215     // bool QTextDocument::useDesignMetrics()

   216     // void QTextDocument::setUseDesignMetrics(bool)

   217     obj1.setUseDesignMetrics(false);

   218     QCOMPARE(false, obj1.useDesignMetrics());

   219     obj1.setUseDesignMetrics(true);

   220     QCOMPARE(true, obj1.useDesignMetrics());

   221 }

   222 

   223 tst_QTextDocument::tst_QTextDocument()

   224 {

   225     QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);

   226     img.save("foo.png");

   227 }

   228 

   229 tst_QTextDocument::~tst_QTextDocument()

   230 {

   231     QFile::remove(QLatin1String("foo.png"));

   232 }

   233 

   234 void tst_QTextDocument::init()

   235 {

   236     doc = new QTextDocument;

   237     cursor = QTextCursor(doc);

   238     defaultFont = QFont();

   239 

   240     htmlHead = QString("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" "

   241             "\"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"

   242             "<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"

   243             "p, li { white-space: pre-wrap; }\n"

   244             "</style></head>"

   245             "<body style=\" font-family:'%1'; font-size:%2pt; font-weight:%3; font-style:%4;\">\n");

   246     htmlHead = htmlHead.arg(defaultFont.family()).arg(defaultFont.pointSizeF()).arg(defaultFont.weight() * 8).arg((defaultFont.italic() ? "italic" : "normal"));

   247 

   248     htmlTail = QString("</body></html>");

   249 }

   250 

   251 void tst_QTextDocument::cleanup()

   252 {

   253     cursor = QTextCursor();

   254     delete doc;

   255     doc = 0;

   256 }

   257 

   258 void tst_QTextDocument::isEmpty()

   259 {

   260     QVERIFY(doc->isEmpty());

   261 }

   262 

   263 void tst_QTextDocument::find_data()

   264 {

   265     QTest::addColumn<QString>("haystack");

   266     QTest::addColumn<QString>("needle");

   267     QTest::addColumn<int>("flags");

   268     QTest::addColumn<int>("from");

   269     QTest::addColumn<int>("anchor");

   270     QTest::addColumn<int>("position");

   271 

   272     QTest::newRow("1") << "Hello World" << "World" << int(QTextDocument::FindCaseSensitively) << 0 << 6 << 11;

   273 

   274     QTest::newRow("2") << QString::fromAscii("Hello") + QString(QChar::ParagraphSeparator) + QString::fromAscii("World")

   275                     << "World" << int(QTextDocument::FindCaseSensitively) << 1 << 6 << 11;

   276 

   277     QTest::newRow("3") << QString::fromAscii("Hello") + QString(QChar::ParagraphSeparator) + QString::fromAscii("World")

   278                     << "Hello" << int(QTextDocument::FindCaseSensitively | QTextDocument::FindBackward) << 10 << 0 << 5;

   279     QTest::newRow("4wholewords") << QString::fromAscii("Hello Blah World")

   280                               << "Blah" << int(QTextDocument::FindWholeWords) << 0 << 6 << 10;

   281     QTest::newRow("5wholewords") << QString::fromAscii("HelloBlahWorld")

   282                               << "Blah" << int(QTextDocument::FindWholeWords) << 0 << -1 << -1;

   283     QTest::newRow("6wholewords") << QString::fromAscii("HelloBlahWorld Blah Hah")

   284                               << "Blah" << int(QTextDocument::FindWholeWords) << 0 << 15 << 19;

   285     QTest::newRow("7wholewords") << QString::fromAscii("HelloBlahWorld Blah Hah")

   286                               << "Blah" << int(QTextDocument::FindWholeWords | QTextDocument::FindBackward) << 23 << 15 << 19;

   287     QTest::newRow("8wholewords") << QString::fromAscii("Hello: World\n")

   288                               << "orld" << int(QTextDocument::FindWholeWords) << 0 << -1 << -1;

   289 

   290     QTest::newRow("across-paragraphs") << QString::fromAscii("First Parag\nSecond Parag with a lot more text")

   291                                        << "Parag" << int(QTextDocument::FindBackward)

   292                                        << 15 << 6 << 11;

   293 

   294     QTest::newRow("nbsp") << "Hello" + QString(QChar(QChar::Nbsp)) +"World" << " " << int(QTextDocument::FindCaseSensitively) << 0 << 5 << 6;

   295 }

   296 

   297 void tst_QTextDocument::find()

   298 {

   299     QFETCH(QString, haystack);

   300     QFETCH(QString, needle);

   301     QFETCH(int, flags);

   302     QFETCH(int, from);

   303     QFETCH(int, anchor);

   304     QFETCH(int, position);

   305 

   306     cursor.insertText(haystack);

   307     cursor = doc->find(needle, from, QTextDocument::FindFlags(flags));

   308 

   309     if (anchor != -1) {

   310         QCOMPARE(cursor.anchor(), anchor);

   311         QCOMPARE(cursor.position(), position);

   312     } else {

   313         QVERIFY(cursor.isNull());

   314     }

   315 

   316     //search using a regular expression

   317     QRegExp expr(needle);

   318     expr.setPatternSyntax(QRegExp::FixedString);

   319     QTextDocument::FindFlags flg(flags);

   320     expr.setCaseSensitivity((flg & QTextDocument::FindCaseSensitively) ? Qt::CaseSensitive : Qt::CaseInsensitive);

   321     cursor = doc->find(expr, from, flg);

   322 

   323     if (anchor != -1) {

   324         QCOMPARE(cursor.anchor(), anchor);

   325         QCOMPARE(cursor.position(), position);

   326     } else {

   327         QVERIFY(cursor.isNull());

   328     }

   329 }

   330 

   331 void tst_QTextDocument::findWithRegExp_data()

   332 {

   333     QTest::addColumn<QString>("haystack");

   334     QTest::addColumn<QString>("needle");

   335     QTest::addColumn<int>("flags");

   336     QTest::addColumn<int>("from");

   337     QTest::addColumn<int>("anchor");

   338     QTest::addColumn<int>("position");

   339 

   340     // match integers 0 to 99

   341     QTest::newRow("1") << "23" << "^\\d\\d?$" << int(QTextDocument::FindCaseSensitively) << 0 << 0 << 2;

   342     // match ampersands but not &

   343     QTest::newRow("2") << "His &amp; hers & theirs" << "&(?!amp;)"<< int(QTextDocument::FindCaseSensitively) << 0 << 15 << 16;

   344     //backward search

   345     QTest::newRow("3") << QString::fromAscii("HelloBlahWorld Blah Hah")

   346                               << "h" << int(QTextDocument::FindBackward) << 18 << 8 << 9;

   347 

   348 }

   349 

   350 void tst_QTextDocument::findWithRegExp()

   351 {

   352     QFETCH(QString, haystack);

   353     QFETCH(QString, needle);

   354     QFETCH(int, flags);

   355     QFETCH(int, from);

   356     QFETCH(int, anchor);

   357     QFETCH(int, position);

   358 

   359     cursor.insertText(haystack);

   360     //search using a regular expression

   361     QRegExp expr(needle);

   362     QTextDocument::FindFlags flg(flags);

   363     expr.setCaseSensitivity((flg & QTextDocument::FindCaseSensitively) ? Qt::CaseSensitive : Qt::CaseInsensitive);

   364     cursor = doc->find(expr, from, flg);

   365 

   366     if (anchor != -1) {

   367         QCOMPARE(cursor.anchor(), anchor);

   368         QCOMPARE(cursor.position(), position);

   369     } else {

   370         QVERIFY(cursor.isNull());

   371     }

   372 }

   373 

   374 void tst_QTextDocument::find2()

   375 {

   376     doc->setPlainText("aaa");

   377     cursor.movePosition(QTextCursor::Start);

   378     cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);

   379     QTextCursor hit = doc->find("a", cursor);

   380     QCOMPARE(hit.position(), 2);

   381     QCOMPARE(hit.anchor(), 1);

   382 }

   383 

   384 void tst_QTextDocument::findMultiple()

   385 {

   386     const QString text("foo bar baz foo bar baz");

   387     doc->setPlainText(text);

   388 

   389     cursor.movePosition(QTextCursor::Start);

   390     cursor = doc->find("bar", cursor);

   391     QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

   392     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   393     cursor = doc->find("bar", cursor);

   394     QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

   395     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   396 

   397     cursor.movePosition(QTextCursor::End);

   398     cursor = doc->find("bar", cursor, QTextDocument::FindBackward);

   399     QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

   400     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   401     cursor = doc->find("bar", cursor, QTextDocument::FindBackward);

   402     QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

   403     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   404 

   405 

   406     QRegExp expr("bar");

   407     expr.setPatternSyntax(QRegExp::FixedString);

   408 

   409     cursor.movePosition(QTextCursor::End);

   410     cursor = doc->find(expr, cursor, QTextDocument::FindBackward);

   411     QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

   412     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   413     cursor = doc->find(expr, cursor, QTextDocument::FindBackward);

   414     QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

   415     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   416 

   417     cursor.movePosition(QTextCursor::Start);

   418     cursor = doc->find(expr, cursor);

   419     QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

   420     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   421     cursor = doc->find(expr, cursor);

   422     QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

   423     QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

   424 }

   425 

   426 void tst_QTextDocument::basicIsModifiedChecks()

   427 {

   428     QSignalSpy spy(doc, SIGNAL(modificationChanged(bool)));

   429 

   430     QVERIFY(!doc->isModified());

   431     cursor.insertText("Hello World");

   432     QVERIFY(doc->isModified());

   433     QCOMPARE(spy.count(), 1);

   434     QVERIFY(spy.takeFirst().at(0).toBool());

   435 

   436     doc->undo();

   437     QVERIFY(!doc->isModified());

   438     QCOMPARE(spy.count(), 1);

   439     QVERIFY(!spy.takeFirst().at(0).toBool());

   440 

   441     doc->redo();

   442     QVERIFY(doc->isModified());

   443     QCOMPARE(spy.count(), 1);

   444     QVERIFY(spy.takeFirst().at(0).toBool());

   445 }

   446 

   447 void tst_QTextDocument::moreIsModified()

   448 {

   449     QVERIFY(!doc->isModified());

   450 

   451     cursor.insertText("Hello");

   452     QVERIFY(doc->isModified());

   453 

   454     doc->undo();

   455     QVERIFY(!doc->isModified());

   456 

   457     cursor.insertText("Hello");

   458 

   459     doc->undo();

   460     QVERIFY(!doc->isModified());

   461 }

   462 

   463 void tst_QTextDocument::isModified2()

   464 {

   465     // reported on qt4-preview-feedback

   466     QVERIFY(!doc->isModified());

   467 

   468     cursor.insertText("Hello");

   469     QVERIFY(doc->isModified());

   470 

   471     doc->setModified(false);

   472     QVERIFY(!doc->isModified());

   473 

   474     cursor.insertText("Hello");

   475     QVERIFY(doc->isModified());

   476 }

   477 

   478 void tst_QTextDocument::isModified3()

   479 {

   480     QVERIFY(!doc->isModified());

   481 

   482     doc->setUndoRedoEnabled(false);

   483     doc->setUndoRedoEnabled(true);

   484 

   485     cursor.insertText("Hello");

   486 

   487     QVERIFY(doc->isModified());

   488     doc->undo();

   489     QVERIFY(!doc->isModified());

   490 }

   491 

   492 void tst_QTextDocument::isModified4()

   493 {

   494     QVERIFY(!doc->isModified());

   495 

   496     cursor.insertText("Hello");

   497     cursor.insertText("World");

   498 

   499     doc->setModified(false);

   500 

   501     QVERIFY(!doc->isModified());

   502 

   503     cursor.insertText("Again");

   504     QVERIFY(doc->isModified());

   505 

   506     doc->undo();

   507     QVERIFY(!doc->isModified());

   508     doc->undo();

   509     QVERIFY(doc->isModified());

   510 

   511     doc->redo();

   512     QVERIFY(!doc->isModified());

   513     doc->redo();

   514     QVERIFY(doc->isModified());

   515 

   516     doc->undo();

   517     QVERIFY(!doc->isModified());

   518     doc->undo();

   519     QVERIFY(doc->isModified());

   520 

   521     //task 197769

   522     cursor.insertText("Hello");

   523     QVERIFY(doc->isModified());

   524 }

   525 

   526 void tst_QTextDocument::noundo_basicIsModifiedChecks()

   527 {

   528     doc->setUndoRedoEnabled(false);

   529     QSignalSpy spy(doc, SIGNAL(modificationChanged(bool)));

   530 

   531     QVERIFY(!doc->isModified());

   532     cursor.insertText("Hello World");

   533     QVERIFY(doc->isModified());

   534     QCOMPARE(spy.count(), 1);

   535     QVERIFY(spy.takeFirst().at(0).toBool());

   536 

   537     doc->undo();

   538     QVERIFY(doc->isModified());

   539     QCOMPARE(spy.count(), 0);

   540 

   541     doc->redo();

   542     QVERIFY(doc->isModified());

   543     QCOMPARE(spy.count(), 0);

   544 }

   545 

   546 void tst_QTextDocument::task240325()

   547 {

   548     doc->setHtml("<html><img width=\"100\" height=\"100\" align=\"right\"/>Foobar Foobar Foobar Foobar</html>");

   549 

   550     QImage img(1000, 7000, QImage::Format_ARGB32_Premultiplied);

   551     QPainter p(&img);

   552     QFontMetrics fm(p.font());

   553 

   554     // Set page size to contain image and one "Foobar"

   555     doc->setPageSize(QSize(100 + fm.width("Foobar")*2, 1000));

   556 

   557     // Force layout

   558     doc->drawContents(&p);

   559 

   560     QCOMPARE(doc->blockCount(), 1);

   561     for (QTextBlock block = doc->begin() ; block!=doc->end() ; block = block.next()) {

   562         QTextLayout *layout = block.layout();

   563         QCOMPARE(layout->lineCount(), 4);

   564         for (int lineIdx=0;lineIdx<layout->lineCount();++lineIdx) {

   565             QTextLine line = layout->lineAt(lineIdx);

   566 

   567             QString text = block.text().mid(line.textStart(), line.textLength()).trimmed();

   568 

   569             // Remove start token

   570             if (lineIdx == 0)

   571                 text = text.mid(1);

   572 

   573             QCOMPARE(text, QString::fromLatin1("Foobar"));

   574         }

   575     }

   576 }

   577 

   578 void tst_QTextDocument::stylesheetFont_data()

   579 {    

   580     QTest::addColumn<QString>("stylesheet");

   581     QTest::addColumn<QFont>("font");

   582 

   583     {

   584         QFont font;

   585         font.setBold(true);

   586         font.setPixelSize(64);

   587 

   588         QTest::newRow("Regular font specification")

   589                  << "font-size: 64px; font-weight: bold;"

   590                  << font;

   591     }

   592 

   593 

   594     {

   595         QFont font;

   596         font.setBold(true);

   597         font.setPixelSize(64);

   598 

   599         QTest::newRow("Shorthand font specification")

   600                 << "font: normal bold 64px Arial;"

   601                 << font;

   602     }

   603 

   604 }

   605 

   606 void tst_QTextDocument::stylesheetFont()

   607 {

   608     QFETCH(QString, stylesheet);

   609     QFETCH(QFont, font);

   610 

   611     QString html = QString::fromLatin1("<html>"

   612                                        "<body>"

   613                                        "<div style=\"%1\" >"

   614                                        "Foobar"

   615                                        "</div>"

   616                                        "</body>"

   617                                        "</html>").arg(stylesheet);

   618 

   619     qDebug() << html;

   620     doc->setHtml(html);

   621     QCOMPARE(doc->blockCount(), 1);

   622 

   623     // First and only block

   624     QTextBlock block = doc->firstBlock();

   625 

   626     QString text = block.text();

   627     QCOMPARE(text, QString::fromLatin1("Foobar"));

   628 

   629     QFont actualFont = block.charFormat().font();

   630 

   631     QCOMPARE(actualFont.bold(), font.bold());

   632     QCOMPARE(actualFont.pixelSize(), font.pixelSize());

   633 }

   634 

   635 void tst_QTextDocument::noundo_moreIsModified()

   636 {

   637     doc->setUndoRedoEnabled(false);

   638     QVERIFY(!doc->isModified());

   639 

   640     cursor.insertText("Hello");

   641     QVERIFY(doc->isModified());

   642 

   643     doc->undo();

   644     QVERIFY(doc->isModified());

   645 

   646     cursor.insertText("Hello");

   647 

   648     doc->undo();

   649     QVERIFY(doc->isModified());

   650 }

   651 

   652 void tst_QTextDocument::noundo_isModified2()

   653 {

   654     // reported on qt4-preview-feedback

   655     QVERIFY(!doc->isModified());

   656 

   657     cursor.insertText("Hello");

   658     QVERIFY(doc->isModified());

   659 

   660     doc->setModified(false);

   661     QVERIFY(!doc->isModified());

   662 

   663     cursor.insertText("Hello");

   664     QVERIFY(doc->isModified());

   665 }

   666 

   667 void tst_QTextDocument::noundo_isModified3()

   668 {

   669     doc->setUndoRedoEnabled(false);

   670     QVERIFY(!doc->isModified());

   671 

   672     cursor.insertText("Hello");

   673 

   674     QVERIFY(doc->isModified());

   675     doc->undo();

   676     QVERIFY(doc->isModified());

   677 }

   678 

   679 void tst_QTextDocument::mightBeRichText()

   680 {

   681     const char qtDocuHeader[] = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n"

   682                                 "<!DOCTYPE html\n"

   683                                 "    PUBLIC ""-//W3C//DTD XHTML 1.0 Strict//EN\" \"DTD/xhtml1-strict.dtd\">\n"

   684                                 "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">";

   685     QVERIFY(Qt::mightBeRichText(QString::fromLatin1(qtDocuHeader)));

   686 }

   687 

   688 Q_DECLARE_METATYPE(QTextDocumentFragment)

   689 

   690 #define CREATE_DOC_AND_CURSOR() \

   691         QTextDocument doc; \

   692         doc.setDefaultFont(defaultFont); \

   693         QTextCursor cursor(&doc);

   694 

   695 void tst_QTextDocument::toHtml_data()

   696 {

   697     QTest::addColumn<QTextDocumentFragment>("input");

   698     QTest::addColumn<QString>("expectedOutput");

   699 

   700     {

   701         CREATE_DOC_AND_CURSOR();

   702 

   703         cursor.insertText("Blah");

   704 

   705         QTest::newRow("simple") << QTextDocumentFragment(&doc) << QString("<p DEFAULTBLOCKSTYLE>Blah</p>");

   706     }

   707 

   708     {

   709         CREATE_DOC_AND_CURSOR();

   710 

   711         cursor.insertText("&<>");

   712 

   713         QTest::newRow("entities") << QTextDocumentFragment(&doc) << QString("<p DEFAULTBLOCKSTYLE>&amp;&lt;&gt;</p>");

   714     }

   715 

   716     {

   717         CREATE_DOC_AND_CURSOR();

   718 

   719         QTextCharFormat fmt;

   720         fmt.setFontFamily("Times");

   721         cursor.insertText("Blah", fmt);

   722 

   723         QTest::newRow("font-family") << QTextDocumentFragment(&doc)

   724                                   << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:'Times';\">Blah</span></p>");

   725     }

   726 

   727     {

   728         CREATE_DOC_AND_CURSOR();

   729 

   730         QTextCharFormat fmt;

   731         fmt.setFontFamily("Foo's Family");

   732         cursor.insertText("Blah", fmt);

   733 

   734         QTest::newRow("font-family-with-quotes1") << QTextDocumentFragment(&doc)

   735                                   << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:\"Foo's Family\";\">Blah</span></p>");

   736     }

   737 

   738     {

   739         CREATE_DOC_AND_CURSOR();

   740 

   741         QTextCharFormat fmt;

   742         fmt.setFontFamily("Foo\"s Family");

   743         cursor.insertText("Blah", fmt);

   744 

   745         QTest::newRow("font-family-with-quotes2") << QTextDocumentFragment(&doc)

   746                                   << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:'Foo\"s Family';\">Blah</span></p>");

   747     }

   748 

   749     {

   750         CREATE_DOC_AND_CURSOR();

   751 

   752         QTextBlockFormat fmt;

   753         fmt.setNonBreakableLines(true);

   754         cursor.insertBlock(fmt);

   755         cursor.insertText("Blah");

   756 

   757         QTest::newRow("pre") << QTextDocumentFragment(&doc)

   758                           <<

   759                              QString("EMPTYBLOCK") +

   760                              QString("<pre DEFAULTBLOCKSTYLE>Blah</pre>");

   761     }

   762 

   763     {

   764         CREATE_DOC_AND_CURSOR();

   765 

   766         QTextCharFormat fmt;

   767         fmt.setFontPointSize(40);

   768         cursor.insertText("Blah", fmt);

   769 

   770         QTest::newRow("font-size") << QTextDocumentFragment(&doc)

   771                                 << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-size:40pt;\">Blah</span></p>");

   772     }

   773 

   774     {

   775         CREATE_DOC_AND_CURSOR();

   776 

   777         QTextCharFormat fmt;

   778         fmt.setProperty(QTextFormat::FontSizeIncrement, 2);

   779         cursor.insertText("Blah", fmt);

   780 

   781         QTest::newRow("logical-font-size") << QTextDocumentFragment(&doc)

   782                                         << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-size:x-large;\">Blah</span></p>");

   783     }

   784 

   785     {

   786         CREATE_DOC_AND_CURSOR();

   787 

   788         cursor.insertText("Foo");

   789 

   790         QTextCharFormat fmt;

   791         fmt.setFontPointSize(40);

   792         cursor.insertBlock(QTextBlockFormat(), fmt);

   793 

   794         fmt.clearProperty(QTextFormat::FontPointSize);

   795         cursor.insertText("Blub", fmt);

   796 

   797         QTest::newRow("no-font-size") << QTextDocumentFragment(&doc)

   798                                    << QString("<p DEFAULTBLOCKSTYLE>Foo</p>\n<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">Blub</p>");

   799     }

   800 

   801     {

   802         CREATE_DOC_AND_CURSOR();

   803 

   804         QTextBlockFormat fmt;

   805         fmt.setLayoutDirection(Qt::RightToLeft);

   806         cursor.insertBlock(fmt);

   807         cursor.insertText("Blah");

   808 

   809         QTest::newRow("rtl") << QTextDocumentFragment(&doc)

   810                           <<

   811                              QString("EMPTYBLOCK") +

   812                              QString("<p dir='rtl' DEFAULTBLOCKSTYLE>Blah</p>");

   813     }

   814 

   815     {

   816         CREATE_DOC_AND_CURSOR();

   817 

   818         QTextBlockFormat fmt;

   819         fmt.setAlignment(Qt::AlignJustify);

   820         cursor.insertBlock(fmt);

   821         cursor.insertText("Blah");

   822 

   823         QTest::newRow("blockalign") << QTextDocumentFragment(&doc)

   824                                  <<

   825                                     QString("EMPTYBLOCK") +

   826                                     QString("<p align=\"justify\" DEFAULTBLOCKSTYLE>Blah</p>");

   827     }

   828 

   829     {

   830         CREATE_DOC_AND_CURSOR();

   831 

   832         QTextBlockFormat fmt;

   833         fmt.setAlignment(Qt::AlignCenter);

   834         cursor.insertBlock(fmt);

   835         cursor.insertText("Blah");

   836 

   837         QTest::newRow("blockalign2") << QTextDocumentFragment(&doc)

   838                                   <<

   839                                     QString("EMPTYBLOCK") +

   840                                     QString("<p align=\"center\" DEFAULTBLOCKSTYLE>Blah</p>");

   841     }

   842 

   843     {

   844         CREATE_DOC_AND_CURSOR();

   845 

   846         QTextBlockFormat fmt;

   847         fmt.setAlignment(Qt::AlignRight | Qt::AlignAbsolute);

   848         cursor.insertBlock(fmt);

   849         cursor.insertText("Blah");

   850 

   851         QTest::newRow("blockalign3") << QTextDocumentFragment(&doc)

   852                                   <<

   853                                     QString("EMPTYBLOCK") +

   854                                     QString("<p align=\"right\" DEFAULTBLOCKSTYLE>Blah</p>");

   855     }

   856 

   857     {

   858         CREATE_DOC_AND_CURSOR();

   859 

   860         QTextBlockFormat fmt;

   861         fmt.setBackground(QColor("#0000ff"));

   862         cursor.insertBlock(fmt);

   863         cursor.insertText("Blah");

   864 

   865         QTest::newRow("bgcolor") << QTextDocumentFragment(&doc)

   866                                  << QString("EMPTYBLOCK") +

   867                                     QString("<p OPENDEFAULTBLOCKSTYLE background-color:#0000ff;\">Blah</p>");

   868     }

   869 

   870     {

   871         CREATE_DOC_AND_CURSOR();

   872 

   873         QTextCharFormat fmt;

   874         fmt.setFontWeight(40);

   875         cursor.insertText("Blah", fmt);

   876 

   877         QTest::newRow("font-weight") << QTextDocumentFragment(&doc)

   878                                   << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-weight:320;\">Blah</span></p>");

   879     }

   880 

   881     {

   882         CREATE_DOC_AND_CURSOR();

   883 

   884         QTextCharFormat fmt;

   885         fmt.setFontItalic(true);

   886         cursor.insertText("Blah", fmt);

   887 

   888         QTest::newRow("font-italic") << QTextDocumentFragment(&doc)

   889                                   << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-style:italic;\">Blah</span></p>");

   890     }

   891 

   892     {

   893         CREATE_DOC_AND_CURSOR();

   894 

   895         QTextCharFormat fmt;

   896         fmt.setFontUnderline(true);

   897         fmt.setFontOverline(false);

   898         cursor.insertText("Blah", fmt);

   899 

   900         QTest::newRow("text-decoration-1") << QTextDocumentFragment(&doc)

   901                                   << QString("<p DEFAULTBLOCKSTYLE><span style=\" text-decoration: underline;\">Blah</span></p>");

   902     }

   903 

   904     {

   905         CREATE_DOC_AND_CURSOR();

   906 

   907         QTextCharFormat fmt;

   908         fmt.setForeground(QColor("#00ff00"));

   909         cursor.insertText("Blah", fmt);

   910 

   911         QTest::newRow("color") << QTextDocumentFragment(&doc)

   912                             << QString("<p DEFAULTBLOCKSTYLE><span style=\" color:#00ff00;\">Blah</span></p>");

   913     }

   914 

   915     {

   916         CREATE_DOC_AND_CURSOR();

   917 

   918         QTextCharFormat fmt;

   919         fmt.setBackground(QColor("#00ff00"));

   920         cursor.insertText("Blah", fmt);

   921 

   922         QTest::newRow("span-bgcolor") << QTextDocumentFragment(&doc)

   923                             << QString("<p DEFAULTBLOCKSTYLE><span style=\" background-color:#00ff00;\">Blah</span></p>");

   924     }

   925 

   926     {

   927         CREATE_DOC_AND_CURSOR();

   928 

   929         QTextCharFormat fmt;

   930         fmt.setVerticalAlignment(QTextCharFormat::AlignSubScript);

   931         cursor.insertText("Blah", fmt);

   932 

   933         QTest::newRow("valign-sub") << QTextDocumentFragment(&doc)

   934                                  << QString("<p DEFAULTBLOCKSTYLE><span style=\" vertical-align:sub;\">Blah</span></p>");

   935 

   936     }

   937 

   938     {

   939         CREATE_DOC_AND_CURSOR();

   940 

   941         QTextCharFormat fmt;

   942         fmt.setVerticalAlignment(QTextCharFormat::AlignSuperScript);

   943         cursor.insertText("Blah", fmt);

   944 

   945         QTest::newRow("valign-super") << QTextDocumentFragment(&doc)

   946                                    << QString("<p DEFAULTBLOCKSTYLE><span style=\" vertical-align:super;\">Blah</span></p>");

   947 

   948     }

   949 

   950     {

   951         CREATE_DOC_AND_CURSOR();

   952 

   953         QTextCharFormat fmt;

   954         fmt.setAnchor(true);

   955         fmt.setAnchorName("blub");

   956         cursor.insertText("Blah", fmt);

   957 

   958         QTest::newRow("named anchor") << QTextDocumentFragment(&doc)

   959                                    << QString("<p DEFAULTBLOCKSTYLE><a name=\"blub\"></a>Blah</p>");

   960     }

   961 

   962     {

   963         CREATE_DOC_AND_CURSOR();

   964 

   965         QTextCharFormat fmt;

   966         fmt.setAnchor(true);

   967         fmt.setAnchorHref("http://www.kde.org/");

   968         cursor.insertText("Blah", fmt);

   969 

   970         QTest::newRow("href anchor") << QTextDocumentFragment(&doc)

   971                                   << QString("<p DEFAULTBLOCKSTYLE><a href=\"http://www.kde.org/\">Blah</a></p>");

   972     }

   973 

   974     {

   975         CREATE_DOC_AND_CURSOR();

   976 

   977         cursor.insertTable(2, 2);

   978 

   979         QTest::newRow("simpletable") << QTextDocumentFragment(&doc)

   980                                   << QString("<table border=\"1\" cellspacing=\"2\">"

   981                                              "\n<tr>\n<td></td>\n<td></td></tr>"

   982                                              "\n<tr>\n<td></td>\n<td></td></tr>"

   983                                              "</table>");

   984     }

   985 

   986     {

   987         CREATE_DOC_AND_CURSOR();

   988 

   989         QTextTable *table = cursor.insertTable(1, 4);

   990         table->mergeCells(0, 0, 1, 2);

   991         table->mergeCells(0, 2, 1, 2);

   992 

   993         QTest::newRow("tablespans") << QTextDocumentFragment(&doc)

   994                                  << QString("<table border=\"1\" cellspacing=\"2\">"

   995                                              "\n<tr>\n<td colspan=\"2\"></td>\n<td colspan=\"2\"></td></tr>"

   996                                              "</table>");

   997     }

   998 

   999     {

  1000         CREATE_DOC_AND_CURSOR();

  1001 

  1002         QTextTableFormat fmt;

  1003         fmt.setBorder(1);

  1004         fmt.setCellSpacing(3);

  1005         fmt.setCellPadding(3);

  1006         fmt.setBackground(QColor("#ff00ff"));

  1007         fmt.setWidth(QTextLength(QTextLength::PercentageLength, 50));

  1008         fmt.setAlignment(Qt::AlignHCenter);

  1009         fmt.setPosition(QTextFrameFormat::FloatRight);

  1010         cursor.insertTable(2, 2, fmt);

  1011 

  1012         QTest::newRow("tableattrs") << QTextDocumentFragment(&doc)

  1013                                   << QString("<table border=\"1\" style=\" float: right;\" align=\"center\" width=\"50%\" cellspacing=\"3\" cellpadding=\"3\" bgcolor=\"#ff00ff\">"

  1014                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1015                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1016                                              "</table>");

  1017     }

  1018 

  1019     {

  1020         CREATE_DOC_AND_CURSOR();

  1021 

  1022         QTextTableFormat fmt;

  1023         fmt.setBorder(1);

  1024         fmt.setCellSpacing(3);

  1025         fmt.setCellPadding(3);

  1026         fmt.setBackground(QColor("#ff00ff"));

  1027         fmt.setWidth(QTextLength(QTextLength::PercentageLength, 50));

  1028         fmt.setAlignment(Qt::AlignHCenter);

  1029         fmt.setPosition(QTextFrameFormat::FloatRight);

  1030         fmt.setLeftMargin(25);

  1031         fmt.setBottomMargin(35);

  1032         cursor.insertTable(2, 2, fmt);

  1033 

  1034         QTest::newRow("tableattrs2") << QTextDocumentFragment(&doc)

  1035                                   << QString("<table border=\"1\" style=\" float: right; margin-top:0px; margin-bottom:35px; margin-left:25px; margin-right:0px;\" align=\"center\" width=\"50%\" cellspacing=\"3\" cellpadding=\"3\" bgcolor=\"#ff00ff\">"

  1036                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1037                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1038                                              "</table>");

  1039     }

  1040 

  1041     {

  1042         CREATE_DOC_AND_CURSOR();

  1043 

  1044         QTextTableFormat fmt;

  1045         fmt.setHeaderRowCount(2);

  1046         cursor.insertTable(4, 2, fmt);

  1047 

  1048         QTest::newRow("tableheader") << QTextDocumentFragment(&doc)

  1049                                   << QString("<table border=\"1\" cellspacing=\"2\">"

  1050                                              "<thead>\n<tr>\n<td></td>\n<td></td></tr>"

  1051                                              "\n<tr>\n<td></td>\n<td></td></tr></thead>"

  1052                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1053                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1054                                              "</table>");

  1055     }

  1056 

  1057     {

  1058         CREATE_DOC_AND_CURSOR();

  1059 

  1060         QTextTable *table = cursor.insertTable(2, 2);

  1061         QTextTable *subTable = table->cellAt(0, 1).firstCursorPosition().insertTable(1, 1);

  1062         subTable->cellAt(0, 0).firstCursorPosition().insertText("Hey");

  1063 

  1064         QTest::newRow("nestedtable") << QTextDocumentFragment(&doc)

  1065                                   << QString("<table border=\"1\" cellspacing=\"2\">"

  1066                                              "\n<tr>\n<td></td>\n<td>\n<table border=\"1\" cellspacing=\"2\">\n<tr>\n<td>\n<p DEFAULTBLOCKSTYLE>Hey</p></td></tr></table></td></tr>"

  1067                                              "\n<tr>\n<td></td>\n<td></td></tr>"

  1068                                              "</table>");

  1069     }

  1070 

  1071     {

  1072         CREATE_DOC_AND_CURSOR();

  1073 

  1074         QTextTableFormat fmt;

  1075         QVector<QTextLength> widths;

  1076         widths.append(QTextLength());

  1077         widths.append(QTextLength(QTextLength::PercentageLength, 30));

  1078         widths.append(QTextLength(QTextLength::FixedLength, 40));

  1079         fmt.setColumnWidthConstraints(widths);

  1080         cursor.insertTable(1, 3, fmt);

  1081 

  1082         QTest::newRow("colwidths") << QTextDocumentFragment(&doc)

  1083                                   << QString("<table border=\"1\" cellspacing=\"2\">"

  1084                                              "\n<tr>\n<td></td>\n<td width=\"30%\"></td>\n<td width=\"40\"></td></tr>"

  1085                                              "</table>");

  1086     }

  1087 

  1088     // ### rowspan/colspan tests, once texttable api for that is back again

  1089     //

  1090     {

  1091         CREATE_DOC_AND_CURSOR();

  1092 

  1093         QTextTable *table = cursor.insertTable(1, 1);

  1094         QTextCursor cellCurs = table->cellAt(0, 0).firstCursorPosition();

  1095         QTextCharFormat fmt;

  1096         fmt.setBackground(QColor("#ffffff"));

  1097         cellCurs.mergeBlockCharFormat(fmt);

  1098 

  1099         QTest::newRow("cellproperties") << QTextDocumentFragment(&doc)

  1100                                      << QString("<table border=\"1\" cellspacing=\"2\">"

  1101                                                 "\n<tr>\n<td bgcolor=\"#ffffff\"></td></tr>"

  1102                                                 "</table>");

  1103     }

  1104 

  1105     {

  1106         CREATE_DOC_AND_CURSOR();

  1107 

  1108         // ### fixme: use programmatic api as soon as we can create floats through it

  1109         const char html[] = "<html><body>Blah<img src=\"image.png\" width=\"10\" height=\"20\" style=\"float: right;\" />Blubb</body></html>";

  1110 

  1111         QTest::newRow("image") << QTextDocumentFragment::fromHtml(QString::fromLatin1(html))

  1112                             << QString("<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">Blah<img src=\"image.png\" width=\"10\" height=\"20\" style=\"float: right;\" />Blubb</p>");

  1113     }

  1114 

  1115     {

  1116         CREATE_DOC_AND_CURSOR();

  1117 

  1118         QTextImageFormat fmt;

  1119         fmt.setName("foo");

  1120         fmt.setVerticalAlignment(QTextCharFormat::AlignMiddle);

  1121         cursor.insertImage(fmt);

  1122 

  1123         QTest::newRow("image-malign") << QTextDocumentFragment(&doc)

  1124                             << QString("<p DEFAULTBLOCKSTYLE><img src=\"foo\" style=\"vertical-align: middle;\" /></p>");

  1125     }

  1126 

  1127     {

  1128         CREATE_DOC_AND_CURSOR();

  1129 

  1130         QTextImageFormat fmt;

  1131         fmt.setName("foo");

  1132         fmt.setVerticalAlignment(QTextCharFormat::AlignTop);

  1133         cursor.insertImage(fmt);

  1134