QTextHtmlParser Class Reference

#include <qtexthtmlparser_p.h>

Inheritance diagram for QTextHtmlParser:

Classes
struct	ExternalStyleSheet

Public Types
enum	Margin { MarginTop, MarginRight, MarginBottom, MarginLeft }

Public Functions
const QTextHtmlParserNode &	at (int i) const
int	bottomMargin (int i) const
int	bottomPadding (int i) const
int	count () const
int	depth (int i) const
void	dumpHtml ()
int	last () const
int	leftMargin (int i) const
int	leftPadding (int i) const
QTextHtmlParserNode &	operator[] (int i)
void	parse (const QString &text, const QTextDocument *resourceProvider)
int	rightMargin (int i) const
int	rightPadding (int i) const
int	topMargin (int i) const
int	topPadding (int i) const

Static Public Functions
static int	lookupElement (const QString &element)

Protected Functions
void	applyAttributes (const QStringList &attributes)
QVector< QCss::Declaration >	declarationsForNode (int node) const
void	eatSpace ()
bool	hasPrefix (QChar c, int lookahead=0) const
void	importStyleSheet (const QString &href)
int	margin (int i, int mar) const
QTextHtmlParserNode *	newNode (int parent)
bool	nodeIsChildOf (int i, QTextHTMLElements id) const
void	parse ()
QStringList	parseAttributes ()
void	parseCloseTag ()
QString	parseEntity ()
void	parseExclamationTag ()
void	parseTag ()
QString	parseWord ()
void	resolveNode ()
QTextHtmlParserNode *	resolveParent ()
void	resolveStyleSheetImports (const QCss::StyleSheet &sheet)

Protected Variables
QVector< ExternalStyleSheet >	externalStyleSheets
QVector< QCss::StyleSheet >	inlineStyleSheets
int	len
QVector< QTextHtmlParserNode >	nodes
int	pos
const QTextDocument *	resourceProvider
bool	textEditMode
QString	txt

Detailed Description

Definition at line 264 of file qtexthtmlparser_p.h.

Enumerations

Margin

enum QTextHtmlParser::Margin

Enumerator
MarginTop
MarginRight
MarginBottom
MarginLeft

Definition at line 267 of file qtexthtmlparser_p.h.

                {
        MarginTop,
        MarginRight,
        MarginBottom,
        MarginLeft
    };

Functions

applyAttributes()

void QTextHtmlParser::applyAttributes ( const QStringList &  attributes )

protected

Definition at line 1516 of file qtexthtmlparser.cpp.

{
    // 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
}

at()

const QTextHtmlParserNode& QTextHtmlParser::at ( int  i ) const

inline

Definition at line 274 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::closeTag(), QTextHtmlImporter::import(), QTextHtmlParserNode::isNestedList(), QTextHtmlImporter::processBlockNode(), QTextHtmlImporter::processSpecialNodes(), and QTextHtmlImporter::scanTable().

{ return nodes.at(i); }

bottomMargin()

int QTextHtmlParser::bottomMargin

(

int

i

)

const

Definition at line 610 of file qtexthtmlparser.cpp.

Referenced by QTextHtmlImporter::processBlockNode(), QTextHtmlImporter::processSpecialNodes(), and QTextHtmlImporter::scanTable().

{
    if (!i)
        return 0;
    return at(i).margin[MarginBottom];
}

bottomPadding()

int QTextHtmlParser::bottomPadding ( int  i ) const

inline

Definition at line 285 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::processBlockNode().

{ return at(i).padding[MarginBottom]; }

count()

int QTextHtmlParser::count ( ) const

inline

Definition at line 276 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::import().

{ return nodes.count(); }

declarationsForNode()

QVector< QCss::Declaration > QTextHtmlParser::declarationsForNode ( int  node ) const

protected

Definition at line 1856 of file qtexthtmlparser.cpp.

{
    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;
}

depth()

int QTextHtmlParser::depth

(

int

i

)

const

Definition at line 575 of file qtexthtmlparser.cpp.

Referenced by QTextHtmlImporter::closeTag().

