| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 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$ |
| ** GNU Lesser General Public License Usage |
| ** 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. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qtexthtmlparser_p.h" |
| |
| #include <qbytearray.h> |
| #include <qtextcodec.h> |
| #include <qapplication.h> |
| #include <qstack.h> |
| #include <qdebug.h> |
| #include <qthread.h> |
| |
| #include "qtextdocument.h" |
| #include "qtextformat_p.h" |
| #include "qtextdocument_p.h" |
| #include "qtextcursor.h" |
| #include "qfont_p.h" |
| #include "private/qfunctions_p.h" |
| |
| #ifndef QT_NO_TEXTHTMLPARSER |
| |
| QT_BEGIN_NAMESPACE |
| |
| // see also tst_qtextdocumentfragment.cpp |
| #define MAX_ENTITY 258 |
| static const struct QTextHtmlEntity { const char *name; quint16 code; } entities[MAX_ENTITY]= { |
| { "AElig", 0x00c6 }, |
| { "AMP", 38 }, |
| { "Aacute", 0x00c1 }, |
| { "Acirc", 0x00c2 }, |
| { "Agrave", 0x00c0 }, |
| { "Alpha", 0x0391 }, |
| { "Aring", 0x00c5 }, |
| { "Atilde", 0x00c3 }, |
| { "Auml", 0x00c4 }, |
| { "Beta", 0x0392 }, |
| { "Ccedil", 0x00c7 }, |
| { "Chi", 0x03a7 }, |
| { "Dagger", 0x2021 }, |
| { "Delta", 0x0394 }, |
| { "ETH", 0x00d0 }, |
| { "Eacute", 0x00c9 }, |
| { "Ecirc", 0x00ca }, |
| { "Egrave", 0x00c8 }, |
| { "Epsilon", 0x0395 }, |
| { "Eta", 0x0397 }, |
| { "Euml", 0x00cb }, |
| { "GT", 62 }, |
| { "Gamma", 0x0393 }, |
| { "Iacute", 0x00cd }, |
| { "Icirc", 0x00ce }, |
| { "Igrave", 0x00cc }, |
| { "Iota", 0x0399 }, |
| { "Iuml", 0x00cf }, |
| { "Kappa", 0x039a }, |
| { "LT", 60 }, |
| { "Lambda", 0x039b }, |
| { "Mu", 0x039c }, |
| { "Ntilde", 0x00d1 }, |
| { "Nu", 0x039d }, |
| { "OElig", 0x0152 }, |
| { "Oacute", 0x00d3 }, |
| { "Ocirc", 0x00d4 }, |
| { "Ograve", 0x00d2 }, |
| { "Omega", 0x03a9 }, |
| { "Omicron", 0x039f }, |
| { "Oslash", 0x00d8 }, |
| { "Otilde", 0x00d5 }, |
| { "Ouml", 0x00d6 }, |
| { "Phi", 0x03a6 }, |
| { "Pi", 0x03a0 }, |
| { "Prime", 0x2033 }, |
| { "Psi", 0x03a8 }, |
| { "QUOT", 34 }, |
| { "Rho", 0x03a1 }, |
| { "Scaron", 0x0160 }, |
| { "Sigma", 0x03a3 }, |
| { "THORN", 0x00de }, |
| { "Tau", 0x03a4 }, |
| { "Theta", 0x0398 }, |
| { "Uacute", 0x00da }, |
| { "Ucirc", 0x00db }, |
| { "Ugrave", 0x00d9 }, |
| { "Upsilon", 0x03a5 }, |
| { "Uuml", 0x00dc }, |
| { "Xi", 0x039e }, |
| { "Yacute", 0x00dd }, |
| { "Yuml", 0x0178 }, |
| { "Zeta", 0x0396 }, |
| { "aacute", 0x00e1 }, |
| { "acirc", 0x00e2 }, |
| { "acute", 0x00b4 }, |
| { "aelig", 0x00e6 }, |
| { "agrave", 0x00e0 }, |
| { "alefsym", 0x2135 }, |
| { "alpha", 0x03b1 }, |
| { "amp", 38 }, |
| { "and", 0x22a5 }, |
| { "ang", 0x2220 }, |
| { "apos", 0x0027 }, |
| { "aring", 0x00e5 }, |
| { "asymp", 0x2248 }, |
| { "atilde", 0x00e3 }, |
| { "auml", 0x00e4 }, |
| { "bdquo", 0x201e }, |
| { "beta", 0x03b2 }, |
| { "brvbar", 0x00a6 }, |
| { "bull", 0x2022 }, |
| { "cap", 0x2229 }, |
| { "ccedil", 0x00e7 }, |
| { "cedil", 0x00b8 }, |
| { "cent", 0x00a2 }, |
| { "chi", 0x03c7 }, |
| { "circ", 0x02c6 }, |
| { "clubs", 0x2663 }, |
| { "cong", 0x2245 }, |
| { "copy", 0x00a9 }, |
| { "crarr", 0x21b5 }, |
| { "cup", 0x222a }, |
| { "curren", 0x00a4 }, |
| { "dArr", 0x21d3 }, |
| { "dagger", 0x2020 }, |
| { "darr", 0x2193 }, |
| { "deg", 0x00b0 }, |
| { "delta", 0x03b4 }, |
| { "diams", 0x2666 }, |
| { "divide", 0x00f7 }, |
| { "eacute", 0x00e9 }, |
| { "ecirc", 0x00ea }, |
| { "egrave", 0x00e8 }, |
| { "empty", 0x2205 }, |
| { "emsp", 0x2003 }, |
| { "ensp", 0x2002 }, |
| { "epsilon", 0x03b5 }, |
| { "equiv", 0x2261 }, |
| { "eta", 0x03b7 }, |
| { "eth", 0x00f0 }, |
| { "euml", 0x00eb }, |
| { "euro", 0x20ac }, |
| { "exist", 0x2203 }, |
| { "fnof", 0x0192 }, |
| { "forall", 0x2200 }, |
| { "frac12", 0x00bd }, |
| { "frac14", 0x00bc }, |
| { "frac34", 0x00be }, |
| { "frasl", 0x2044 }, |
| { "gamma", 0x03b3 }, |
| { "ge", 0x2265 }, |
| { "gt", 62 }, |
| { "hArr", 0x21d4 }, |
| { "harr", 0x2194 }, |
| { "hearts", 0x2665 }, |
| { "hellip", 0x2026 }, |
| { "iacute", 0x00ed }, |
| { "icirc", 0x00ee }, |
| { "iexcl", 0x00a1 }, |
| { "igrave", 0x00ec }, |
| { "image", 0x2111 }, |
| { "infin", 0x221e }, |
| { "int", 0x222b }, |
| { "iota", 0x03b9 }, |
| { "iquest", 0x00bf }, |
| { "isin", 0x2208 }, |
| { "iuml", 0x00ef }, |
| { "kappa", 0x03ba }, |
| { "lArr", 0x21d0 }, |
| { "lambda", 0x03bb }, |
| { "lang", 0x2329 }, |
| { "laquo", 0x00ab }, |
| { "larr", 0x2190 }, |
| { "lceil", 0x2308 }, |
| { "ldquo", 0x201c }, |
| { "le", 0x2264 }, |
| { "lfloor", 0x230a }, |
| { "lowast", 0x2217 }, |
| { "loz", 0x25ca }, |
| { "lrm", 0x200e }, |
| { "lsaquo", 0x2039 }, |
| { "lsquo", 0x2018 }, |
| { "lt", 60 }, |
| { "macr", 0x00af }, |
| { "mdash", 0x2014 }, |
| { "micro", 0x00b5 }, |
| { "middot", 0x00b7 }, |
| { "minus", 0x2212 }, |
| { "mu", 0x03bc }, |
| { "nabla", 0x2207 }, |
| { "nbsp", 0x00a0 }, |
| { "ndash", 0x2013 }, |
| { "ne", 0x2260 }, |
| { "ni", 0x220b }, |
| { "not", 0x00ac }, |
| { "notin", 0x2209 }, |
| { "nsub", 0x2284 }, |
| { "ntilde", 0x00f1 }, |
| { "nu", 0x03bd }, |
| { "oacute", 0x00f3 }, |
| { "ocirc", 0x00f4 }, |
| { "oelig", 0x0153 }, |
| { "ograve", 0x00f2 }, |
| { "oline", 0x203e }, |
| { "omega", 0x03c9 }, |
| { "omicron", 0x03bf }, |
| { "oplus", 0x2295 }, |
| { "or", 0x22a6 }, |
| { "ordf", 0x00aa }, |
| { "ordm", 0x00ba }, |
| { "oslash", 0x00f8 }, |
| { "otilde", 0x00f5 }, |
| { "otimes", 0x2297 }, |
| { "ouml", 0x00f6 }, |
| { "para", 0x00b6 }, |
| { "part", 0x2202 }, |
| { "percnt", 0x0025 }, |
| { "permil", 0x2030 }, |
| { "perp", 0x22a5 }, |
| { "phi", 0x03c6 }, |
| { "pi", 0x03c0 }, |
| { "piv", 0x03d6 }, |
| { "plusmn", 0x00b1 }, |
| { "pound", 0x00a3 }, |
| { "prime", 0x2032 }, |
| { "prod", 0x220f }, |
| { "prop", 0x221d }, |
| { "psi", 0x03c8 }, |
| { "quot", 34 }, |
| { "rArr", 0x21d2 }, |
| { "radic", 0x221a }, |
| { "rang", 0x232a }, |
| { "raquo", 0x00bb }, |
| { "rarr", 0x2192 }, |
| { "rceil", 0x2309 }, |
| { "rdquo", 0x201d }, |
| { "real", 0x211c }, |
| { "reg", 0x00ae }, |
| { "rfloor", 0x230b }, |
| { "rho", 0x03c1 }, |
| { "rlm", 0x200f }, |
| { "rsaquo", 0x203a }, |
| { "rsquo", 0x2019 }, |
| { "sbquo", 0x201a }, |
| { "scaron", 0x0161 }, |
| { "sdot", 0x22c5 }, |
| { "sect", 0x00a7 }, |
| { "shy", 0x00ad }, |
| { "sigma", 0x03c3 }, |
| { "sigmaf", 0x03c2 }, |
| { "sim", 0x223c }, |
| { "spades", 0x2660 }, |
| { "sub", 0x2282 }, |
| { "sube", 0x2286 }, |
| { "sum", 0x2211 }, |
| { "sup", 0x2283 }, |
| { "sup1", 0x00b9 }, |
| { "sup2", 0x00b2 }, |
| { "sup3", 0x00b3 }, |
| { "supe", 0x2287 }, |
| { "szlig", 0x00df }, |
| { "tau", 0x03c4 }, |
| { "there4", 0x2234 }, |
| { "theta", 0x03b8 }, |
| { "thetasym", 0x03d1 }, |
| { "thinsp", 0x2009 }, |
| { "thorn", 0x00fe }, |
| { "tilde", 0x02dc }, |
| { "times", 0x00d7 }, |
| { "trade", 0x2122 }, |
| { "uArr", 0x21d1 }, |
| { "uacute", 0x00fa }, |
| { "uarr", 0x2191 }, |
| { "ucirc", 0x00fb }, |
| { "ugrave", 0x00f9 }, |
| { "uml", 0x00a8 }, |
| { "upsih", 0x03d2 }, |
| { "upsilon", 0x03c5 }, |
| { "uuml", 0x00fc }, |
| { "weierp", 0x2118 }, |
| { "xi", 0x03be }, |
| { "yacute", 0x00fd }, |
| { "yen", 0x00a5 }, |
| { "yuml", 0x00ff }, |
| { "zeta", 0x03b6 }, |
| { "zwj", 0x200d }, |
| { "zwnj", 0x200c } |
| }; |
| |
| Q_STATIC_GLOBAL_OPERATOR bool operator<(const QString &entityStr, const QTextHtmlEntity &entity) |
| { |
| return entityStr < QLatin1String(entity.name); |
| } |
| |
| Q_STATIC_GLOBAL_OPERATOR bool operator<(const QTextHtmlEntity &entity, const QString &entityStr) |
| { |
| return QLatin1String(entity.name) < entityStr; |
| } |
| |
| static QChar resolveEntity(const QString &entity) |
| { |
| const QTextHtmlEntity *start = &entities[0]; |
| const QTextHtmlEntity *end = &entities[MAX_ENTITY]; |
| const QTextHtmlEntity *e = qBinaryFind(start, end, entity); |
| if (e == end) |
| return QChar(); |
| return e->code; |
| } |
| |
| static const ushort windowsLatin1ExtendedCharacters[0xA0 - 0x80] = { |
| 0x20ac, // 0x80 |
| 0x0081, // 0x81 direct mapping |
| 0x201a, // 0x82 |
| 0x0192, // 0x83 |
| 0x201e, // 0x84 |
| 0x2026, // 0x85 |
| 0x2020, // 0x86 |
| 0x2021, // 0x87 |
| 0x02C6, // 0x88 |
| 0x2030, // 0x89 |
| 0x0160, // 0x8A |
| 0x2039, // 0x8B |
| 0x0152, // 0x8C |
| 0x008D, // 0x8D direct mapping |
| 0x017D, // 0x8E |
| 0x008F, // 0x8F directmapping |
| 0x0090, // 0x90 directmapping |
| 0x2018, // 0x91 |
| 0x2019, // 0x92 |
| 0x201C, // 0x93 |
| 0X201D, // 0x94 |
| 0x2022, // 0x95 |
| 0x2013, // 0x96 |
| 0x2014, // 0x97 |
| 0x02DC, // 0x98 |
| 0x2122, // 0x99 |
| 0x0161, // 0x9A |
| 0x203A, // 0x9B |
| 0x0153, // 0x9C |
| 0x009D, // 0x9D direct mapping |
| 0x017E, // 0x9E |
| 0x0178 // 0x9F |
| }; |
| |
| // the displayMode value is according to the what are blocks in the piecetable, not |
| // what the w3c defines. |
| static const QTextHtmlElement elements[Html_NumElements]= { |
| { "a", Html_a, QTextHtmlElement::DisplayInline }, |
| { "address", Html_address, QTextHtmlElement::DisplayInline }, |
| { "b", Html_b, QTextHtmlElement::DisplayInline }, |
| { "big", Html_big, QTextHtmlElement::DisplayInline }, |
| { "blockquote", Html_blockquote, QTextHtmlElement::DisplayBlock }, |
| { "body", Html_body, QTextHtmlElement::DisplayBlock }, |
| { "br", Html_br, QTextHtmlElement::DisplayInline }, |
| { "caption", Html_caption, QTextHtmlElement::DisplayBlock }, |
| { "center", Html_center, QTextHtmlElement::DisplayBlock }, |
| { "cite", Html_cite, QTextHtmlElement::DisplayInline }, |
| { "code", Html_code, QTextHtmlElement::DisplayInline }, |
| { "dd", Html_dd, QTextHtmlElement::DisplayBlock }, |
| { "dfn", Html_dfn, QTextHtmlElement::DisplayInline }, |
| { "div", Html_div, QTextHtmlElement::DisplayBlock }, |
| { "dl", Html_dl, QTextHtmlElement::DisplayBlock }, |
| { "dt", Html_dt, QTextHtmlElement::DisplayBlock }, |
| { "em", Html_em, QTextHtmlElement::DisplayInline }, |
| { "font", Html_font, QTextHtmlElement::DisplayInline }, |
| { "h1", Html_h1, QTextHtmlElement::DisplayBlock }, |
| { "h2", Html_h2, QTextHtmlElement::DisplayBlock }, |
| { "h3", Html_h3, QTextHtmlElement::DisplayBlock }, |
| { "h4", Html_h4, QTextHtmlElement::DisplayBlock }, |
| { "h5", Html_h5, QTextHtmlElement::DisplayBlock }, |
| { "h6", Html_h6, QTextHtmlElement::DisplayBlock }, |
| { "head", Html_head, QTextHtmlElement::DisplayNone }, |
| { "hr", Html_hr, QTextHtmlElement::DisplayBlock }, |
| { "html", Html_html, QTextHtmlElement::DisplayInline }, |
| { "i", Html_i, QTextHtmlElement::DisplayInline }, |
| { "img", Html_img, QTextHtmlElement::DisplayInline }, |
| { "kbd", Html_kbd, QTextHtmlElement::DisplayInline }, |
| { "li", Html_li, QTextHtmlElement::DisplayBlock }, |
| { "link", Html_link, QTextHtmlElement::DisplayNone }, |
| { "meta", Html_meta, QTextHtmlElement::DisplayNone }, |
| { "nobr", Html_nobr, QTextHtmlElement::DisplayInline }, |
| { "ol", Html_ol, QTextHtmlElement::DisplayBlock }, |
| { "p", Html_p, QTextHtmlElement::DisplayBlock }, |
| { "pre", Html_pre, QTextHtmlElement::DisplayBlock }, |
| { "qt", Html_body /*deliberate mapping*/, QTextHtmlElement::DisplayBlock }, |
| { "s", Html_s, QTextHtmlElement::DisplayInline }, |
| { "samp", Html_samp, QTextHtmlElement::DisplayInline }, |
| { "script", Html_script, QTextHtmlElement::DisplayNone }, |
| { "small", Html_small, QTextHtmlElement::DisplayInline }, |
| { "span", Html_span, QTextHtmlElement::DisplayInline }, |
| { "strong", Html_strong, QTextHtmlElement::DisplayInline }, |
| { "style", Html_style, QTextHtmlElement::DisplayNone }, |
| { "sub", Html_sub, QTextHtmlElement::DisplayInline }, |
| { "sup", Html_sup, QTextHtmlElement::DisplayInline }, |
| { "table", Html_table, QTextHtmlElement::DisplayTable }, |
| { "tbody", Html_tbody, QTextHtmlElement::DisplayTable }, |
| { "td", Html_td, QTextHtmlElement::DisplayBlock }, |
| { "tfoot", Html_tfoot, QTextHtmlElement::DisplayTable }, |
| { "th", Html_th, QTextHtmlElement::DisplayBlock }, |
| { "thead", Html_thead, QTextHtmlElement::DisplayTable }, |
| { "title", Html_title, QTextHtmlElement::DisplayNone }, |
| { "tr", Html_tr, QTextHtmlElement::DisplayTable }, |
| { "tt", Html_tt, QTextHtmlElement::DisplayInline }, |
| { "u", Html_u, QTextHtmlElement::DisplayInline }, |
| { "ul", Html_ul, QTextHtmlElement::DisplayBlock }, |
| { "var", Html_var, QTextHtmlElement::DisplayInline }, |
| }; |
| |
| |
| Q_STATIC_GLOBAL_OPERATOR bool operator<(const QString &str, const QTextHtmlElement &e) |
| { |
| return str < QLatin1String(e.name); |
| } |
| |
| Q_STATIC_GLOBAL_OPERATOR bool operator<(const QTextHtmlElement &e, const QString &str) |
| { |
| return QLatin1String(e.name) < str; |
| } |
| |
| static const QTextHtmlElement *lookupElementHelper(const QString &element) |
| { |
| const QTextHtmlElement *start = &elements[0]; |
| const QTextHtmlElement *end = &elements[Html_NumElements]; |
| const QTextHtmlElement *e = qBinaryFind(start, end, element); |
| if (e == end) |
| return 0; |
| return e; |
| } |
| |
| int QTextHtmlParser::lookupElement(const QString &element) |
| { |
| const QTextHtmlElement *e = lookupElementHelper(element); |
| if (!e) |
| return -1; |
| return e->id; |
| } |
| |
| // quotes newlines as "\\n" |
| static QString quoteNewline(const QString &s) |
| { |
| QString n = s; |
| n.replace(QLatin1Char('\n'), QLatin1String("\\n")); |
| return n; |
| } |
| |
| QTextHtmlParserNode::QTextHtmlParserNode() |
| : parent(0), id(Html_unknown), |
| cssFloat(QTextFrameFormat::InFlow), hasOwnListStyle(false), |
| hasCssListIndent(false), isEmptyParagraph(false), isTextFrame(false), isRootFrame(false), |
| displayMode(QTextHtmlElement::DisplayInline), hasHref(false), |
| listStyle(QTextListFormat::ListStyleUndefined), imageWidth(-1), imageHeight(-1), tableBorder(0), |
| tableCellRowSpan(1), tableCellColSpan(1), tableCellSpacing(2), tableCellPadding(0), |
| borderBrush(Qt::darkGray), borderStyle(QTextFrameFormat::BorderStyle_Outset), |
| userState(-1), cssListIndent(0), wsm(WhiteSpaceModeUndefined) |
| { |
| margin[QTextHtmlParser::MarginLeft] = 0; |
| margin[QTextHtmlParser::MarginRight] = 0; |
| margin[QTextHtmlParser::MarginTop] = 0; |
| margin[QTextHtmlParser::MarginBottom] = 0; |
| } |
| |
| void QTextHtmlParser::dumpHtml() |
| { |
| for (int i = 0; i < count(); ++i) { |
| qDebug().nospace() << qPrintable(QString(depth(i)*4, QLatin1Char(' '))) |
| << qPrintable(at(i).tag) << ':' |
| << quoteNewline(at(i).text); |
| ; |
| } |
| } |
| |
| QTextHtmlParserNode *QTextHtmlParser::newNode(int parent) |
| { |
| QTextHtmlParserNode *lastNode = &nodes.last(); |
| QTextHtmlParserNode *newNode = 0; |
| |
| bool reuseLastNode = true; |
| |
| if (nodes.count() == 1) { |
| reuseLastNode = false; |
| } else if (lastNode->tag.isEmpty()) { |
| |
| if (lastNode->text.isEmpty()) { |
| reuseLastNode = true; |
| } else { // last node is a text node (empty tag) with some text |
| |
| if (lastNode->text.length() == 1 && lastNode->text.at(0).isSpace()) { |
| |
| int lastSibling = count() - 2; |
| while (lastSibling |
| && at(lastSibling).parent != lastNode->parent |
| && at(lastSibling).displayMode == QTextHtmlElement::DisplayInline) { |
| lastSibling = at(lastSibling).parent; |
| } |
| |
| if (at(lastSibling).displayMode == QTextHtmlElement::DisplayInline) { |
| reuseLastNode = false; |
| } else { |
| reuseLastNode = true; |
| } |
| } else { |
| // text node with real (non-whitespace) text -> nothing to re-use |
| reuseLastNode = false; |
| } |
| |
| } |
| |
| } else { |
| // last node had a proper tag -> nothing to re-use |
| reuseLastNode = false; |
| } |
| |
| if (reuseLastNode) { |
| newNode = lastNode; |
| newNode->tag.clear(); |
| newNode->text.clear(); |
| newNode->id = Html_unknown; |
| } else { |
| nodes.resize(nodes.size() + 1); |
| newNode = &nodes.last(); |
| } |
| |
| newNode->parent = parent; |
| return newNode; |
| } |
| |
| void QTextHtmlParser::parse(const QString &text, const QTextDocument *_resourceProvider) |
| { |
| nodes.clear(); |
| nodes.resize(1); |
| txt = text; |
| pos = 0; |
| len = txt.length(); |
| textEditMode = false; |
| resourceProvider = _resourceProvider; |
| parse(); |
| //dumpHtml(); |
| } |
| |
| int QTextHtmlParser::depth(int i) const |
| { |
| int depth = 0; |
| while (i) { |
| i = at(i).parent; |
| ++depth; |
| } |
| return depth; |
| } |
| |
| int QTextHtmlParser::margin(int i, int mar) const { |
| int m = 0; |
| const QTextHtmlParserNode *node; |
| if (mar == MarginLeft |
| || mar == MarginRight) { |
| while (i) { |
| node = &at(i); |
| if (!node->isBlock() && node->id != Html_table) |
| break; |
| if (node->isTableCell()) |
| break; |
| m += node->margin[mar]; |
| i = node->parent; |
| } |
| } |
| return m; |
| } |
| |
| int QTextHtmlParser::topMargin(int i) const |
| { |
| if (!i) |
| return 0; |
| return at(i).margin[MarginTop]; |
| } |
| |
| int QTextHtmlParser::bottomMargin(int i) const |
| { |
| if (!i) |
| return 0; |
| return at(i).margin[MarginBottom]; |
| } |
| |
| void QTextHtmlParser::eatSpace() |
| { |
| while (pos < len && txt.at(pos).isSpace() && txt.at(pos) != QChar::ParagraphSeparator) |
| pos++; |
| } |
| |
| void QTextHtmlParser::parse() |
| { |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c == QLatin1Char('<')) { |
| parseTag(); |
| } else if (c == QLatin1Char('&')) { |
| nodes.last().text += parseEntity(); |
| } else { |
| nodes.last().text += c; |
| } |
| } |
| } |
| |
| // parses a tag after "<" |
| void QTextHtmlParser::parseTag() |
| { |
| eatSpace(); |
| |
| // handle comments and other exclamation mark declarations |
| if (hasPrefix(QLatin1Char('!'))) { |
| parseExclamationTag(); |
| if (nodes.last().wsm != QTextHtmlParserNode::WhiteSpacePre |
| && nodes.last().wsm != QTextHtmlParserNode::WhiteSpacePreWrap |
| && !textEditMode) |
| eatSpace(); |
| return; |
| } |
| |
| // if close tag just close |
| if (hasPrefix(QLatin1Char('/'))) { |
| if (nodes.last().id == Html_style) { |
| #ifndef QT_NO_CSSPARSER |
| QCss::Parser parser(nodes.last().text); |
| QCss::StyleSheet sheet; |
| sheet.origin = QCss::StyleSheetOrigin_Author; |
| parser.parse(&sheet, Qt::CaseInsensitive); |
| inlineStyleSheets.append(sheet); |
| resolveStyleSheetImports(sheet); |
| #endif |
| } |
| parseCloseTag(); |
| return; |
| } |
| |
| int p = last(); |
| while (p && at(p).tag.size() == 0) |
| p = at(p).parent; |
| |
| QTextHtmlParserNode *node = newNode(p); |
| |
| // parse tag name |
| node->tag = parseWord().toLower(); |
| |
| const QTextHtmlElement *elem = lookupElementHelper(node->tag); |
| if (elem) { |
| node->id = elem->id; |
| node->displayMode = elem->displayMode; |
| } else { |
| node->id = Html_unknown; |
| } |
| |
| node->attributes.clear(); |
| // _need_ at least one space after the tag name, otherwise there can't be attributes |
| if (pos < len && txt.at(pos).isSpace()) |
| node->attributes = parseAttributes(); |
| |
| // resolveParent() may have to change the order in the tree and |
| // insert intermediate nodes for buggy HTML, so re-initialize the 'node' |
| // pointer through the return value |
| node = resolveParent(); |
| resolveNode(); |
| |
| const int nodeIndex = nodes.count() - 1; // this new node is always the last |
| #ifndef QT_NO_CSSPARSER |
| node->applyCssDeclarations(declarationsForNode(nodeIndex), resourceProvider); |
| #endif |
| applyAttributes(node->attributes); |
| |
| // finish tag |
| bool tagClosed = false; |
| while (pos < len && txt.at(pos) != QLatin1Char('>')) { |
| if (txt.at(pos) == QLatin1Char('/')) |
| tagClosed = true; |
| |
| pos++; |
| } |
| pos++; |
| |
| // in a white-space preserving environment strip off a initial newline |
| // since the element itself already generates a newline |
| if ((node->wsm == QTextHtmlParserNode::WhiteSpacePre |
| || node->wsm == QTextHtmlParserNode::WhiteSpacePreWrap) |
| && node->isBlock()) { |
| if (pos < len - 1 && txt.at(pos) == QLatin1Char('\n')) |
| ++pos; |
| } |
| |
| if (node->mayNotHaveChildren() || tagClosed) { |
| newNode(node->parent); |
| resolveNode(); |
| } |
| } |
| |
| // parses a tag beginning with "/" |
| void QTextHtmlParser::parseCloseTag() |
| { |
| ++pos; |
| QString tag = parseWord().toLower().trimmed(); |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c == QLatin1Char('>')) |
| break; |
| } |
| |
| // find corresponding open node |
| int p = last(); |
| if (p > 0 |
| && at(p - 1).tag == tag |
| && at(p - 1).mayNotHaveChildren()) |
| p--; |
| |
| while (p && at(p).tag != tag) |
| p = at(p).parent; |
| |
| // simply ignore the tag if we can't find |
| // a corresponding open node, for broken |
| // html such as <font>blah</font></font> |
| if (!p) |
| return; |
| |
| // in a white-space preserving environment strip off a trailing newline |
| // since the closing of the opening block element will automatically result |
| // in a new block for elements following the <pre> |
| // ...foo\n</pre><p>blah -> foo</pre><p>blah |
| if ((at(p).wsm == QTextHtmlParserNode::WhiteSpacePre |
| || at(p).wsm == QTextHtmlParserNode::WhiteSpacePreWrap) |
| && at(p).isBlock()) { |
| if (at(last()).text.endsWith(QLatin1Char('\n'))) |
| nodes[last()].text.chop(1); |
| } |
| |
| newNode(at(p).parent); |
| resolveNode(); |
| } |
| |
| // parses a tag beginning with "!" |
| void QTextHtmlParser::parseExclamationTag() |
| { |
| ++pos; |
| if (hasPrefix(QLatin1Char('-'),1) && hasPrefix(QLatin1Char('-'),2)) { |
| pos += 3; |
| // eat comments |
| int end = txt.indexOf(QLatin1String("-->"), pos); |
| pos = (end >= 0 ? end + 3 : len); |
| } else { |
| // eat internal tags |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c == QLatin1Char('>')) |
| break; |
| } |
| } |
| } |
| |
| // parses an entity after "&", and returns it |
| QString QTextHtmlParser::parseEntity() |
| { |
| int recover = pos; |
| QString entity; |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c.isSpace() || pos - recover > 9) { |
| goto error; |
| } |
| if (c == QLatin1Char(';')) |
| break; |
| entity += c; |
| } |
| { |
| QChar resolved = resolveEntity(entity); |
| if (!resolved.isNull()) |
| return QString(resolved); |
| } |
| if (entity.length() > 1 && entity.at(0) == QLatin1Char('#')) { |
| entity.remove(0, 1); // removing leading # |
| |
| int base = 10; |
| bool ok = false; |
| |
| if (entity.at(0).toLower() == QLatin1Char('x')) { // hex entity? |
| entity.remove(0, 1); |
| base = 16; |
| } |
| |
| uint uc = entity.toUInt(&ok, base); |
| if (ok) { |
| if (uc >= 0x80 && uc < 0x80 + (sizeof(windowsLatin1ExtendedCharacters)/sizeof(windowsLatin1ExtendedCharacters[0]))) |
| uc = windowsLatin1ExtendedCharacters[uc - 0x80]; |
| QString str; |
| if (uc > 0xffff) { |
| // surrogate pair |
| uc -= 0x10000; |
| ushort high = uc/0x400 + 0xd800; |
| ushort low = uc%0x400 + 0xdc00; |
| str.append(QChar(high)); |
| str.append(QChar(low)); |
| } else { |
| str.append(QChar(uc)); |
| } |
| return str; |
| } |
| } |
| error: |
| pos = recover; |
| return QLatin1String("&"); |
| } |
| |
| // parses one word, possibly quoted, and returns it |
| QString QTextHtmlParser::parseWord() |
| { |
| QString word; |
| if (hasPrefix(QLatin1Char('\"'))) { // double quotes |
| ++pos; |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c == QLatin1Char('\"')) |
| break; |
| else if (c == QLatin1Char('&')) |
| word += parseEntity(); |
| else |
| word += c; |
| } |
| } else if (hasPrefix(QLatin1Char('\''))) { // single quotes |
| ++pos; |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c == QLatin1Char('\'')) |
| break; |
| else |
| word += c; |
| } |
| } else { // normal text |
| while (pos < len) { |
| QChar c = txt.at(pos++); |
| if (c == QLatin1Char('>') |
| || (c == QLatin1Char('/') && hasPrefix(QLatin1Char('>'), 1)) |
| || c == QLatin1Char('<') |
| || c == QLatin1Char('=') |
| || c.isSpace()) { |
| --pos; |
| break; |
| } |
| if (c == QLatin1Char('&')) |
| word += parseEntity(); |
| else |
| word += c; |
| } |
| } |
| return word; |
| } |
| |
| // gives the new node the right parent |
| QTextHtmlParserNode *QTextHtmlParser::resolveParent() |
| { |
| QTextHtmlParserNode *node = &nodes.last(); |
| |
| int p = node->parent; |
| |
| // Excel gives us buggy HTML with just tr without surrounding table tags |
| // or with just td tags |
| |
| if (node->id == Html_td) { |
| int n = p; |
| while (n && at(n).id != Html_tr) |
| n = at(n).parent; |
| |
| if (!n) { |
| nodes.insert(nodes.count() - 1, QTextHtmlParserNode()); |
| nodes.insert(nodes.count() - 1, QTextHtmlParserNode()); |
| |
| QTextHtmlParserNode *table = &nodes[nodes.count() - 3]; |
| table->parent = p; |
| table->id = Html_table; |
| table->tag = QLatin1String("table"); |
| table->children.append(nodes.count() - 2); // add row as child |
| |
| QTextHtmlParserNode *row = &nodes[nodes.count() - 2]; |
| row->parent = nodes.count() - 3; // table as parent |
| row->id = Html_tr; |
| row->tag = QLatin1String("tr"); |
| |
| p = nodes.count() - 2; |
| node = &nodes.last(); // re-initialize pointer |
| } |
| } |
| |
| if (node->id == Html_tr) { |
| int n = p; |
| while (n && at(n).id != Html_table) |
| n = at(n).parent; |
| |
| if (!n) { |
| nodes.insert(nodes.count() - 1, QTextHtmlParserNode()); |
| QTextHtmlParserNode *table = &nodes[nodes.count() - 2]; |
| table->parent = p; |
| table->id = Html_table; |
| table->tag = QLatin1String("table"); |
| p = nodes.count() - 2; |
| node = &nodes.last(); // re-initialize pointer |
| } |
| } |
| |
| // permit invalid html by letting block elements be children |
| // of inline elements with the exception of paragraphs: |
| // |
| // a new paragraph closes parent inline elements (while loop), |
| // unless they themselves are children of a non-paragraph block |
| // element (if statement) |
| // |
| // For example: |
| // |
| // <body><p><b>Foo<p>Bar <-- second <p> implicitly closes <b> that |
| // belongs to the first <p>. The self-nesting |
| // check further down prevents the second <p> |
| // from nesting into the first one then. |
| // so Bar is not bold. |
| // |
| // <body><b><p>Foo <-- Foo should be bold. |
| // |
| // <body><b><p>Foo<p>Bar <-- Foo and Bar should be bold. |
| // |
| if (node->id == Html_p) { |
| while (p && !at(p).isBlock()) |
| p = at(p).parent; |
| |
| if (!p || at(p).id != Html_p) |
| p = node->parent; |
| } |
| |
| // some elements are not self nesting |
| if (node->id == at(p).id |
| && node->isNotSelfNesting()) |
| p = at(p).parent; |
| |
| // some elements are not allowed in certain contexts |
| while ((p && !node->allowedInContext(at(p).id)) |
| // ### make new styles aware of empty tags |
| || at(p).mayNotHaveChildren() |
| ) { |
| p = at(p).parent; |
| } |
| |
| node->parent = p; |
| |
| // makes it easier to traverse the tree, later |
| nodes[p].children.append(nodes.count() - 1); |
| return node; |
| } |
| |
| // sets all properties on the new node |
| void QTextHtmlParser::resolveNode() |
| { |
| QTextHtmlParserNode *node = &nodes.last(); |
| const QTextHtmlParserNode *parent = &nodes.at(node->parent); |
| node->initializeProperties(parent, this); |
| } |
| |
| bool QTextHtmlParserNode::isNestedList(const QTextHtmlParser *parser) const |
| { |
| if (!isListStart()) |
| return false; |
| |
| int p = parent; |
| while (p) { |
| if (parser->at(p).isListStart()) |
| return true; |
| p = parser->at(p).parent; |
| } |
| return false; |
| } |
| |
| void QTextHtmlParserNode::initializeProperties(const QTextHtmlParserNode *parent, const QTextHtmlParser *parser) |
| { |
| // inherit properties from parent element |
| charFormat = parent->charFormat; |
| |
| if (id == Html_html) |
| blockFormat.setLayoutDirection(Qt::LeftToRight); // HTML default |
| else if (parent->blockFormat.hasProperty(QTextFormat::LayoutDirection)) |
| blockFormat.setLayoutDirection(parent->blockFormat.layoutDirection()); |
| |
| if (parent->displayMode == QTextHtmlElement::DisplayNone) |
| displayMode = QTextHtmlElement::DisplayNone; |
| |
| if (parent->id != Html_table || id == Html_caption) { |
| if (parent->blockFormat.hasProperty(QTextFormat::BlockAlignment)) |
| blockFormat.setAlignment(parent->blockFormat.alignment()); |
| else |
| blockFormat.clearProperty(QTextFormat::BlockAlignment); |
| } |
| // we don't paint per-row background colors, yet. so as an |
| // exception inherit the background color here |
| // we also inherit the background between inline elements |
| if ((parent->id != Html_tr || !isTableCell()) |
| && (displayMode != QTextHtmlElement::DisplayInline || parent->displayMode != QTextHtmlElement::DisplayInline)) { |
| charFormat.clearProperty(QTextFormat::BackgroundBrush); |
| } |
| |
| listStyle = parent->listStyle; |
| // makes no sense to inherit that property, a named anchor is a single point |
| // in the document, which is set by the DocumentFragment |
| charFormat.clearProperty(QTextFormat::AnchorName); |
| wsm = parent->wsm; |
| |
| // initialize remaining properties |
| margin[QTextHtmlParser::MarginLeft] = 0; |
| margin[QTextHtmlParser::MarginRight] = 0; |
| margin[QTextHtmlParser::MarginTop] = 0; |
| margin[QTextHtmlParser::MarginBottom] = 0; |
| cssFloat = QTextFrameFormat::InFlow; |
| |
| for (int i = 0; i < 4; ++i) |
| padding[i] = -1; |
| |
| // set element specific attributes |
| switch (id) { |
| case Html_a: |
| charFormat.setAnchor(true); |
| for (int i = 0; i < attributes.count(); i += 2) { |
| const QString key = attributes.at(i); |
| if (key.compare(QLatin1String("href"), Qt::CaseInsensitive) == 0 |
| && !attributes.at(i + 1).isEmpty()) { |
| hasHref = true; |
| charFormat.setUnderlineStyle(QTextCharFormat::SingleUnderline); |
| charFormat.setForeground(QApplication::palette().link()); |
| } |
| } |
| |
| break; |
| case Html_em: |
| case Html_i: |
| case Html_cite: |
| case Html_address: |
| case Html_var: |
| case Html_dfn: |
| charFormat.setFontItalic(true); |
| break; |
| case Html_big: |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(1)); |
| break; |
| case Html_small: |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(-1)); |
| break; |
| case Html_strong: |
| case Html_b: |
| charFormat.setFontWeight(QFont::Bold); |
| break; |
| case Html_h1: |
| charFormat.setFontWeight(QFont::Bold); |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(3)); |
| margin[QTextHtmlParser::MarginTop] = 18; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| break; |
| case Html_h2: |
| charFormat.setFontWeight(QFont::Bold); |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(2)); |
| margin[QTextHtmlParser::MarginTop] = 16; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| break; |
| case Html_h3: |
| charFormat.setFontWeight(QFont::Bold); |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(1)); |
| margin[QTextHtmlParser::MarginTop] = 14; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| break; |
| case Html_h4: |
| charFormat.setFontWeight(QFont::Bold); |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(0)); |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| break; |
| case Html_h5: |
| charFormat.setFontWeight(QFont::Bold); |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, int(-1)); |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 4; |
| break; |
| case Html_p: |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| break; |
| case Html_center: |
| blockFormat.setAlignment(Qt::AlignCenter); |
| break; |
| case Html_ul: |
| listStyle = QTextListFormat::ListDisc; |
| // nested lists don't have margins, except for the toplevel one |
| if (!isNestedList(parser)) { |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| } |
| // no left margin as we use indenting instead |
| break; |
| case Html_ol: |
| listStyle = QTextListFormat::ListDecimal; |
| // nested lists don't have margins, except for the toplevel one |
| if (!isNestedList(parser)) { |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| } |
| // no left margin as we use indenting instead |
| break; |
| case Html_code: |
| case Html_tt: |
| case Html_kbd: |
| case Html_samp: |
| charFormat.setFontFamily(QString::fromLatin1("Courier New,courier")); |
| // <tt> uses a fixed font, so set the property |
| charFormat.setFontFixedPitch(true); |
| break; |
| case Html_br: |
| text = QChar(QChar::LineSeparator); |
| wsm = QTextHtmlParserNode::WhiteSpacePre; |
| break; |
| // ##### sub / sup |
| case Html_pre: |
| charFormat.setFontFamily(QString::fromLatin1("Courier New,courier")); |
| wsm = WhiteSpacePre; |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| // <pre> uses a fixed font |
| charFormat.setFontFixedPitch(true); |
| break; |
| case Html_blockquote: |
| margin[QTextHtmlParser::MarginTop] = 12; |
| margin[QTextHtmlParser::MarginBottom] = 12; |
| margin[QTextHtmlParser::MarginLeft] = 40; |
| margin[QTextHtmlParser::MarginRight] = 40; |
| break; |
| case Html_dl: |
| margin[QTextHtmlParser::MarginTop] = 8; |
| margin[QTextHtmlParser::MarginBottom] = 8; |
| break; |
| case Html_dd: |
| margin[QTextHtmlParser::MarginLeft] = 30; |
| break; |
| case Html_u: |
| charFormat.setUnderlineStyle(QTextCharFormat::SingleUnderline); |
| break; |
| case Html_s: |
| charFormat.setFontStrikeOut(true); |
| break; |
| case Html_nobr: |
| wsm = WhiteSpaceNoWrap; |
| break; |
| case Html_th: |
| charFormat.setFontWeight(QFont::Bold); |
| blockFormat.setAlignment(Qt::AlignCenter); |
| break; |
| case Html_td: |
| blockFormat.setAlignment(Qt::AlignLeft); |
| break; |
| case Html_sub: |
| charFormat.setVerticalAlignment(QTextCharFormat::AlignSubScript); |
| break; |
| case Html_sup: |
| charFormat.setVerticalAlignment(QTextCharFormat::AlignSuperScript); |
| break; |
| default: break; |
| } |
| } |
| |
| #ifndef QT_NO_CSSPARSER |
| void QTextHtmlParserNode::setListStyle(const QVector<QCss::Value> &cssValues) |
| { |
| for (int i = 0; i < cssValues.count(); ++i) { |
| if (cssValues.at(i).type == QCss::Value::KnownIdentifier) { |
| switch (static_cast<QCss::KnownValue>(cssValues.at(i).variant.toInt())) { |
| case QCss::Value_Disc: hasOwnListStyle = true; listStyle = QTextListFormat::ListDisc; break; |
| case QCss::Value_Square: hasOwnListStyle = true; listStyle = QTextListFormat::ListSquare; break; |
| case QCss::Value_Circle: hasOwnListStyle = true; listStyle = QTextListFormat::ListCircle; break; |
| case QCss::Value_Decimal: hasOwnListStyle = true; listStyle = QTextListFormat::ListDecimal; break; |
| case QCss::Value_LowerAlpha: hasOwnListStyle = true; listStyle = QTextListFormat::ListLowerAlpha; break; |
| case QCss::Value_UpperAlpha: hasOwnListStyle = true; listStyle = QTextListFormat::ListUpperAlpha; break; |
| case QCss::Value_LowerRoman: hasOwnListStyle = true; listStyle = QTextListFormat::ListLowerRoman; break; |
| case QCss::Value_UpperRoman: hasOwnListStyle = true; listStyle = QTextListFormat::ListUpperRoman; break; |
| default: break; |
| } |
| } |
| } |
| // allow individual list items to override the style |
| if (id == Html_li && hasOwnListStyle) |
| blockFormat.setProperty(QTextFormat::ListStyle, listStyle); |
| } |
| |
| void QTextHtmlParserNode::applyCssDeclarations(const QVector<QCss::Declaration> &declarations, const QTextDocument *resourceProvider) |
| { |
| QCss::ValueExtractor extractor(declarations); |
| extractor.extractBox(margin, padding); |
| |
| for (int i = 0; i < declarations.count(); ++i) { |
| const QCss::Declaration &decl = declarations.at(i); |
| if (decl.d->values.isEmpty()) continue; |
| |
| QCss::KnownValue identifier = QCss::UnknownValue; |
| if (decl.d->values.first().type == QCss::Value::KnownIdentifier) |
| identifier = static_cast<QCss::KnownValue>(decl.d->values.first().variant.toInt()); |
| |
| switch (decl.d->propertyId) { |
| case QCss::BorderColor: borderBrush = QBrush(decl.colorValue()); break; |
| case QCss::BorderStyles: |
| if (decl.styleValue() != QCss::BorderStyle_Unknown && decl.styleValue() != QCss::BorderStyle_Native) |
| borderStyle = static_cast<QTextFrameFormat::BorderStyle>(decl.styleValue() - 1); |
| break; |
| case QCss::BorderWidth: |
| tableBorder = extractor.lengthValue(decl); |
| break; |
| case QCss::Color: charFormat.setForeground(decl.colorValue()); break; |
| case QCss::Float: |
| cssFloat = QTextFrameFormat::InFlow; |
| switch (identifier) { |
| case QCss::Value_Left: cssFloat = QTextFrameFormat::FloatLeft; break; |
| case QCss::Value_Right: cssFloat = QTextFrameFormat::FloatRight; break; |
| default: break; |
| } |
| break; |
| case QCss::QtBlockIndent: |
| blockFormat.setIndent(decl.d->values.first().variant.toInt()); |
| break; |
| case QCss::TextIndent: { |
| qreal indent = 0; |
| if (decl.realValue(&indent, "px")) |
| blockFormat.setTextIndent(indent); |
| break; } |
| case QCss::QtListIndent: |
| if (decl.intValue(&cssListIndent)) |
| hasCssListIndent = true; |
| break; |
| case QCss::QtParagraphType: |
| if (decl.d->values.first().variant.toString().compare(QLatin1String("empty"), Qt::CaseInsensitive) == 0) |
| isEmptyParagraph = true; |
| break; |
| case QCss::QtTableType: |
| if (decl.d->values.first().variant.toString().compare(QLatin1String("frame"), Qt::CaseInsensitive) == 0) |
| isTextFrame = true; |
| else if (decl.d->values.first().variant.toString().compare(QLatin1String("root"), Qt::CaseInsensitive) == 0) { |
| isTextFrame = true; |
| isRootFrame = true; |
| } |
| break; |
| case QCss::QtUserState: |
| userState = decl.d->values.first().variant.toInt(); |
| break; |
| case QCss::Whitespace: |
| switch (identifier) { |
| case QCss::Value_Normal: wsm = QTextHtmlParserNode::WhiteSpaceNormal; break; |
| case QCss::Value_Pre: wsm = QTextHtmlParserNode::WhiteSpacePre; break; |
| case QCss::Value_NoWrap: wsm = QTextHtmlParserNode::WhiteSpaceNoWrap; break; |
| case QCss::Value_PreWrap: wsm = QTextHtmlParserNode::WhiteSpacePreWrap; break; |
| default: break; |
| } |
| break; |
| case QCss::VerticalAlignment: |
| switch (identifier) { |
| case QCss::Value_Sub: charFormat.setVerticalAlignment(QTextCharFormat::AlignSubScript); break; |
| case QCss::Value_Super: charFormat.setVerticalAlignment(QTextCharFormat::AlignSuperScript); break; |
| case QCss::Value_Middle: charFormat.setVerticalAlignment(QTextCharFormat::AlignMiddle); break; |
| case QCss::Value_Top: charFormat.setVerticalAlignment(QTextCharFormat::AlignTop); break; |
| case QCss::Value_Bottom: charFormat.setVerticalAlignment(QTextCharFormat::AlignBottom); break; |
| default: charFormat.setVerticalAlignment(QTextCharFormat::AlignNormal); break; |
| } |
| break; |
| case QCss::PageBreakBefore: |
| switch (identifier) { |
| case QCss::Value_Always: blockFormat.setPageBreakPolicy(blockFormat.pageBreakPolicy() | QTextFormat::PageBreak_AlwaysBefore); break; |
| case QCss::Value_Auto: blockFormat.setPageBreakPolicy(blockFormat.pageBreakPolicy() & ~QTextFormat::PageBreak_AlwaysBefore); break; |
| default: break; |
| } |
| break; |
| case QCss::PageBreakAfter: |
| switch (identifier) { |
| case QCss::Value_Always: blockFormat.setPageBreakPolicy(blockFormat.pageBreakPolicy() | QTextFormat::PageBreak_AlwaysAfter); break; |
| case QCss::Value_Auto: blockFormat.setPageBreakPolicy(blockFormat.pageBreakPolicy() & ~QTextFormat::PageBreak_AlwaysAfter); break; |
| default: break; |
| } |
| break; |
| case QCss::TextUnderlineStyle: |
| switch (identifier) { |
| case QCss::Value_None: charFormat.setUnderlineStyle(QTextCharFormat::NoUnderline); break; |
| case QCss::Value_Solid: charFormat.setUnderlineStyle(QTextCharFormat::SingleUnderline); break; |
| case QCss::Value_Dashed: charFormat.setUnderlineStyle(QTextCharFormat::DashUnderline); break; |
| case QCss::Value_Dotted: charFormat.setUnderlineStyle(QTextCharFormat::DotLine); break; |
| case QCss::Value_DotDash: charFormat.setUnderlineStyle(QTextCharFormat::DashDotLine); break; |
| case QCss::Value_DotDotDash: charFormat.setUnderlineStyle(QTextCharFormat::DashDotDotLine); break; |
| case QCss::Value_Wave: charFormat.setUnderlineStyle(QTextCharFormat::WaveUnderline); break; |
| default: break; |
| } |
| break; |
| case QCss::ListStyleType: |
| case QCss::ListStyle: |
| setListStyle(decl.d->values); |
| break; |
| default: break; |
| } |
| } |
| |
| QFont f; |
| int adjustment = -255; |
| extractor.extractFont(&f, &adjustment); |
| if (f.resolve() & QFont::SizeResolved) { |
| if (f.pointSize() > 0) { |
| charFormat.setFontPointSize(f.pointSize()); |
| } else if (f.pixelSize() > 0) { |
| charFormat.setProperty(QTextFormat::FontPixelSize, f.pixelSize()); |
| } |
| } |
| if (f.resolve() & QFont::StyleResolved) |
| charFormat.setFontItalic(f.style() != QFont::StyleNormal); |
| |
| if (f.resolve() & QFont::WeightResolved) |
| charFormat.setFontWeight(f.weight()); |
| |
| if (f.resolve() & QFont::FamilyResolved) |
| charFormat.setFontFamily(f.family()); |
| |
| if (f.resolve() & QFont::UnderlineResolved) |
| charFormat.setUnderlineStyle(f.underline() ? QTextCharFormat::SingleUnderline : QTextCharFormat::NoUnderline); |
| |
| if (f.resolve() & QFont::OverlineResolved) |
| charFormat.setFontOverline(f.overline()); |
| |
| if (f.resolve() & QFont::StrikeOutResolved) |
| charFormat.setFontStrikeOut(f.strikeOut()); |
| |
| if (f.resolve() & QFont::CapitalizationResolved) |
| charFormat.setFontCapitalization(f.capitalization()); |
| |
| if (adjustment >= -1) |
| charFormat.setProperty(QTextFormat::FontSizeAdjustment, adjustment); |
| |
| { |
| Qt::Alignment ignoredAlignment; |
| QCss::Repeat ignoredRepeat; |
| QString bgImage; |
| QBrush bgBrush; |
| QCss::Origin ignoredOrigin, ignoredClip; |
| QCss::Attachment ignoredAttachment; |
| extractor.extractBackground(&bgBrush, &bgImage, &ignoredRepeat, &ignoredAlignment, |
| &ignoredOrigin, &ignoredAttachment, &ignoredClip); |
| |
| if (!bgImage.isEmpty() && resourceProvider) { |
| applyBackgroundImage(bgImage, resourceProvider); |
| } else if (bgBrush.style() != Qt::NoBrush) { |
| charFormat.setBackground(bgBrush); |
| } |
| } |
| } |
| |
| #endif // QT_NO_CSSPARSER |
| |
| void QTextHtmlParserNode::applyBackgroundImage(const QString &url, const QTextDocument *resourceProvider) |
| { |
| if (!url.isEmpty() && resourceProvider) { |
| QVariant val = resourceProvider->resource(QTextDocument::ImageResource, url); |
| |
| if (qApp->thread() != QThread::currentThread()) { |
| // must use images in non-GUI threads |
| if (val.type() == QVariant::Image) { |
| QImage image = qvariant_cast<QImage>(val); |
| charFormat.setBackground(image); |
| } else if (val.type() == QVariant::ByteArray) { |
| QImage image; |
| if (image.loadFromData(val.toByteArray())) { |
| charFormat.setBackground(image); |
| } |
| } |
| } else { |
| if (val.type() == QVariant::Image || val.type() == QVariant::Pixmap) { |
| charFormat.setBackground(qvariant_cast<QPixmap>(val)); |
| } else if (val.type() == QVariant::ByteArray) { |
| QPixmap pm; |
| if (pm.loadFromData(val.toByteArray())) { |
| charFormat.setBackground(pm); |
| } |
| } |
| } |
| } |
| if (!url.isEmpty()) |
| charFormat.setProperty(QTextFormat::BackgroundImageUrl, url); |
| } |
| |
| bool QTextHtmlParserNode::hasOnlyWhitespace() const |
| { |
| for (int i = 0; i < text.count(); ++i) |
| if (!text.at(i).isSpace() || text.at(i) == QChar::LineSeparator) |
| return false; |
| return true; |
| } |
| |
| static bool setIntAttribute(int *destination, const QString &value) |
| { |
| bool ok = false; |
| int val = value.toInt(&ok); |
| if (ok) |
| *destination = val; |
| |
| return ok; |
| } |
| |
| static bool setFloatAttribute(qreal *destination, const QString &value) |
| { |
| bool ok = false; |
| qreal val = value.toDouble(&ok); |
| if (ok) |
| *destination = val; |
| |
| return ok; |
| } |
| |
| static void setWidthAttribute(QTextLength *width, QString value) |
| { |
| bool ok = false; |
| qreal realVal = value.toDouble(&ok); |
| if (ok) { |
| *width = QTextLength(QTextLength::FixedLength, realVal); |
| } else { |
| value = value.trimmed(); |
| if (!value.isEmpty() && value.endsWith(QLatin1Char('%'))) { |
| value.chop(1); |
| realVal = value.toDouble(&ok); |
| if (ok) |
| *width = QTextLength(QTextLength::PercentageLength, realVal); |
| } |
| } |
| } |
| |
| #ifndef QT_NO_CSSPARSER |
| void QTextHtmlParserNode::parseStyleAttribute(const QString &value, const QTextDocument *resourceProvider) |
| { |
| QString css = value; |
| css.prepend(QLatin1String("* {")); |
| css.append(QLatin1Char('}')); |
| QCss::Parser parser(css); |
| QCss::StyleSheet sheet; |
| parser.parse(&sheet, Qt::CaseInsensitive); |
| if (sheet.styleRules.count() != 1) return; |
| applyCssDeclarations(sheet.styleRules.at(0).declarations, resourceProvider); |
| } |
| #endif |
| |
| QStringList QTextHtmlParser::parseAttributes() |
| { |
| QStringList attrs; |
| |
| while (pos < len) { |
| eatSpace(); |
| if (hasPrefix(QLatin1Char('>')) || hasPrefix(QLatin1Char('/'))) |
| break; |
| QString key = parseWord().toLower(); |
| QString value = QLatin1String("1"); |
| if (key.size() == 0) |
| break; |
| eatSpace(); |
| if (hasPrefix(QLatin1Char('='))){ |
| pos++; |
| eatSpace(); |
| value = parseWord(); |
| } |
| if (value.size() == 0) |
| continue; |
| attrs << key << value; |
| } |
| |
| return attrs; |
| } |
| |
| void QTextHtmlParser::applyAttributes(const QStringList &attributes) |
| { |
| // local state variable for qt3 textedit mode |
| bool seenQt3Richtext = false; |
| QString linkHref; |
| QString linkType; |
| |
| if (attributes.count() % 2 == 1) |
| return; |
| |
| QTextHtmlParserNode *node = &nodes.last(); |
| |
| for (int i = 0; i < attributes.count(); i += 2) { |
| QString key = attributes.at(i); |
| QString value = attributes.at(i + 1); |
| |
| switch (node->id) { |
| case Html_font: |
| // the infamous font tag |
| if (key == QLatin1String("size") && value.size()) { |
| int n = value.toInt(); |
| if (value.at(0) != QLatin1Char('+') && value.at(0) != QLatin1Char('-')) |
| n -= 3; |
| node->charFormat.setProperty(QTextFormat::FontSizeAdjustment, n); |
| } else if (key == QLatin1String("face")) { |
| node->charFormat.setFontFamily(value); |
| } else if (key == QLatin1String("color")) { |
| QColor c; c.setNamedColor(value); |
| if (!c.isValid()) |
| qWarning("QTextHtmlParser::applyAttributes: Unknown color name '%s'",value.toLatin1().constData()); |
| node->charFormat.setForeground(c); |
| } |
| break; |
| case Html_ol: |
| case Html_ul: |
| if (key == QLatin1String("type")) { |
| node->hasOwnListStyle = true; |
| if (value == QLatin1String("1")) { |
| node->listStyle = QTextListFormat::ListDecimal; |
| } else if (value == QLatin1String("a")) { |
| node->listStyle = QTextListFormat::ListLowerAlpha; |
| } else if (value == QLatin1String("A")) { |
| node->listStyle = QTextListFormat::ListUpperAlpha; |
| } else if (value == QLatin1String("i")) { |
| node->listStyle = QTextListFormat::ListLowerRoman; |
| } else if (value == QLatin1String("I")) { |
| node->listStyle = QTextListFormat::ListUpperRoman; |
| } else { |
| value = value.toLower(); |
| if (value == QLatin1String("square")) |
| node->listStyle = QTextListFormat::ListSquare; |
| else if (value == QLatin1String("disc")) |
| node->listStyle = QTextListFormat::ListDisc; |
| else if (value == QLatin1String("circle")) |
| node->listStyle = QTextListFormat::ListCircle; |
| } |
| } |
| break; |
| case Html_a: |
| if (key == QLatin1String("href")) |
| node->charFormat.setAnchorHref(value); |
| else if (key == QLatin1String("name")) |
| node->charFormat.setAnchorName(value); |
| break; |
| case Html_img: |
| if (key == QLatin1String("src") || key == QLatin1String("source")) { |
| node->imageName = value; |
| } else if (key == QLatin1String("width")) { |
| node->imageWidth = -2; // register that there is a value for it. |
| setFloatAttribute(&node->imageWidth, value); |
| } else if (key == QLatin1String("height")) { |
| node->imageHeight = -2; // register that there is a value for it. |
| setFloatAttribute(&node->imageHeight, value); |
| } |
| break; |
| case Html_tr: |
| case Html_body: |
| if (key == QLatin1String("bgcolor")) { |
| QColor c; c.setNamedColor(value); |
| if (!c.isValid()) |
| qWarning("QTextHtmlParser::applyAttributes: Unknown color name '%s'",value.toLatin1().constData()); |
| node->charFormat.setBackground(c); |
| } else if (key == QLatin1String("background")) { |
| node->applyBackgroundImage(value, resourceProvider); |
| } |
| break; |
| case Html_th: |
| case Html_td: |
| if (key == QLatin1String("width")) { |
| setWidthAttribute(&node->width, value); |
| } else if (key == QLatin1String("bgcolor")) { |
| QColor c; c.setNamedColor(value); |
| if (!c.isValid()) |
| qWarning("QTextHtmlParser::applyAttributes: Unknown color name '%s'",value.toLatin1().constData()); |
| node->charFormat.setBackground(c); |
| } else if (key == QLatin1String("background")) { |
| node->applyBackgroundImage(value, resourceProvider); |
| } else if (key == QLatin1String("rowspan")) { |
| if (setIntAttribute(&node->tableCellRowSpan, value)) |
| node->tableCellRowSpan = qMax(1, node->tableCellRowSpan); |
| } else if (key == QLatin1String("colspan")) { |
| if (setIntAttribute(&node->tableCellColSpan, value)) |
| node->tableCellColSpan = qMax(1, node->tableCellColSpan); |
| } |
| break; |
| case Html_table: |
| if (key == QLatin1String("border")) { |
| setFloatAttribute(&node->tableBorder, value); |
| } else if (key == QLatin1String("bgcolor")) { |
| QColor c; c.setNamedColor(value); |
| if (!c.isValid()) |
| qWarning("QTextHtmlParser::applyAttributes: Unknown color name '%s'",value.toLatin1().constData()); |
| node->charFormat.setBackground(c); |
| } else if (key == QLatin1String("background")) { |
| node->applyBackgroundImage(value, resourceProvider); |
| } else if (key == QLatin1String("cellspacing")) { |
| setFloatAttribute(&node->tableCellSpacing, value); |
| } else if (key == QLatin1String("cellpadding")) { |
| setFloatAttribute(&node->tableCellPadding, value); |
| } else if (key == QLatin1String("width")) { |
| setWidthAttribute(&node->width, value); |
| } else if (key == QLatin1String("height")) { |
| setWidthAttribute(&node->height, value); |
| } |
| break; |
| case Html_meta: |
| if (key == QLatin1String("name") |
| && value == QLatin1String("qrichtext")) { |
| seenQt3Richtext = true; |
| } |
| |
| if (key == QLatin1String("content") |
| && value == QLatin1String("1") |
| && seenQt3Richtext) { |
| |
| textEditMode = true; |
| } |
| break; |
| case Html_hr: |
| if (key == QLatin1String("width")) |
| setWidthAttribute(&node->width, value); |
| break; |
| case Html_link: |
| if (key == QLatin1String("href")) |
| linkHref = value; |
| else if (key == QLatin1String("type")) |
| linkType = value; |
| break; |
| default: |
| break; |
| } |
| |
| if (key == QLatin1String("style")) { |
| #ifndef QT_NO_CSSPARSER |
| node->parseStyleAttribute(value, resourceProvider); |
| #endif |
| } else if (key == QLatin1String("align")) { |
| value = value.toLower(); |
| bool alignmentSet = true; |
| |
| if (value == QLatin1String("left")) |
| node->blockFormat.setAlignment(Qt::AlignLeft|Qt::AlignAbsolute); |
| else if (value == QLatin1String("right")) |
| node->blockFormat.setAlignment(Qt::AlignRight|Qt::AlignAbsolute); |
| else if (value == QLatin1String("center")) |
| node->blockFormat.setAlignment(Qt::AlignHCenter); |
| else if (value == QLatin1String("justify")) |
| node->blockFormat.setAlignment(Qt::AlignJustify); |
| else |
| alignmentSet = false; |
| |
| if (node->id == Html_img) { |
| // HTML4 compat |
| if (alignmentSet) { |
| if (node->blockFormat.alignment() & Qt::AlignLeft) |
| node->cssFloat = QTextFrameFormat::FloatLeft; |
| else if (node->blockFormat.alignment() & Qt::AlignRight) |
| node->cssFloat = QTextFrameFormat::FloatRight; |
| } else if (value == QLatin1String("middle")) { |
| node->charFormat.setVerticalAlignment(QTextCharFormat::AlignMiddle); |
| } else if (value == QLatin1String("top")) { |
| node->charFormat.setVerticalAlignment(QTextCharFormat::AlignTop); |
| } |
| } |
| } else if (key == QLatin1String("valign")) { |
| value = value.toLower(); |
| if (value == QLatin1String("top")) |
| node->charFormat.setVerticalAlignment(QTextCharFormat::AlignTop); |
| else if (value == QLatin1String("middle")) |
| node->charFormat.setVerticalAlignment(QTextCharFormat::AlignMiddle); |
| else if (value == QLatin1String("bottom")) |
| node->charFormat.setVerticalAlignment(QTextCharFormat::AlignBottom); |
| } else if (key == QLatin1String("dir")) { |
| value = value.toLower(); |
| if (value == QLatin1String("ltr")) |
| node->blockFormat.setLayoutDirection(Qt::LeftToRight); |
| else if (value == QLatin1String("rtl")) |
| node->blockFormat.setLayoutDirection(Qt::RightToLeft); |
| } else if (key == QLatin1String("title")) { |
| node->charFormat.setToolTip(value); |
| } else if (key == QLatin1String("id")) { |
| node->charFormat.setAnchor(true); |
| node->charFormat.setAnchorName(value); |
| } |
| } |
| |
| #ifndef QT_NO_CSSPARSER |
| if (resourceProvider && !linkHref.isEmpty() && linkType == QLatin1String("text/css")) |
| importStyleSheet(linkHref); |
| #endif |
| } |
| |
| #ifndef QT_NO_CSSPARSER |
| class QTextHtmlStyleSelector : public QCss::StyleSelector |
| { |
| public: |
| inline QTextHtmlStyleSelector(const QTextHtmlParser *parser) |
| : parser(parser) { nameCaseSensitivity = Qt::CaseInsensitive; } |
| |
| virtual QStringList nodeNames(NodePtr node) const; |
| virtual QString attribute(NodePtr node, const QString &name) const; |
| virtual bool hasAttributes(NodePtr node) const; |
| virtual bool isNullNode(NodePtr node) const; |
| virtual NodePtr parentNode(NodePtr node) const; |
| virtual NodePtr previousSiblingNode(NodePtr node) const; |
| virtual NodePtr duplicateNode(NodePtr node) const; |
| virtual void freeNode(NodePtr node) const; |
| |
| private: |
| const QTextHtmlParser *parser; |
| }; |
| |
| QStringList QTextHtmlStyleSelector::nodeNames(NodePtr node) const |
| { |
| return QStringList(parser->at(node.id).tag.toLower()); |
| } |
| |
| #endif // QT_NO_CSSPARSER |
| |
| static inline int findAttribute(const QStringList &attributes, const QString &name) |
| { |
| int idx = -1; |
| do { |
| idx = attributes.indexOf(name, idx + 1); |
| } while (idx != -1 && (idx % 2 == 1)); |
| return idx; |
| } |
| |
| #ifndef QT_NO_CSSPARSER |
| |
| QString QTextHtmlStyleSelector::attribute(NodePtr node, const QString &name) const |
| { |
| const QStringList &attributes = parser->at(node.id).attributes; |
| const int idx = findAttribute(attributes, name); |
| if (idx == -1) |
| return QString(); |
| return attributes.at(idx + 1); |
| } |
| |
| bool QTextHtmlStyleSelector::hasAttributes(NodePtr node) const |
| { |
| const QStringList &attributes = parser->at(node.id).attributes; |
| return !attributes.isEmpty(); |
| } |
| |
| bool QTextHtmlStyleSelector::isNullNode(NodePtr node) const |
| { |
| return node.id == 0; |
| } |
| |
| QCss::StyleSelector::NodePtr QTextHtmlStyleSelector::parentNode(NodePtr node) const |
| { |
| NodePtr parent; |
| parent.id = 0; |
| if (node.id) { |
| parent.id = parser->at(node.id).parent; |
| } |
| return parent; |
| } |
| |
| QCss::StyleSelector::NodePtr QTextHtmlStyleSelector::duplicateNode(NodePtr node) const |
| { |
| return node; |
| } |
| |
| QCss::StyleSelector::NodePtr QTextHtmlStyleSelector::previousSiblingNode(NodePtr node) const |
| { |
| NodePtr sibling; |
| sibling.id = 0; |
| if (!node.id) |
| return sibling; |
| int parent = parser->at(node.id).parent; |
| if (!parent) |
| return sibling; |
| const int childIdx = parser->at(parent).children.indexOf(node.id); |
| if (childIdx <= 0) |
| return sibling; |
| sibling.id = parser->at(parent).children.at(childIdx - 1); |
| return sibling; |
| } |
| |
| void QTextHtmlStyleSelector::freeNode(NodePtr) const |
| { |
| } |
| |
| void QTextHtmlParser::resolveStyleSheetImports(const QCss::StyleSheet &sheet) |
| { |
| for (int i = 0; i < sheet.importRules.count(); ++i) { |
| const QCss::ImportRule &rule = sheet.importRules.at(i); |
| if (rule.media.isEmpty() |
| || rule.media.contains(QLatin1String("screen"), Qt::CaseInsensitive)) |
| importStyleSheet(rule.href); |
| } |
| } |
| |
| void QTextHtmlParser::importStyleSheet(const QString &href) |
| { |
| if (!resourceProvider) |
| return; |
| for (int i = 0; i < externalStyleSheets.count(); ++i) |
| if (externalStyleSheets.at(i).url == href) |
| return; |
| |
| QVariant res = resourceProvider->resource(QTextDocument::StyleSheetResource, href); |
| QString css; |
| if (res.type() == QVariant::String) { |
| css = res.toString(); |
| } else if (res.type() == QVariant::ByteArray) { |
| // #### detect @charset |
| css = QString::fromUtf8(res.toByteArray()); |
| } |
| if (!css.isEmpty()) { |
| QCss::Parser parser(css); |
| QCss::StyleSheet sheet; |
| parser.parse(&sheet, Qt::CaseInsensitive); |
| externalStyleSheets.append(ExternalStyleSheet(href, sheet)); |
| resolveStyleSheetImports(sheet); |
| } |
| } |
| |
| QVector<QCss::Declaration> QTextHtmlParser::declarationsForNode(int node) const |
| { |
| QVector<QCss::Declaration> decls; |
| |
| QTextHtmlStyleSelector selector(this); |
| |
| int idx = 0; |
| selector.styleSheets.resize((resourceProvider ? 1 : 0) |
| + externalStyleSheets.count() |
| + inlineStyleSheets.count()); |
| if (resourceProvider) |
| selector.styleSheets[idx++] = resourceProvider->docHandle()->parsedDefaultStyleSheet; |
| |
| for (int i = 0; i < externalStyleSheets.count(); ++i, ++idx) |
| selector.styleSheets[idx] = externalStyleSheets.at(i).sheet; |
| |
| for (int i = 0; i < inlineStyleSheets.count(); ++i, ++idx) |
| selector.styleSheets[idx] = inlineStyleSheets.at(i); |
| |
| selector.medium = QLatin1String("screen"); |
| |
| QCss::StyleSelector::NodePtr n; |
| n.id = node; |
| |
| const char *extraPseudo = 0; |
| if (nodes.at(node).id == Html_a && nodes.at(node).hasHref) |
| extraPseudo = "link"; |
| decls = selector.declarationsForNode(n, extraPseudo); |
| |
| return decls; |
| } |
| |
| bool QTextHtmlParser::nodeIsChildOf(int i, QTextHTMLElements id) const |
| { |
| while (i) { |
| if (at(i).id == id) |
| return true; |
| i = at(i).parent; |
| } |
| return false; |
| } |
| |
| QT_END_NAMESPACE |
| #endif // QT_NO_CSSPARSER |
| |
| #endif // QT_NO_TEXTHTMLPARSER |
