/****************************************************************************+ −
**+ −
** Copyright (C) 2009 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$+ −
** No Commercial Usage+ −
** This file contains pre-release code and may not be distributed.+ −
** You may use this file in accordance with the terms and conditions+ −
** contained in the Technology Preview License Agreement accompanying+ −
** this package.+ −
**+ −
** GNU Lesser General Public License Usage+ −
** Alternatively, this file may be used under the terms of the GNU Lesser+ −
** General Public License version 2.1 as published by the Free Software+ −
** Foundation and appearing in the file LICENSE.LGPL included in the+ −
** packaging of this file. Please review the following information to+ −
** ensure the GNU Lesser General Public License version 2.1 requirements+ −
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+ −
**+ −
** In addition, as a special exception, Nokia gives you certain additional+ −
** rights. These rights are described in the Nokia Qt LGPL Exception+ −
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+ −
**+ −
** If you have questions regarding the use of this file, please contact+ −
** Nokia at qt-info@nokia.com.+ −
**+ −
**+ −
**+ −
**+ −
**+ −
**+ −
**+ −
**+ −
** $QT_END_LICENSE$+ −
**+ −
****************************************************************************/+ −
+ −
#include "qtextdocumentfragment.h"+ −
#include "qtextdocumentfragment_p.h"+ −
#include "qtextcursor_p.h"+ −
#include "qtextlist.h"+ −
#include "private/qunicodetables_p.h"+ −
+ −
#include <qdebug.h>+ −
#include <qtextcodec.h>+ −
#include <qbytearray.h>+ −
#include <qdatastream.h>+ −
#include <qdatetime.h>+ −
+ −
QT_BEGIN_NAMESPACE+ −
+ −
QTextCopyHelper::QTextCopyHelper(const QTextCursor &_source, const QTextCursor &_destination, bool forceCharFormat, const QTextCharFormat &fmt)+ −
#if defined(Q_CC_DIAB) // compiler bug+ −
: formatCollection(*_destination.d->priv->formatCollection()), originalText((const QString)_source.d->priv->buffer())+ −
#else+ −
: formatCollection(*_destination.d->priv->formatCollection()), originalText(_source.d->priv->buffer())+ −
#endif+ −
{+ −
src = _source.d->priv;+ −
dst = _destination.d->priv;+ −
insertPos = _destination.position();+ −
this->forceCharFormat = forceCharFormat;+ −
primaryCharFormatIndex = convertFormatIndex(fmt);+ −
cursor = _source;+ −
}+ −
+ −
int QTextCopyHelper::convertFormatIndex(const QTextFormat &oldFormat, int objectIndexToSet)+ −
{+ −
QTextFormat fmt = oldFormat;+ −
if (objectIndexToSet != -1) {+ −
fmt.setObjectIndex(objectIndexToSet);+ −
} else if (fmt.objectIndex() != -1) {+ −
int newObjectIndex = objectIndexMap.value(fmt.objectIndex(), -1);+ −
if (newObjectIndex == -1) {+ −
QTextFormat objFormat = src->formatCollection()->objectFormat(fmt.objectIndex());+ −
Q_ASSERT(objFormat.objectIndex() == -1);+ −
newObjectIndex = formatCollection.createObjectIndex(objFormat);+ −
objectIndexMap.insert(fmt.objectIndex(), newObjectIndex);+ −
}+ −
fmt.setObjectIndex(newObjectIndex);+ −
}+ −
int idx = formatCollection.indexForFormat(fmt);+ −
Q_ASSERT(formatCollection.format(idx).type() == oldFormat.type());+ −
return idx;+ −
}+ −
+ −
int QTextCopyHelper::appendFragment(int pos, int endPos, int objectIndex)+ −
{+ −
QTextDocumentPrivate::FragmentIterator fragIt = src->find(pos);+ −
const QTextFragmentData * const frag = fragIt.value();+ −
+ −
Q_ASSERT(objectIndex == -1+ −
|| (frag->size_array[0] == 1 && src->formatCollection()->format(frag->format).objectIndex() != -1));+ −
+ −
int charFormatIndex;+ −
if (forceCharFormat)+ −
charFormatIndex = primaryCharFormatIndex;+ −
else+ −
charFormatIndex = convertFormatIndex(frag->format, objectIndex);+ −
+ −
const int inFragmentOffset = qMax(0, pos - fragIt.position());+ −
int charsToCopy = qMin(int(frag->size_array[0] - inFragmentOffset), endPos - pos);+ −
+ −
QTextBlock nextBlock = src->blocksFind(pos + 1);+ −
+ −
int blockIdx = -2;+ −
if (nextBlock.position() == pos + 1) {+ −
blockIdx = convertFormatIndex(nextBlock.blockFormat());+ −
} else if (pos == 0 && insertPos == 0) {+ −
dst->setBlockFormat(dst->blocksBegin(), dst->blocksBegin(), convertFormat(src->blocksBegin().blockFormat()).toBlockFormat());+ −
dst->setCharFormat(-1, 1, convertFormat(src->blocksBegin().charFormat()).toCharFormat());+ −
}+ −
+ −
QString txtToInsert(originalText.constData() + frag->stringPosition + inFragmentOffset, charsToCopy);+ −
if (txtToInsert.length() == 1+ −
&& (txtToInsert.at(0) == QChar::ParagraphSeparator+ −
|| txtToInsert.at(0) == QTextBeginningOfFrame+ −
|| txtToInsert.at(0) == QTextEndOfFrame+ −
)+ −
) {+ −
dst->insertBlock(txtToInsert.at(0), insertPos, blockIdx, charFormatIndex);+ −
++insertPos;+ −
} else {+ −
if (nextBlock.textList()) {+ −
QTextBlock dstBlock = dst->blocksFind(insertPos);+ −
if (!dstBlock.textList()) {+ −
// insert a new text block with the block and char format from the+ −
// source block to make sure that the following text fragments+ −
// end up in a list as they should+ −
int listBlockFormatIndex = convertFormatIndex(nextBlock.blockFormat());+ −
int listCharFormatIndex = convertFormatIndex(nextBlock.charFormat());+ −
dst->insertBlock(insertPos, listBlockFormatIndex, listCharFormatIndex);+ −
++insertPos;+ −
}+ −
}+ −
dst->insert(insertPos, txtToInsert, charFormatIndex);+ −
const int userState = nextBlock.userState();+ −
if (userState != -1)+ −
dst->blocksFind(insertPos).setUserState(userState);+ −
insertPos += txtToInsert.length();+ −
}+ −
+ −
return charsToCopy;+ −
}+ −
+ −
void QTextCopyHelper::appendFragments(int pos, int endPos)+ −
{+ −
Q_ASSERT(pos < endPos);+ −
+ −
while (pos < endPos)+ −
pos += appendFragment(pos, endPos);+ −
}+ −
+ −
void QTextCopyHelper::copy()+ −
{+ −
if (cursor.hasComplexSelection()) {+ −
QTextTable *table = cursor.currentTable();+ −
int row_start, col_start, num_rows, num_cols;+ −
cursor.selectedTableCells(&row_start, &num_rows, &col_start, &num_cols);+ −
+ −
QTextTableFormat tableFormat = table->format();+ −
tableFormat.setColumns(num_cols);+ −
tableFormat.clearColumnWidthConstraints();+ −
const int objectIndex = dst->formatCollection()->createObjectIndex(tableFormat);+ −
+ −
Q_ASSERT(row_start != -1);+ −
for (int r = row_start; r < row_start + num_rows; ++r) {+ −
for (int c = col_start; c < col_start + num_cols; ++c) {+ −
QTextTableCell cell = table->cellAt(r, c);+ −
const int rspan = cell.rowSpan();+ −
const int cspan = cell.columnSpan();+ −
if (rspan != 1) {+ −
int cr = cell.row();+ −
if (cr != r)+ −
continue;+ −
}+ −
if (cspan != 1) {+ −
int cc = cell.column();+ −
if (cc != c)+ −
continue;+ −
}+ −
+ −
// add the QTextBeginningOfFrame+ −
QTextCharFormat cellFormat = cell.format();+ −
if (r + rspan >= row_start + num_rows) {+ −
cellFormat.setTableCellRowSpan(row_start + num_rows - r);+ −
}+ −
if (c + cspan >= col_start + num_cols) {+ −
cellFormat.setTableCellColumnSpan(col_start + num_cols - c);+ −
}+ −
const int charFormatIndex = convertFormatIndex(cellFormat, objectIndex);+ −
+ −
int blockIdx = -2;+ −
const int cellPos = cell.firstPosition();+ −
QTextBlock block = src->blocksFind(cellPos);+ −
if (block.position() == cellPos) {+ −
blockIdx = convertFormatIndex(block.blockFormat());+ −
}+ −
+ −
dst->insertBlock(QTextBeginningOfFrame, insertPos, blockIdx, charFormatIndex);+ −
++insertPos;+ −
+ −
// nothing to add for empty cells+ −
if (cell.lastPosition() > cellPos) {+ −
// add the contents+ −
appendFragments(cellPos, cell.lastPosition());+ −
}+ −
}+ −
}+ −
+ −
// add end of table+ −
int end = table->lastPosition();+ −
appendFragment(end, end+1, objectIndex);+ −
} else {+ −
appendFragments(cursor.selectionStart(), cursor.selectionEnd());+ −
}+ −
}+ −
+ −
QTextDocumentFragmentPrivate::QTextDocumentFragmentPrivate(const QTextCursor &_cursor)+ −
: ref(1), doc(new QTextDocument), importedFromPlainText(false)+ −
{+ −
doc->setUndoRedoEnabled(false);+ −
+ −
if (!_cursor.hasSelection())+ −
return;+ −
+ −
doc->docHandle()->beginEditBlock();+ −
QTextCursor destCursor(doc);+ −
QTextCopyHelper(_cursor, destCursor).copy();+ −
doc->docHandle()->endEditBlock();+ −
+ −
if (_cursor.d)+ −
doc->docHandle()->mergeCachedResources(_cursor.d->priv);+ −
}+ −
+ −
void QTextDocumentFragmentPrivate::insert(QTextCursor &_cursor) const+ −
{+ −
if (_cursor.isNull())+ −
return;+ −
+ −
QTextDocumentPrivate *destPieceTable = _cursor.d->priv;+ −
destPieceTable->beginEditBlock();+ −
+ −
QTextCursor sourceCursor(doc);+ −
sourceCursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);+ −
QTextCopyHelper(sourceCursor, _cursor, importedFromPlainText, _cursor.charFormat()).copy();+ −
+ −
destPieceTable->endEditBlock();+ −
}+ −
+ −
/*!+ −
\class QTextDocumentFragment+ −
\reentrant+ −
+ −
\brief The QTextDocumentFragment class represents a piece of formatted text+ −
from a QTextDocument.+ −
+ −
\ingroup richtext-processing+ −
\ingroup shared+ −
+ −
A QTextDocumentFragment is a fragment of rich text, that can be inserted into+ −
a QTextDocument. A document fragment can be created from a+ −
QTextDocument, from a QTextCursor's selection, or from another+ −
document fragment. Document fragments can also be created by the+ −
static functions, fromPlainText() and fromHtml().+ −
+ −
The contents of a document fragment can be obtained as plain text+ −
by using the toPlainText() function, or it can be obtained as HTML+ −
with toHtml().+ −
*/+ −
+ −
+ −
/*!+ −
Constructs an empty QTextDocumentFragment.+ −
+ −
\sa isEmpty()+ −
*/+ −
QTextDocumentFragment::QTextDocumentFragment()+ −
: d(0)+ −
{+ −
}+ −
+ −
/*!+ −
Converts the given \a document into a QTextDocumentFragment.+ −
Note that the QTextDocumentFragment only stores the document contents, not meta information+ −
like the document's title.+ −
*/+ −
QTextDocumentFragment::QTextDocumentFragment(const QTextDocument *document)+ −
: d(0)+ −
{+ −
if (!document)+ −
return;+ −
+ −
QTextCursor cursor(const_cast<QTextDocument *>(document));+ −
cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);+ −
d = new QTextDocumentFragmentPrivate(cursor);+ −
}+ −
+ −
/*!+ −
Creates a QTextDocumentFragment from the \a{cursor}'s selection.+ −
If the cursor doesn't have a selection, the created fragment is empty.+ −
+ −
\sa isEmpty() QTextCursor::selection()+ −
*/+ −
QTextDocumentFragment::QTextDocumentFragment(const QTextCursor &cursor)+ −
: d(0)+ −
{+ −
if (!cursor.hasSelection())+ −
return;+ −
+ −
d = new QTextDocumentFragmentPrivate(cursor);+ −
}+ −
+ −
/*!+ −
\fn QTextDocumentFragment::QTextDocumentFragment(const QTextDocumentFragment &other)+ −
+ −
Copy constructor. Creates a copy of the \a other fragment.+ −
*/+ −
QTextDocumentFragment::QTextDocumentFragment(const QTextDocumentFragment &rhs)+ −
: d(rhs.d)+ −
{+ −
if (d)+ −
d->ref.ref();+ −
}+ −
+ −
/*!+ −
\fn QTextDocumentFragment &QTextDocumentFragment::operator=(const QTextDocumentFragment &other)+ −
+ −
Assigns the \a other fragment to this fragment.+ −
*/+ −
QTextDocumentFragment &QTextDocumentFragment::operator=(const QTextDocumentFragment &rhs)+ −
{+ −
if (rhs.d)+ −
rhs.d->ref.ref();+ −
if (d && !d->ref.deref())+ −
delete d;+ −
d = rhs.d;+ −
return *this;+ −
}+ −
+ −
/*!+ −
Destroys the document fragment.+ −
*/+ −
QTextDocumentFragment::~QTextDocumentFragment()+ −
{+ −
if (d && !d->ref.deref())+ −
delete d;+ −
}+ −
+ −
/*!+ −
Returns true if the fragment is empty; otherwise returns false.+ −
*/+ −
bool QTextDocumentFragment::isEmpty() const+ −
{+ −
return !d || !d->doc || d->doc->docHandle()->length() <= 1;+ −
}+ −
+ −
/*!+ −
Returns the document fragment's text as plain text (i.e. with no+ −
formatting information).+ −
+ −
\sa toHtml()+ −
*/+ −
QString QTextDocumentFragment::toPlainText() const+ −
{+ −
if (!d)+ −
return QString();+ −
+ −
return d->doc->toPlainText();+ −
}+ −
+ −
// #### Qt 5: merge with other overload+ −
/*!+ −
\overload+ −
*/+ −
+ −
#ifndef QT_NO_TEXTHTMLPARSER+ −
+ −
QString QTextDocumentFragment::toHtml() const+ −
{+ −
return toHtml(QByteArray());+ −
}+ −
+ −
/*!+ −
\since 4.2+ −
+ −
Returns the contents of the document fragment as HTML,+ −
using the specified \a encoding (e.g., "UTF-8", "ISO 8859-1").+ −
+ −
\sa toPlainText(), QTextDocument::toHtml(), QTextCodec+ −
*/+ −
QString QTextDocumentFragment::toHtml(const QByteArray &encoding) const+ −
{+ −
if (!d)+ −
return QString();+ −
+ −
return QTextHtmlExporter(d->doc).toHtml(encoding, QTextHtmlExporter::ExportFragment);+ −
}+ −
+ −
#endif // QT_NO_TEXTHTMLPARSER+ −
+ −
/*!+ −
Returns a document fragment that contains the given \a plainText.+ −
+ −
When inserting such a fragment into a QTextDocument the current char format of+ −
the QTextCursor used for insertion is used as format for the text.+ −
*/+ −
QTextDocumentFragment QTextDocumentFragment::fromPlainText(const QString &plainText)+ −
{+ −
QTextDocumentFragment res;+ −
+ −
res.d = new QTextDocumentFragmentPrivate;+ −
res.d->importedFromPlainText = true;+ −
QTextCursor cursor(res.d->doc);+ −
cursor.insertText(plainText);+ −
return res;+ −
}+ −
+ −
static QTextListFormat::Style nextListStyle(QTextListFormat::Style style)+ −
{+ −
if (style == QTextListFormat::ListDisc)+ −
return QTextListFormat::ListCircle;+ −
else if (style == QTextListFormat::ListCircle)+ −
return QTextListFormat::ListSquare;+ −
return style;+ −
}+ −
+ −
#ifndef QT_NO_TEXTHTMLPARSER+ −
+ −
QTextHtmlImporter::QTextHtmlImporter(QTextDocument *_doc, const QString &_html, ImportMode mode, const QTextDocument *resourceProvider)+ −
: indent(0), compressNextWhitespace(PreserveWhiteSpace), doc(_doc), importMode(mode)+ −
{+ −
cursor = QTextCursor(doc);+ −
wsm = QTextHtmlParserNode::WhiteSpaceNormal;+ −
+ −
QString html = _html;+ −
const int startFragmentPos = html.indexOf(QLatin1String("<!--StartFragment-->"));+ −
if (startFragmentPos != -1) {+ −
QString qt3RichTextHeader(QLatin1String("<meta name=\"qrichtext\" content=\"1\" />"));+ −
+ −
// Hack for Qt3+ −
const bool hasQtRichtextMetaTag = html.contains(qt3RichTextHeader);+ −
+ −
const int endFragmentPos = html.indexOf(QLatin1String("<!--EndFragment-->"));+ −
if (startFragmentPos < endFragmentPos)+ −
html = html.mid(startFragmentPos, endFragmentPos - startFragmentPos);+ −
else+ −
html = html.mid(startFragmentPos);+ −
+ −
if (hasQtRichtextMetaTag)+ −
html.prepend(qt3RichTextHeader);+ −
}+ −
+ −
parse(html, resourceProvider ? resourceProvider : doc);+ −
// dumpHtml();+ −
}+ −
+ −
void QTextHtmlImporter::import()+ −
{+ −
cursor.beginEditBlock();+ −
hasBlock = true;+ −
forceBlockMerging = false;+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
blockTagClosed = false;+ −
for (currentNodeIdx = 0; currentNodeIdx < count(); ++currentNodeIdx) {+ −
currentNode = &at(currentNodeIdx);+ −
wsm = textEditMode ? QTextHtmlParserNode::WhiteSpacePreWrap : currentNode->wsm;+ −
+ −
/*+ −
* process each node in three stages:+ −
* 1) check if the hierarchy changed and we therefore passed the+ −
* equivalent of a closing tag -> we may need to finish off+ −
* some structures like tables+ −
*+ −
* 2) check if the current node is a special node like a+ −
* <table>, <ul> or <img> tag that requires special processing+ −
*+ −
* 3) if the node should result in a QTextBlock create one and+ −
* finally insert text that may be attached to the node+ −
*/+ −
+ −
/* emit 'closing' table blocks or adjust current indent level+ −
* if we+ −
* 1) are beyond the first node+ −
* 2) the current node not being a child of the previous node+ −
* means there was a tag closing in the input html+ −
*/+ −
if (currentNodeIdx > 0 && (currentNode->parent != currentNodeIdx - 1)) {+ −
blockTagClosed = closeTag();+ −
// visually collapse subsequent block tags, but if the element after the closed block tag+ −
// is for example an inline element (!isBlock) we have to make sure we start a new paragraph by setting+ −
// hasBlock to false.+ −
if (blockTagClosed+ −
&& !currentNode->isBlock()+ −
&& currentNode->id != Html_unknown)+ −
{+ −
hasBlock = false;+ −
} else if (hasBlock) {+ −
// when collapsing subsequent block tags we need to clear the block format+ −
QTextBlockFormat blockFormat = currentNode->blockFormat;+ −
blockFormat.setIndent(indent);+ −
+ −
QTextBlockFormat oldFormat = cursor.blockFormat();+ −
if (oldFormat.hasProperty(QTextFormat::PageBreakPolicy)) {+ −
QTextFormat::PageBreakFlags pageBreak = oldFormat.pageBreakPolicy();+ −
if (pageBreak == QTextFormat::PageBreak_AlwaysAfter)+ −
/* We remove an empty paragrah that requested a page break after.+ −
moving that request to the next paragraph means we also need to make+ −
that a pagebreak before to keep the same visual appearance.+ −
*/+ −
pageBreak = QTextFormat::PageBreak_AlwaysBefore;+ −
blockFormat.setPageBreakPolicy(pageBreak);+ −
}+ −
+ −
cursor.setBlockFormat(blockFormat);+ −
}+ −
}+ −
+ −
if (currentNode->displayMode == QTextHtmlElement::DisplayNone) {+ −
if (currentNode->id == Html_title)+ −
doc->setMetaInformation(QTextDocument::DocumentTitle, currentNode->text);+ −
// ignore explicitly 'invisible' elements+ −
continue;+ −
}+ −
+ −
if (processSpecialNodes() == ContinueWithNextNode)+ −
continue;+ −
+ −
// make sure there's a block for 'Blah' after <ul><li>foo</ul>Blah+ −
if (blockTagClosed+ −
&& !hasBlock+ −
&& !currentNode->isBlock()+ −
&& !currentNode->text.isEmpty() && !currentNode->hasOnlyWhitespace()+ −
&& currentNode->displayMode == QTextHtmlElement::DisplayInline) {+ −
+ −
QTextBlockFormat block = currentNode->blockFormat;+ −
block.setIndent(indent);+ −
+ −
appendBlock(block, currentNode->charFormat);+ −
+ −
hasBlock = true;+ −
}+ −
+ −
if (currentNode->isBlock()) {+ −
if (processBlockNode() == ContinueWithNextNode)+ −
continue;+ −
}+ −
+ −
if (currentNode->charFormat.isAnchor() && !currentNode->charFormat.anchorName().isEmpty()) {+ −
namedAnchors.append(currentNode->charFormat.anchorName());+ −
}+ −
+ −
if (appendNodeText())+ −
hasBlock = false; // if we actually appended text then we don't+ −
// have an empty block anymore+ −
}+ −
+ −
cursor.endEditBlock();+ −
}+ −
+ −
bool QTextHtmlImporter::appendNodeText()+ −
{+ −
const int initialCursorPosition = cursor.position();+ −
QTextCharFormat format = currentNode->charFormat;+ −
+ −
if(wsm == QTextHtmlParserNode::WhiteSpacePre || wsm == QTextHtmlParserNode::WhiteSpacePreWrap)+ −
compressNextWhitespace = PreserveWhiteSpace;+ −
+ −
QString text = currentNode->text;+ −
+ −
QString textToInsert;+ −
textToInsert.reserve(text.size());+ −
+ −
for (int i = 0; i < text.length(); ++i) {+ −
QChar ch = text.at(i);+ −
+ −
if (ch.isSpace()+ −
&& ch != QChar::Nbsp+ −
&& ch != QChar::ParagraphSeparator) {+ −
+ −
if (compressNextWhitespace == CollapseWhiteSpace)+ −
compressNextWhitespace = RemoveWhiteSpace; // allow this one, and remove the ones coming next.+ −
else if(compressNextWhitespace == RemoveWhiteSpace)+ −
continue;+ −
+ −
if (wsm == QTextHtmlParserNode::WhiteSpacePre+ −
|| textEditMode+ −
) {+ −
if (ch == QLatin1Char('\n')) {+ −
if (textEditMode)+ −
continue;+ −
} else if (ch == QLatin1Char('\r')) {+ −
continue;+ −
}+ −
} else if (wsm != QTextHtmlParserNode::WhiteSpacePreWrap) {+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
if (wsm == QTextHtmlParserNode::WhiteSpaceNoWrap)+ −
ch = QChar::Nbsp;+ −
else+ −
ch = QLatin1Char(' ');+ −
}+ −
} else {+ −
compressNextWhitespace = PreserveWhiteSpace;+ −
}+ −
+ −
if (ch == QLatin1Char('\n')+ −
|| ch == QChar::ParagraphSeparator) {+ −
+ −
if (!textToInsert.isEmpty()) {+ −
cursor.insertText(textToInsert, format);+ −
textToInsert.clear();+ −
}+ −
+ −
QTextBlockFormat fmt = cursor.blockFormat();+ −
+ −
if (fmt.hasProperty(QTextFormat::BlockBottomMargin)) {+ −
QTextBlockFormat tmp = fmt;+ −
tmp.clearProperty(QTextFormat::BlockBottomMargin);+ −
cursor.setBlockFormat(tmp);+ −
}+ −
+ −
fmt.clearProperty(QTextFormat::BlockTopMargin);+ −
appendBlock(fmt, cursor.charFormat());+ −
} else {+ −
if (!namedAnchors.isEmpty()) {+ −
if (!textToInsert.isEmpty()) {+ −
cursor.insertText(textToInsert, format);+ −
textToInsert.clear();+ −
}+ −
+ −
format.setAnchor(true);+ −
format.setAnchorNames(namedAnchors);+ −
cursor.insertText(ch, format);+ −
namedAnchors.clear();+ −
format.clearProperty(QTextFormat::IsAnchor);+ −
format.clearProperty(QTextFormat::AnchorName);+ −
} else {+ −
textToInsert += ch;+ −
}+ −
}+ −
}+ −
+ −
if (!textToInsert.isEmpty()) {+ −
cursor.insertText(textToInsert, format);+ −
}+ −
+ −
return cursor.position() != initialCursorPosition;+ −
}+ −
+ −
QTextHtmlImporter::ProcessNodeResult QTextHtmlImporter::processSpecialNodes()+ −
{+ −
switch (currentNode->id) {+ −
case Html_body:+ −
if (currentNode->charFormat.background().style() != Qt::NoBrush) {+ −
QTextFrameFormat fmt = doc->rootFrame()->frameFormat();+ −
fmt.setBackground(currentNode->charFormat.background());+ −
doc->rootFrame()->setFrameFormat(fmt);+ −
const_cast<QTextHtmlParserNode *>(currentNode)->charFormat.clearProperty(QTextFormat::BackgroundBrush);+ −
}+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
break;+ −
+ −
case Html_ol:+ −
case Html_ul: {+ −
QTextListFormat::Style style = currentNode->listStyle;+ −
+ −
if (currentNode->id == Html_ul && !currentNode->hasOwnListStyle && currentNode->parent) {+ −
const QTextHtmlParserNode *n = &at(currentNode->parent);+ −
while (n) {+ −
if (n->id == Html_ul) {+ −
style = nextListStyle(currentNode->listStyle);+ −
}+ −
if (n->parent)+ −
n = &at(n->parent);+ −
else+ −
n = 0;+ −
}+ −
}+ −
+ −
QTextListFormat listFmt;+ −
listFmt.setStyle(style);+ −
+ −
++indent;+ −
if (currentNode->hasCssListIndent)+ −
listFmt.setIndent(currentNode->cssListIndent);+ −
else+ −
listFmt.setIndent(indent);+ −
+ −
List l;+ −
l.format = listFmt;+ −
l.listNode = currentNodeIdx;+ −
lists.append(l);+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
+ −
// broken html: <ul>Text here<li>Foo+ −
const QString simpl = currentNode->text.simplified();+ −
if (simpl.isEmpty() || simpl.at(0).isSpace())+ −
return ContinueWithNextNode;+ −
break;+ −
}+ −
+ −
case Html_table: {+ −
Table t = scanTable(currentNodeIdx);+ −
tables.append(t);+ −
hasBlock = false;+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
return ContinueWithNextNode;+ −
}+ −
+ −
case Html_tr:+ −
return ContinueWithNextNode;+ −
+ −
case Html_img: {+ −
QTextImageFormat fmt;+ −
fmt.setName(currentNode->imageName);+ −
+ −
fmt.merge(currentNode->charFormat);+ −
+ −
if (currentNode->imageWidth != -1)+ −
fmt.setWidth(currentNode->imageWidth);+ −
if (currentNode->imageHeight != -1)+ −
fmt.setHeight(currentNode->imageHeight);+ −
+ −
cursor.insertImage(fmt, QTextFrameFormat::Position(currentNode->cssFloat));+ −
+ −
cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor);+ −
cursor.mergeCharFormat(currentNode->charFormat);+ −
cursor.movePosition(QTextCursor::Right);+ −
compressNextWhitespace = CollapseWhiteSpace;+ −
+ −
hasBlock = false;+ −
return ContinueWithNextNode;+ −
}+ −
+ −
case Html_hr: {+ −
QTextBlockFormat blockFormat = currentNode->blockFormat;+ −
blockFormat.setTopMargin(topMargin(currentNodeIdx));+ −
blockFormat.setBottomMargin(bottomMargin(currentNodeIdx));+ −
blockFormat.setProperty(QTextFormat::BlockTrailingHorizontalRulerWidth, currentNode->width);+ −
if (hasBlock && importMode == ImportToDocument)+ −
cursor.mergeBlockFormat(blockFormat);+ −
else+ −
appendBlock(blockFormat);+ −
hasBlock = false;+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
return ContinueWithNextNode;+ −
}+ −
+ −
default: break;+ −
}+ −
return ContinueWithCurrentNode;+ −
}+ −
+ −
// returns true if a block tag was closed+ −
bool QTextHtmlImporter::closeTag()+ −
{+ −
const QTextHtmlParserNode *closedNode = &at(currentNodeIdx - 1);+ −
const int endDepth = depth(currentNodeIdx) - 1;+ −
int depth = this->depth(currentNodeIdx - 1);+ −
bool blockTagClosed = false;+ −
+ −
while (depth > endDepth) {+ −
Table *t = 0;+ −
if (!tables.isEmpty())+ −
t = &tables.last();+ −
+ −
switch (closedNode->id) {+ −
case Html_tr:+ −
if (t && !t->isTextFrame) {+ −
++t->currentRow;+ −
+ −
// for broken html with rowspans but missing tr tags+ −
while (!t->currentCell.atEnd() && t->currentCell.row < t->currentRow)+ −
++t->currentCell;+ −
}+ −
+ −
blockTagClosed = true;+ −
break;+ −
+ −
case Html_table:+ −
if (!t)+ −
break;+ −
indent = t->lastIndent;+ −
+ −
tables.resize(tables.size() - 1);+ −
t = 0;+ −
+ −
if (tables.isEmpty()) {+ −
cursor = doc->rootFrame()->lastCursorPosition();+ −
} else {+ −
t = &tables.last();+ −
if (t->isTextFrame)+ −
cursor = t->frame->lastCursorPosition();+ −
else if (!t->currentCell.atEnd())+ −
cursor = t->currentCell.cell().lastCursorPosition();+ −
}+ −
+ −
// we don't need an extra block after tables, so we don't+ −
// claim to have closed one for the creation of a new one+ −
// in import()+ −
blockTagClosed = false;+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
break;+ −
+ −
case Html_th:+ −
case Html_td:+ −
if (t && !t->isTextFrame)+ −
++t->currentCell;+ −
blockTagClosed = true;+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
break;+ −
+ −
case Html_ol:+ −
case Html_ul:+ −
if (lists.isEmpty())+ −
break;+ −
lists.resize(lists.size() - 1);+ −
--indent;+ −
blockTagClosed = true;+ −
break;+ −
+ −
case Html_br:+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
break;+ −
+ −
case Html_div:+ −
if (closedNode->children.isEmpty())+ −
break;+ −
// fall through+ −
default:+ −
if (closedNode->isBlock())+ −
blockTagClosed = true;+ −
break;+ −
}+ −
+ −
closedNode = &at(closedNode->parent);+ −
--depth;+ −
}+ −
+ −
return blockTagClosed;+ −
}+ −
+ −
QTextHtmlImporter::Table QTextHtmlImporter::scanTable(int tableNodeIdx)+ −
{+ −
Table table;+ −
table.columns = 0;+ −
+ −
QVector<QTextLength> columnWidths;+ −
+ −
int tableHeaderRowCount = 0;+ −
QVector<int> rowNodes;+ −
rowNodes.reserve(at(tableNodeIdx).children.count());+ −
foreach (int row, at(tableNodeIdx).children)+ −
switch (at(row).id) {+ −
case Html_tr:+ −
rowNodes += row;+ −
break;+ −
case Html_thead:+ −
case Html_tbody:+ −
case Html_tfoot:+ −
foreach (int potentialRow, at(row).children)+ −
if (at(potentialRow).id == Html_tr) {+ −
rowNodes += potentialRow;+ −
if (at(row).id == Html_thead)+ −
++tableHeaderRowCount;+ −
}+ −
break;+ −
default: break;+ −
}+ −
+ −
QVector<RowColSpanInfo> rowColSpans;+ −
QVector<RowColSpanInfo> rowColSpanForColumn;+ −
+ −
int effectiveRow = 0;+ −
foreach (int row, rowNodes) {+ −
int colsInRow = 0;+ −
+ −
foreach (int cell, at(row).children)+ −
if (at(cell).isTableCell()) {+ −
// skip all columns with spans from previous rows+ −
while (colsInRow < rowColSpanForColumn.size()) {+ −
const RowColSpanInfo &spanInfo = rowColSpanForColumn[colsInRow];+ −
+ −
if (spanInfo.row + spanInfo.rowSpan > effectiveRow) {+ −
Q_ASSERT(spanInfo.col == colsInRow);+ −
colsInRow += spanInfo.colSpan;+ −
} else+ −
break;+ −
}+ −
+ −
const QTextHtmlParserNode &c = at(cell);+ −
const int currentColumn = colsInRow;+ −
colsInRow += c.tableCellColSpan;+ −
+ −
RowColSpanInfo spanInfo;+ −
spanInfo.row = effectiveRow;+ −
spanInfo.col = currentColumn;+ −
spanInfo.colSpan = c.tableCellColSpan;+ −
spanInfo.rowSpan = c.tableCellRowSpan;+ −
if (spanInfo.colSpan > 1 || spanInfo.rowSpan > 1)+ −
rowColSpans.append(spanInfo);+ −
+ −
columnWidths.resize(qMax(columnWidths.count(), colsInRow));+ −
rowColSpanForColumn.resize(columnWidths.size());+ −
for (int i = currentColumn; i < currentColumn + c.tableCellColSpan; ++i) {+ −
if (columnWidths.at(i).type() == QTextLength::VariableLength) {+ −
QTextLength w = c.width;+ −
if (c.tableCellColSpan > 1 && w.type() != QTextLength::VariableLength)+ −
w = QTextLength(w.type(), w.value(100.) / c.tableCellColSpan);+ −
columnWidths[i] = w;+ −
}+ −
rowColSpanForColumn[i] = spanInfo;+ −
}+ −
}+ −
+ −
table.columns = qMax(table.columns, colsInRow);+ −
+ −
++effectiveRow;+ −
}+ −
table.rows = effectiveRow;+ −
+ −
table.lastIndent = indent;+ −
indent = 0;+ −
+ −
if (table.rows == 0 || table.columns == 0)+ −
return table;+ −
+ −
QTextFrameFormat fmt;+ −
const QTextHtmlParserNode &node = at(tableNodeIdx);+ −
+ −
if (!node.isTextFrame) {+ −
QTextTableFormat tableFmt;+ −
tableFmt.setCellSpacing(node.tableCellSpacing);+ −
tableFmt.setCellPadding(node.tableCellPadding);+ −
if (node.blockFormat.hasProperty(QTextFormat::BlockAlignment))+ −
tableFmt.setAlignment(node.blockFormat.alignment());+ −
tableFmt.setColumns(table.columns);+ −
tableFmt.setColumnWidthConstraints(columnWidths);+ −
tableFmt.setHeaderRowCount(tableHeaderRowCount);+ −
fmt = tableFmt;+ −
}+ −
+ −
fmt.setTopMargin(topMargin(tableNodeIdx));+ −
fmt.setBottomMargin(bottomMargin(tableNodeIdx));+ −
fmt.setLeftMargin(leftMargin(tableNodeIdx)+ −
+ table.lastIndent * 40 // ##### not a good emulation+ −
);+ −
fmt.setRightMargin(rightMargin(tableNodeIdx));+ −
+ −
// compatibility+ −
if (qFuzzyCompare(fmt.leftMargin(), fmt.rightMargin())+ −
&& qFuzzyCompare(fmt.leftMargin(), fmt.topMargin())+ −
&& qFuzzyCompare(fmt.leftMargin(), fmt.bottomMargin()))+ −
fmt.setProperty(QTextFormat::FrameMargin, fmt.leftMargin());+ −
+ −
fmt.setBorderStyle(node.borderStyle);+ −
fmt.setBorderBrush(node.borderBrush);+ −
fmt.setBorder(node.tableBorder);+ −
fmt.setWidth(node.width);+ −
fmt.setHeight(node.height);+ −
if (node.blockFormat.hasProperty(QTextFormat::PageBreakPolicy))+ −
fmt.setPageBreakPolicy(node.blockFormat.pageBreakPolicy());+ −
+ −
if (node.blockFormat.hasProperty(QTextFormat::LayoutDirection))+ −
fmt.setLayoutDirection(node.blockFormat.layoutDirection());+ −
if (node.charFormat.background().style() != Qt::NoBrush)+ −
fmt.setBackground(node.charFormat.background());+ −
fmt.setPosition(QTextFrameFormat::Position(node.cssFloat));+ −
+ −
if (node.isTextFrame) {+ −
if (node.isRootFrame) {+ −
table.frame = cursor.currentFrame();+ −
table.frame->setFrameFormat(fmt);+ −
} else+ −
table.frame = cursor.insertFrame(fmt);+ −
+ −
table.isTextFrame = true;+ −
} else {+ −
const int oldPos = cursor.position();+ −
QTextTable *textTable = cursor.insertTable(table.rows, table.columns, fmt.toTableFormat());+ −
table.frame = textTable;+ −
+ −
for (int i = 0; i < rowColSpans.count(); ++i) {+ −
const RowColSpanInfo &nfo = rowColSpans.at(i);+ −
textTable->mergeCells(nfo.row, nfo.col, nfo.rowSpan, nfo.colSpan);+ −
}+ −
+ −
table.currentCell = TableCellIterator(textTable);+ −
cursor.setPosition(oldPos); // restore for caption support which needs to be inserted right before the table+ −
}+ −
return table;+ −
}+ −
+ −
QTextHtmlImporter::ProcessNodeResult QTextHtmlImporter::processBlockNode()+ −
{+ −
QTextBlockFormat block;+ −
QTextCharFormat charFmt;+ −
bool modifiedBlockFormat = true;+ −
bool modifiedCharFormat = true;+ −
+ −
if (currentNode->isTableCell() && !tables.isEmpty()) {+ −
Table &t = tables.last();+ −
if (!t.isTextFrame && !t.currentCell.atEnd()) {+ −
QTextTableCell cell = t.currentCell.cell();+ −
if (cell.isValid()) {+ −
QTextTableCellFormat fmt = cell.format().toTableCellFormat();+ −
if (topPadding(currentNodeIdx) >= 0)+ −
fmt.setTopPadding(topPadding(currentNodeIdx));+ −
if (bottomPadding(currentNodeIdx) >= 0)+ −
fmt.setBottomPadding(bottomPadding(currentNodeIdx));+ −
if (leftPadding(currentNodeIdx) >= 0)+ −
fmt.setLeftPadding(leftPadding(currentNodeIdx));+ −
if (rightPadding(currentNodeIdx) >= 0)+ −
fmt.setRightPadding(rightPadding(currentNodeIdx));+ −
cell.setFormat(fmt);+ −
+ −
cursor.setPosition(cell.firstPosition());+ −
}+ −
}+ −
hasBlock = true;+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
+ −
if (currentNode->charFormat.background().style() != Qt::NoBrush) {+ −
charFmt.setBackground(currentNode->charFormat.background());+ −
cursor.mergeBlockCharFormat(charFmt);+ −
}+ −
}+ −
+ −
if (hasBlock) {+ −
block = cursor.blockFormat();+ −
charFmt = cursor.blockCharFormat();+ −
modifiedBlockFormat = false;+ −
modifiedCharFormat = false;+ −
}+ −
+ −
// collapse+ −
{+ −
qreal tm = qreal(topMargin(currentNodeIdx));+ −
if (tm > block.topMargin()) {+ −
block.setTopMargin(tm);+ −
modifiedBlockFormat = true;+ −
}+ −
}+ −
+ −
int bottomMargin = this->bottomMargin(currentNodeIdx);+ −
+ −
// for list items we may want to collapse with the bottom margin of the+ −
// list.+ −
const QTextHtmlParserNode *parentNode = currentNode->parent ? &at(currentNode->parent) : 0;+ −
if ((currentNode->id == Html_li || currentNode->id == Html_dt || currentNode->id == Html_dd)+ −
&& parentNode+ −
&& (parentNode->isListStart() || parentNode->id == Html_dl)+ −
&& (parentNode->children.last() == currentNodeIdx)) {+ −
bottomMargin = qMax(bottomMargin, this->bottomMargin(currentNode->parent));+ −
}+ −
+ −
if (block.bottomMargin() != bottomMargin) {+ −
block.setBottomMargin(bottomMargin);+ −
modifiedBlockFormat = true;+ −
}+ −
+ −
{+ −
const qreal lm = leftMargin(currentNodeIdx);+ −
const qreal rm = rightMargin(currentNodeIdx);+ −
+ −
if (block.leftMargin() != lm) {+ −
block.setLeftMargin(lm);+ −
modifiedBlockFormat = true;+ −
}+ −
if (block.rightMargin() != rm) {+ −
block.setRightMargin(rm);+ −
modifiedBlockFormat = true;+ −
}+ −
}+ −
+ −
if (currentNode->id != Html_li+ −
&& indent != 0+ −
&& (lists.isEmpty()+ −
|| !hasBlock+ −
|| !lists.last().list+ −
|| lists.last().list->itemNumber(cursor.block()) == -1+ −
)+ −
) {+ −
block.setIndent(indent);+ −
modifiedBlockFormat = true;+ −
}+ −
+ −
if (currentNode->blockFormat.propertyCount() > 0) {+ −
modifiedBlockFormat = true;+ −
block.merge(currentNode->blockFormat);+ −
}+ −
+ −
if (currentNode->charFormat.propertyCount() > 0) {+ −
modifiedCharFormat = true;+ −
charFmt.merge(currentNode->charFormat);+ −
}+ −
+ −
// ####################+ −
// block.setFloatPosition(node->cssFloat);+ −
+ −
if (wsm == QTextHtmlParserNode::WhiteSpacePre) {+ −
block.setNonBreakableLines(true);+ −
modifiedBlockFormat = true;+ −
}+ −
+ −
if (currentNode->charFormat.background().style() != Qt::NoBrush && !currentNode->isTableCell()) {+ −
block.setBackground(currentNode->charFormat.background());+ −
modifiedBlockFormat = true;+ −
}+ −
+ −
if (hasBlock && (!currentNode->isEmptyParagraph || forceBlockMerging)) {+ −
if (modifiedBlockFormat)+ −
cursor.setBlockFormat(block);+ −
if (modifiedCharFormat)+ −
cursor.setBlockCharFormat(charFmt);+ −
} else {+ −
if (currentNodeIdx == 1 && cursor.position() == 0 && currentNode->isEmptyParagraph) {+ −
cursor.setBlockFormat(block);+ −
cursor.setBlockCharFormat(charFmt);+ −
} else {+ −
appendBlock(block, charFmt);+ −
}+ −
}+ −
+ −
if (currentNode->userState != -1)+ −
cursor.block().setUserState(currentNode->userState);+ −
+ −
if (currentNode->id == Html_li && !lists.isEmpty()) {+ −
List &l = lists.last();+ −
if (l.list) {+ −
l.list->add(cursor.block());+ −
} else {+ −
l.list = cursor.createList(l.format);+ −
const qreal listTopMargin = topMargin(l.listNode);+ −
if (listTopMargin > block.topMargin()) {+ −
block.setTopMargin(listTopMargin);+ −
cursor.mergeBlockFormat(block);+ −
}+ −
}+ −
if (hasBlock) {+ −
QTextBlockFormat fmt;+ −
fmt.setIndent(0);+ −
cursor.mergeBlockFormat(fmt);+ −
}+ −
}+ −
+ −
forceBlockMerging = false;+ −
if (currentNode->id == Html_body || currentNode->id == Html_html)+ −
forceBlockMerging = true;+ −
+ −
if (currentNode->isEmptyParagraph) {+ −
hasBlock = false;+ −
return ContinueWithNextNode;+ −
}+ −
+ −
hasBlock = true;+ −
blockTagClosed = false;+ −
return ContinueWithCurrentNode;+ −
}+ −
+ −
void QTextHtmlImporter::appendBlock(const QTextBlockFormat &format, QTextCharFormat charFmt)+ −
{+ −
if (!namedAnchors.isEmpty()) {+ −
charFmt.setAnchor(true);+ −
charFmt.setAnchorNames(namedAnchors);+ −
namedAnchors.clear();+ −
}+ −
+ −
cursor.insertBlock(format, charFmt);+ −
+ −
if (wsm != QTextHtmlParserNode::WhiteSpacePre && wsm != QTextHtmlParserNode::WhiteSpacePreWrap)+ −
compressNextWhitespace = RemoveWhiteSpace;+ −
}+ −
+ −
#endif // QT_NO_TEXTHTMLPARSER+ −
+ −
/*!+ −
\fn QTextDocumentFragment QTextDocumentFragment::fromHtml(const QString &text)+ −
+ −
Returns a QTextDocumentFragment based on the arbitrary piece of+ −
HTML in the given \a text. The formatting is preserved as much as+ −
possible; for example, "<b>bold</b>" will become a document+ −
fragment with the text "bold" with a bold character format.+ −
*/+ −
+ −
#ifndef QT_NO_TEXTHTMLPARSER+ −
+ −
QTextDocumentFragment QTextDocumentFragment::fromHtml(const QString &html)+ −
{+ −
return fromHtml(html, 0);+ −
}+ −
+ −
/*!+ −
\fn QTextDocumentFragment QTextDocumentFragment::fromHtml(const QString &text, const QTextDocument *resourceProvider)+ −
\since 4.2+ −
+ −
Returns a QTextDocumentFragment based on the arbitrary piece of+ −
HTML in the given \a text. The formatting is preserved as much as+ −
possible; for example, "<b>bold</b>" will become a document+ −
fragment with the text "bold" with a bold character format.+ −
+ −
If the provided HTML contains references to external resources such as imported style sheets, then+ −
they will be loaded through the \a resourceProvider.+ −
*/+ −
+ −
QTextDocumentFragment QTextDocumentFragment::fromHtml(const QString &html, const QTextDocument *resourceProvider)+ −
{+ −
QTextDocumentFragment res;+ −
res.d = new QTextDocumentFragmentPrivate;+ −
+ −
QTextHtmlImporter importer(res.d->doc, html, QTextHtmlImporter::ImportToFragment, resourceProvider);+ −
importer.import();+ −
return res;+ −
}+ −
+ −
QT_END_NAMESPACE+ −
#endif // QT_NO_TEXTHTMLPARSER+ −