{
    int depth = 0;
    while (i) {
        i = at(i).parent;
        ++depth;
    }
    return depth;
}

dumpHtml()

void QTextHtmlParser::dumpHtml

(

)

Definition at line 497 of file qtexthtmlparser.cpp.

{
    for (int i = 0; i < count(); ++i) {
        qDebug().nospace() << qPrintable(QString(depth(i)*4, QLatin1Char(' ')))
                           << qPrintable(at(i).tag) << ':'
                           << quoteNewline(at(i).text);
            ;
    }
}

eatSpace()

void QTextHtmlParser::eatSpace ( )

protected

Definition at line 617 of file qtexthtmlparser.cpp.

{
    while (pos < len && txt.at(pos).isSpace() && txt.at(pos) != QChar::ParagraphSeparator)
        pos++;
}

hasPrefix()

bool QTextHtmlParser::hasPrefix ( QChar  c, int  lookahead = 0  ) const

inlineprotected

Definition at line 313 of file qtexthtmlparser_p.h.

        {return pos + lookahead < len && txt.at(pos) == c; }

importStyleSheet()

void QTextHtmlParser::importStyleSheet ( const QString &  href )

protected

Definition at line 1831 of file qtexthtmlparser.cpp.

{
    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);
    }
}

last()

int QTextHtmlParser::last ( ) const

inline

Definition at line 277 of file qtexthtmlparser_p.h.

{ return nodes.count()-1; }

leftMargin()

int QTextHtmlParser::leftMargin ( int  i ) const

inline

Definition at line 281 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::processBlockNode(), and QTextHtmlImporter::scanTable().

{ return margin(i, MarginLeft); }

leftPadding()

int QTextHtmlParser::leftPadding ( int  i ) const

inline

Definition at line 286 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::processBlockNode().

{ return at(i).padding[MarginLeft]; }

lookupElement()

int QTextHtmlParser::lookupElement ( const QString &  element )

static

Definition at line 465 of file qtexthtmlparser.cpp.

Referenced by Qt::mightBeRichText().

{
    const QTextHtmlElement *e = lookupElementHelper(element);
    if (!e)
        return -1;
    return e->id;
}

margin()

int QTextHtmlParser::margin ( int  i, int  mar  ) const

protected

Definition at line 585 of file qtexthtmlparser.cpp.

                                                {
    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;
}

newNode()

QTextHtmlParserNode * QTextHtmlParser::newNode ( int  parent )

protected

Definition at line 507 of file qtexthtmlparser.cpp.

{
    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;
}

nodeIsChildOf()

bool QTextHtmlParser::nodeIsChildOf ( int  i, QTextHTMLElements  id  ) const

protected

Definition at line 1888 of file qtexthtmlparser.cpp.

{
    while (i) {
        if (at(i).id == id)
            return true;
        i = at(i).parent;
    }
    return false;
}

operator[]()

QTextHtmlParserNode& QTextHtmlParser::operator[] ( int  i )

inline

Definition at line 275 of file qtexthtmlparser_p.h.

{ return nodes[i]; }

parse() [1/2]

void QTextHtmlParser::parse	(	const QString &	text,
		const QTextDocument *	resourceProvider
	)

Definition at line 562 of file qtexthtmlparser.cpp.

{
    nodes.clear();
    nodes.resize(1);
    txt = text;
    pos = 0;
    len = txt.length();
    textEditMode = false;
    resourceProvider = _resourceProvider;
    parse();
    //dumpHtml();
}

parse() [2/2]

void QTextHtmlParser::parse ( )

protected

Definition at line 623 of file qtexthtmlparser.cpp.

Referenced by QTextHtmlImporter::QTextHtmlImporter().

{
    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;
        }
    }
}

parseAttributes()

QStringList QTextHtmlParser::parseAttributes ( )

protected

Definition at line 1490 of file qtexthtmlparser.cpp.

{
    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;
}

parseCloseTag()

void QTextHtmlParser::parseCloseTag ( )

protected

Definition at line 728 of file qtexthtmlparser.cpp.

