f9f395c28b
Updated version of LGPL and FDL licenseheaders. Apply release phase licenseheaders for all source files. Reviewed-by: Trust Me
1906 lines
65 KiB
C++
1906 lines
65 KiB
C++
/****************************************************************************
|
|
**
|
|
** 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::LineHeight: {
|
|
qreal lineHeight;
|
|
if (decl.realValue(&lineHeight, "px")) {
|
|
blockFormat.setLineHeight(lineHeight, QTextBlockFormat::FixedHeight);
|
|
} else {
|
|
bool ok;
|
|
QString value = decl.d->values.first().toString();
|
|
lineHeight = value.toDouble(&ok);
|
|
if (ok)
|
|
blockFormat.setLineHeight(lineHeight, QTextBlockFormat::ProportionalHeight);
|
|
else
|
|
blockFormat.setLineHeight(0, QTextBlockFormat::SingleHeight);
|
|
}
|
|
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;
|
|
case QCss::QtListNumberPrefix:
|
|
textListNumberPrefix = decl.d->values.first().variant.toString();
|
|
break;
|
|
case QCss::QtListNumberSuffix:
|
|
textListNumberSuffix = decl.d->values.first().variant.toString();
|
|
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
|