/****************************************************************************
**
** Copyright (C) 2010 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