{
    ++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();
}

parseEntity()

QString QTextHtmlParser::parseEntity ( )

protected

Definition at line 789 of file qtexthtmlparser.cpp.

{
    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 (QChar::requiresSurrogates(uc)) {
                str += QChar(QChar::highSurrogate(uc));
                str += QChar(QChar::lowSurrogate(uc));
            } else {
                str = QChar(uc);
            }
            return str;
        }
    }
error:
    pos = recover;
    return QLatin1String("&");
}

parseExclamationTag()

void QTextHtmlParser::parseExclamationTag ( )

protected

Definition at line 770 of file qtexthtmlparser.cpp.

{
    ++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;
        }
    }
}

parseTag()

void QTextHtmlParser::parseTag ( )

protected

Definition at line 638 of file qtexthtmlparser.cpp.

{
    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();
    }
}

parseWord()

QString QTextHtmlParser::parseWord ( )

protected

Definition at line 838 of file qtexthtmlparser.cpp.

{
    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;
}

resolveNode()

void QTextHtmlParser::resolveNode ( )

protected

Definition at line 980 of file qtexthtmlparser.cpp.

{
    QTextHtmlParserNode *node = &nodes.last();
    const QTextHtmlParserNode *parent = &nodes.at(node->parent);
    node->initializeProperties(parent, this);
}

resolveParent()

QTextHtmlParserNode * QTextHtmlParser::resolveParent ( )

protected

Definition at line 882 of file qtexthtmlparser.cpp.

{
    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;
}

resolveStyleSheetImports()

void QTextHtmlParser::resolveStyleSheetImports ( const QCss::StyleSheet &  sheet )

protected

Definition at line 1821 of file qtexthtmlparser.cpp.

{
    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);
    }
}

rightMargin()

int QTextHtmlParser::rightMargin ( int  i ) const

inline

Definition at line 282 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::processBlockNode(), and QTextHtmlImporter::scanTable().

{ return margin(i, MarginRight); }

rightPadding()

int QTextHtmlParser::rightPadding ( int  i ) const

inline

Definition at line 287 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::processBlockNode().

{ return at(i).padding[MarginRight]; }

topMargin()

int QTextHtmlParser::topMargin

(

int

i

)

const

Definition at line 603 of file qtexthtmlparser.cpp.

Referenced by QTextHtmlImporter::processBlockNode(), QTextHtmlImporter::processSpecialNodes(), and QTextHtmlImporter::scanTable().

{
    if (!i)
        return 0;
    return at(i).margin[MarginTop];
}

topPadding()

int QTextHtmlParser::topPadding ( int  i ) const

inline

Definition at line 284 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::processBlockNode().

{ return at(i).padding[MarginTop]; }

Properties

externalStyleSheets

QVector<ExternalStyleSheet> QTextHtmlParser::externalStyleSheets

protected

Definition at line 333 of file qtexthtmlparser_p.h.

inlineStyleSheets

QVector<QCss::StyleSheet> QTextHtmlParser::inlineStyleSheets

protected

Definition at line 334 of file qtexthtmlparser_p.h.

len

int QTextHtmlParser::len

protected

Definition at line 298 of file qtexthtmlparser_p.h.

nodes

QVector<QTextHtmlParserNode> QTextHtmlParser::nodes

protected

Definition at line 296 of file qtexthtmlparser_p.h.

pos

int QTextHtmlParser::pos

protected

Definition at line 298 of file qtexthtmlparser_p.h.

resourceProvider

const QTextDocument* QTextHtmlParser::resourceProvider

protected

Definition at line 337 of file qtexthtmlparser_p.h.

textEditMode

bool QTextHtmlParser::textEditMode

protected

Definition at line 300 of file qtexthtmlparser_p.h.

Referenced by QTextHtmlImporter::appendNodeText(), and QTextHtmlImporter::import().

txt

QString QTextHtmlParser::txt

protected

Definition at line 297 of file qtexthtmlparser_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/text/qtexthtmlparser_p.h
• /src/gui/text/qtexthtmlparser.cpp