/****************************************************************************
**
** 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 "qtextdocumentlayout_p.h"
#include "qtextdocument_p.h"
#include "qtextimagehandler_p.h"
#include "qtexttable.h"
#include "qtextlist.h"
#include "qtextengine_p.h"
#include "private/qcssutil_p.h"
#include "qabstracttextdocumentlayout_p.h"
#include "qcssparser_p.h"
#include <qpainter.h>
#include <qmath.h>
#include <qrect.h>
#include <qpalette.h>
#include <qdebug.h>
#include <qvarlengtharray.h>
#include <limits.h>
#include <qstyle.h>
#include <qbasictimer.h>
#include "private/qfunctions_p.h"
// #define LAYOUT_DEBUG
#ifdef LAYOUT_DEBUG
#define LDEBUG qDebug()
#define INC_INDENT debug_indent += " "
#define DEC_INDENT debug_indent = debug_indent.left(debug_indent.length()-2)
#else
#define LDEBUG if(0) qDebug()
#define INC_INDENT do {} while(0)
#define DEC_INDENT do {} while(0)
#endif
QT_BEGIN_NAMESPACE
Q_GUI_EXPORT extern int qt_defaultDpi();
// ################ should probably add frameFormatChange notification!
struct QLayoutStruct;
class QTextFrameData : public QTextFrameLayoutData
{
public:
QTextFrameData();
// relative to parent frame
QFixedPoint position;
QFixedSize size;
// contents starts at (margin+border/margin+border)
QFixed topMargin;
QFixed bottomMargin;
QFixed leftMargin;
QFixed rightMargin;
QFixed border;
QFixed padding;
// contents width includes padding (as we need to treat this on a per cell basis for tables)
QFixed contentsWidth;
QFixed contentsHeight;
QFixed oldContentsWidth;
// accumulated margins
QFixed effectiveTopMargin;
QFixed effectiveBottomMargin;
QFixed minimumWidth;
QFixed maximumWidth;
QLayoutStruct *currentLayoutStruct;
bool sizeDirty;
bool layoutDirty;
QList<QPointer<QTextFrame> > floats;
};
QTextFrameData::QTextFrameData()
: maximumWidth(QFIXED_MAX),
currentLayoutStruct(0), sizeDirty(true), layoutDirty(true)
{
}
struct QLayoutStruct {
QLayoutStruct() : maximumWidth(QFIXED_MAX), fullLayout(false)
{}
QTextFrame *frame;
QFixed x_left;
QFixed x_right;
QFixed frameY; // absolute y position of the current frame
QFixed y; // always relative to the current frame
QFixed contentsWidth;
QFixed minimumWidth;
QFixed maximumWidth;
bool fullLayout;
QList<QTextFrame *> pendingFloats;
QFixed pageHeight;
QFixed pageBottom;
QFixed pageTopMargin;
QFixed pageBottomMargin;
QRectF updateRect;
QRectF updateRectForFloats;
inline void addUpdateRectForFloat(const QRectF &rect) {
if (updateRectForFloats.isValid())
updateRectForFloats |= rect;
else
updateRectForFloats = rect;
}
inline QFixed absoluteY() const
{ return frameY + y; }
inline int currentPage() const
{ return pageHeight == 0 ? 0 : (absoluteY() / pageHeight).truncate(); }
inline void newPage()
{ if (pageHeight == QFIXED_MAX) return; pageBottom += pageHeight; y = pageBottom - pageHeight + pageBottomMargin + pageTopMargin - frameY; }
};
class QTextTableData : public QTextFrameData
{
public:
QFixed cellSpacing, cellPadding;
qreal deviceScale;
QVector<QFixed> minWidths;
QVector<QFixed> maxWidths;
QVector<QFixed> widths;
QVector<QFixed> heights;
QVector<QFixed> columnPositions;
QVector<QFixed> rowPositions;
QVector<QFixed> cellVerticalOffsets;
QFixed headerHeight;
// maps from cell index (row + col * rowCount) to child frames belonging to
// the specific cell
QMultiHash<int, QTextFrame *> childFrameMap;
inline QFixed cellWidth(int column, int colspan) const
{ return columnPositions.at(column + colspan - 1) + widths.at(column + colspan - 1)
- columnPositions.at(column); }
inline void calcRowPosition(int row)
{
if (row > 0)
rowPositions[row] = rowPositions.at(row - 1) + heights.at(row - 1) + border + cellSpacing + border;
}
QRectF cellRect(const QTextTableCell &cell) const;
inline QFixed paddingProperty(const QTextFormat &format, QTextFormat::Property property) const
{
QVariant v = format.property(property);
if (v.isNull()) {
return cellPadding;
} else {
Q_ASSERT(v.userType() == QVariant::Double || v.userType() == QMetaType::Float);
return QFixed::fromReal(v.toReal() * deviceScale);
}
}
inline QFixed topPadding(const QTextFormat &format) const
{
return paddingProperty(format, QTextFormat::TableCellTopPadding);
}
inline QFixed bottomPadding(const QTextFormat &format) const
{
return paddingProperty(format, QTextFormat::TableCellBottomPadding);
}
inline QFixed leftPadding(const QTextFormat &format) const
{
return paddingProperty(format, QTextFormat::TableCellLeftPadding);
}
inline QFixed rightPadding(const QTextFormat &format) const
{
return paddingProperty(format, QTextFormat::TableCellRightPadding);
}
inline QFixedPoint cellPosition(const QTextTableCell &cell) const
{
const QTextFormat fmt = cell.format();
return cellPosition(cell.row(), cell.column()) + QFixedPoint(leftPadding(fmt), topPadding(fmt));
}
void updateTableSize();
private:
inline QFixedPoint cellPosition(int row, int col) const
{ return QFixedPoint(columnPositions.at(col), rowPositions.at(row) + cellVerticalOffsets.at(col + row * widths.size())); }
};
static QTextFrameData *createData(QTextFrame *f)
{
QTextFrameData *data;
if (qobject_cast<QTextTable *>(f))
data = new QTextTableData;
else
data = new QTextFrameData;
f->setLayoutData(data);
return data;
}
static inline QTextFrameData *data(QTextFrame *f)
{
QTextFrameData *data = static_cast<QTextFrameData *>(f->layoutData());
if (!data)
data = createData(f);
return data;
}
static bool isFrameFromInlineObject(QTextFrame *f)
{
return f->firstPosition() > f->lastPosition();
}
void QTextTableData::updateTableSize()
{
const QFixed effectiveTopMargin = this->topMargin + border + padding;
const QFixed effectiveBottomMargin = this->bottomMargin + border + padding;
const QFixed effectiveLeftMargin = this->leftMargin + border + padding;
const QFixed effectiveRightMargin = this->rightMargin + border + padding;
size.height = contentsHeight == -1
? rowPositions.last() + heights.last() + padding + border + cellSpacing + effectiveBottomMargin
: effectiveTopMargin + contentsHeight + effectiveBottomMargin;
size.width = effectiveLeftMargin + contentsWidth + effectiveRightMargin;
}
QRectF QTextTableData::cellRect(const QTextTableCell &cell) const
{
const int row = cell.row();
const int rowSpan = cell.rowSpan();
const int column = cell.column();
const int colSpan = cell.columnSpan();
return QRectF(columnPositions.at(column).toReal(),
rowPositions.at(row).toReal(),
(columnPositions.at(column + colSpan - 1) + widths.at(column + colSpan - 1) - columnPositions.at(column)).toReal(),
(rowPositions.at(row + rowSpan - 1) + heights.at(row + rowSpan - 1) - rowPositions.at(row)).toReal());
}
static inline bool isEmptyBlockBeforeTable(const QTextBlock &block, const QTextBlockFormat &format, const QTextFrame::Iterator &nextIt)
{
return !nextIt.atEnd()
&& qobject_cast<QTextTable *>(nextIt.currentFrame())
&& block.isValid()
&& block.length() == 1
&& !format.hasProperty(QTextFormat::BlockTrailingHorizontalRulerWidth)
&& !format.hasProperty(QTextFormat::BackgroundBrush)
&& nextIt.currentFrame()->firstPosition() == block.position() + 1
;
}
static inline bool isEmptyBlockBeforeTable(QTextFrame::Iterator it)
{
QTextFrame::Iterator next = it; ++next;
if (it.currentFrame())
return false;
QTextBlock block = it.currentBlock();
return isEmptyBlockBeforeTable(block, block.blockFormat(), next);
}
static inline bool isEmptyBlockAfterTable(const QTextBlock &block, const QTextFrame *previousFrame)
{
return qobject_cast<const QTextTable *>(previousFrame)
&& block.isValid()
&& block.length() == 1
&& previousFrame->lastPosition() == block.position() - 1
;
}
static inline bool isLineSeparatorBlockAfterTable(const QTextBlock &block, const QTextFrame *previousFrame)
{
return qobject_cast<const QTextTable *>(previousFrame)
&& block.isValid()
&& block.length() > 1
&& block.text().at(0) == QChar::LineSeparator
&& previousFrame->lastPosition() == block.position() - 1
;
}
/*
Optimisation strategies:
HTML layout:
* Distinguish between normal and special flow. For normal flow the condition:
y1 > y2 holds for all blocks with b1.key() > b2.key().
* Special flow is: floats, table cells
* Normal flow within table cells. Tables (not cells) are part of the normal flow.
* If blocks grows/shrinks in height and extends over whole page width at the end, move following blocks.
* If height doesn't change, no need to do anything
Table cells:
* If minWidth of cell changes, recalculate table width, relayout if needed.
* What about maxWidth when doing auto layout?
Floats:
* need fixed or proportional width, otherwise don't float!
* On width/height change relayout surrounding paragraphs.
Document width change:
* full relayout needed
Float handling:
* Floats are specified by a special format object.
* currently only floating images are implemented.
*/
/*
On the table layouting:
+---[ table border ]-------------------------
| [ cell spacing ]
| +------[ cell border ]-----+ +--------
| | | |
| |
| |
| |
|
rowPositions[i] and columnPositions[i] point at the cell content
position. So for example the left border is drawn at
x = columnPositions[i] - fd->border and similar for y.
*/
struct QCheckPoint
{
QFixed y;
QFixed frameY; // absolute y position of the current frame
int positionInFrame;
QFixed minimumWidth;
QFixed maximumWidth;
QFixed contentsWidth;
};
Q_DECLARE_TYPEINFO(QCheckPoint, Q_PRIMITIVE_TYPE);
Q_STATIC_GLOBAL_OPERATOR bool operator<(const QCheckPoint &checkPoint, QFixed y)
{
return checkPoint.y < y;
}
Q_STATIC_GLOBAL_OPERATOR bool operator<(const QCheckPoint &checkPoint, int pos)
{
return checkPoint.positionInFrame < pos;
}
static void fillBackground(QPainter *p, const QRectF &rect, QBrush brush, const QPointF &origin, QRectF gradientRect = QRectF())
{
p->save();
if (brush.style() >= Qt::LinearGradientPattern && brush.style() <= Qt::ConicalGradientPattern) {
if (!gradientRect.isNull()) {
QTransform m;
m.translate(gradientRect.left(), gradientRect.top());
m.scale(gradientRect.width(), gradientRect.height());
brush.setTransform(m);
const_cast<QGradient *>(brush.gradient())->setCoordinateMode(QGradient::LogicalMode);
}
} else {
p->setBrushOrigin(origin);
}
p->fillRect(rect, brush);
p->restore();
}
class QTextDocumentLayoutPrivate : public QAbstractTextDocumentLayoutPrivate
{
Q_DECLARE_PUBLIC(QTextDocumentLayout)
public:
QTextDocumentLayoutPrivate();
QTextOption::WrapMode wordWrapMode;
#ifdef LAYOUT_DEBUG
mutable QString debug_indent;
#endif
int fixedColumnWidth;
int cursorWidth;
QSizeF lastReportedSize;
QRectF viewportRect;
QRectF clipRect;
mutable int currentLazyLayoutPosition;
mutable int lazyLayoutStepSize;
QBasicTimer layoutTimer;
mutable QBasicTimer sizeChangedTimer;
uint showLayoutProgress : 1;
uint insideDocumentChange : 1;
int lastPageCount;
qreal idealWidth;
bool contentHasAlignment;
QFixed blockIndent(const QTextBlockFormat &blockFormat) const;
void drawFrame(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context,
QTextFrame *f) const;
void drawFlow(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context,
QTextFrame::Iterator it, const QList<QTextFrame *> &floats, QTextBlock *cursorBlockNeedingRepaint) const;
void drawBlock(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context,
QTextBlock bl, bool inRootFrame) const;
void drawListItem(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context,
QTextBlock bl, const QTextCharFormat *selectionFormat) const;
void drawTableCell(const QRectF &cellRect, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &cell_context,
QTextTable *table, QTextTableData *td, int r, int c,
QTextBlock *cursorBlockNeedingRepaint, QPointF *cursorBlockOffset) const;
void drawBorder(QPainter *painter, const QRectF &rect, qreal topMargin, qreal bottomMargin, qreal border,
const QBrush &brush, QTextFrameFormat::BorderStyle style) const;
void drawFrameDecoration(QPainter *painter, QTextFrame *frame, QTextFrameData *fd, const QRectF &clip, const QRectF &rect) const;
enum HitPoint {
PointBefore,
PointAfter,
PointInside,
PointExact
};
HitPoint hitTest(QTextFrame *frame, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const;
HitPoint hitTest(QTextFrame::Iterator it, HitPoint hit, const QFixedPoint &p,
int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const;
HitPoint hitTest(QTextTable *table, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const;
HitPoint hitTest(QTextBlock bl, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const;
QLayoutStruct layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width,
int layoutFrom, int layoutTo, QTextTableData *tableData, QFixed absoluteTableY,
bool withPageBreaks);
void setCellPosition(QTextTable *t, const QTextTableCell &cell, const QPointF &pos);
QRectF layoutTable(QTextTable *t, int layoutFrom, int layoutTo, QFixed parentY);
void positionFloat(QTextFrame *frame, QTextLine *currentLine = 0);
// calls the next one
QRectF layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed parentY = 0);
QRectF layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed frameWidth, QFixed frameHeight, QFixed parentY = 0);
void layoutBlock(const QTextBlock &bl, int blockPosition, const QTextBlockFormat &blockFormat,
QLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat);
void layoutFlow(QTextFrame::Iterator it, QLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, QFixed width = 0);
void pageBreakInsideTable(QTextTable *table, QLayoutStruct *layoutStruct);
void floatMargins(const QFixed &y, const QLayoutStruct *layoutStruct, QFixed *left, QFixed *right) const;
QFixed findY(QFixed yFrom, const QLayoutStruct *layoutStruct, QFixed requiredWidth) const;
QVector<QCheckPoint> checkPoints;
QTextFrame::Iterator frameIteratorForYPosition(QFixed y) const;
QTextFrame::Iterator frameIteratorForTextPosition(int position) const;
void ensureLayouted(QFixed y) const;
void ensureLayoutedByPosition(int position) const;
inline void ensureLayoutFinished() const
{ ensureLayoutedByPosition(INT_MAX); }
void layoutStep() const;
QRectF frameBoundingRectInternal(QTextFrame *frame) const;
qreal scaleToDevice(qreal value) const;
QFixed scaleToDevice(QFixed value) const;
};
QTextDocumentLayoutPrivate::QTextDocumentLayoutPrivate()
: fixedColumnWidth(-1),
cursorWidth(1),
currentLazyLayoutPosition(-1),
lazyLayoutStepSize(1000),
lastPageCount(-1)
{
showLayoutProgress = true;
insideDocumentChange = false;
idealWidth = 0;
contentHasAlignment = false;
}
QTextFrame::Iterator QTextDocumentLayoutPrivate::frameIteratorForYPosition(QFixed y) const
{
QTextFrame *rootFrame = document->rootFrame();
if (checkPoints.isEmpty()
|| y < 0 || y > data(rootFrame)->size.height)
return rootFrame->begin();
QVector<QCheckPoint>::ConstIterator checkPoint = qLowerBound(checkPoints.begin(), checkPoints.end(), y);
if (checkPoint == checkPoints.end())
return rootFrame->begin();
if (checkPoint != checkPoints.begin())
--checkPoint;
const int position = rootFrame->firstPosition() + checkPoint->positionInFrame;
return frameIteratorForTextPosition(position);
}
QTextFrame::Iterator QTextDocumentLayoutPrivate::frameIteratorForTextPosition(int position) const
{
QTextFrame *rootFrame = docPrivate->rootFrame();
const QTextDocumentPrivate::BlockMap &map = docPrivate->blockMap();
const int begin = map.findNode(rootFrame->firstPosition());
const int end = map.findNode(rootFrame->lastPosition()+1);
const int block = map.findNode(position);
const int blockPos = map.position(block);
QTextFrame::iterator it(rootFrame, block, begin, end);
QTextFrame *containingFrame = docPrivate->frameAt(blockPos);
if (containingFrame != rootFrame) {
while (containingFrame->parentFrame() != rootFrame) {
containingFrame = containingFrame->parentFrame();
Q_ASSERT(containingFrame);
}
it.cf = containingFrame;
it.cb = 0;
}
return it;
}
QTextDocumentLayoutPrivate::HitPoint
QTextDocumentLayoutPrivate::hitTest(QTextFrame *frame, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const
{
QTextFrameData *fd = data(frame);
// #########
if (fd->layoutDirty)
return PointAfter;
Q_ASSERT(!fd->layoutDirty);
Q_ASSERT(!fd->sizeDirty);
const QFixedPoint relativePoint(point.x - fd->position.x, point.y - fd->position.y);
QTextFrame *rootFrame = docPrivate->rootFrame();
// LDEBUG << "checking frame" << frame->firstPosition() << "point=" << point
// << "position" << fd->position << "size" << fd->size;
if (frame != rootFrame) {
if (relativePoint.y < 0 || relativePoint.x < 0) {
*position = frame->firstPosition() - 1;
// LDEBUG << "before pos=" << *position;
return PointBefore;
} else if (relativePoint.y > fd->size.height || relativePoint.x > fd->size.width) {
*position = frame->lastPosition() + 1;
// LDEBUG << "after pos=" << *position;
return PointAfter;
}
}
if (isFrameFromInlineObject(frame)) {
*position = frame->firstPosition() - 1;
return PointExact;
}
if (QTextTable *table = qobject_cast<QTextTable *>(frame)) {
const int rows = table->rows();
const int columns = table->columns();
QTextTableData *td = static_cast<QTextTableData *>(data(table));
if (!td->childFrameMap.isEmpty()) {
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < columns; ++c) {
QTextTableCell cell = table->cellAt(r, c);
if (cell.row() != r || cell.column() != c)
continue;
QRectF cellRect = td->cellRect(cell);
const QFixedPoint cellPos = QFixedPoint::fromPointF(cellRect.topLeft());
const QFixedPoint pointInCell = relativePoint - cellPos;
const QList<QTextFrame *> childFrames = td->childFrameMap.values(r + c * rows);
for (int i = 0; i < childFrames.size(); ++i) {
QTextFrame *child = childFrames.at(i);
if (isFrameFromInlineObject(child)
&& child->frameFormat().position() != QTextFrameFormat::InFlow
&& hitTest(child, pointInCell, position, l, accuracy) == PointExact)
{
return PointExact;
}
}
}
}
}
return hitTest(table, relativePoint, position, l, accuracy);
}
const QList<QTextFrame *> childFrames = frame->childFrames();
for (int i = 0; i < childFrames.size(); ++i) {
QTextFrame *child = childFrames.at(i);
if (isFrameFromInlineObject(child)
&& child->frameFormat().position() != QTextFrameFormat::InFlow
&& hitTest(child, relativePoint, position, l, accuracy) == PointExact)
{
return PointExact;
}
}
QTextFrame::Iterator it = frame->begin();
if (frame == rootFrame) {
it = frameIteratorForYPosition(relativePoint.y);
Q_ASSERT(it.parentFrame() == frame);
}
if (it.currentFrame())
*position = it.currentFrame()->firstPosition();
else
*position = it.currentBlock().position();
return hitTest(it, PointBefore, relativePoint, position, l, accuracy);
}
QTextDocumentLayoutPrivate::HitPoint
QTextDocumentLayoutPrivate::hitTest(QTextFrame::Iterator it, HitPoint hit, const QFixedPoint &p,
int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const
{
INC_INDENT;
for (; !it.atEnd(); ++it) {
QTextFrame *c = it.currentFrame();
HitPoint hp;
int pos = -1;
if (c) {
hp = hitTest(c, p, &pos, l, accuracy);
} else {
hp = hitTest(it.currentBlock(), p, &pos, l, accuracy);
}
if (hp >= PointInside) {
if (isEmptyBlockBeforeTable(it))
continue;
hit = hp;
*position = pos;
break;
}
if (hp == PointBefore && pos < *position) {
*position = pos;
hit = hp;
} else if (hp == PointAfter && pos > *position) {
*position = pos;
hit = hp;
}
}
DEC_INDENT;
// LDEBUG << "inside=" << hit << " pos=" << *position;
return hit;
}
QTextDocumentLayoutPrivate::HitPoint
QTextDocumentLayoutPrivate::hitTest(QTextTable *table, const QFixedPoint &point,
int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const
{
QTextTableData *td = static_cast<QTextTableData *>(data(table));
QVector<QFixed>::ConstIterator rowIt = qLowerBound(td->rowPositions.constBegin(), td->rowPositions.constEnd(), point.y);
if (rowIt == td->rowPositions.constEnd()) {
rowIt = td->rowPositions.constEnd() - 1;
} else if (rowIt != td->rowPositions.constBegin()) {
--rowIt;
}
QVector<QFixed>::ConstIterator colIt = qLowerBound(td->columnPositions.constBegin(), td->columnPositions.constEnd(), point.x);
if (colIt == td->columnPositions.constEnd()) {
colIt = td->columnPositions.constEnd() - 1;
} else if (colIt != td->columnPositions.constBegin()) {
--colIt;
}
QTextTableCell cell = table->cellAt(rowIt - td->rowPositions.constBegin(),
colIt - td->columnPositions.constBegin());
if (!cell.isValid())
return PointBefore;
*position = cell.firstPosition();
HitPoint hp = hitTest(cell.begin(), PointInside, point - td->cellPosition(cell), position, l, accuracy);
if (hp == PointExact)
return hp;
if (hp == PointAfter)
*position = cell.lastPosition();
return PointInside;
}
QTextDocumentLayoutPrivate::HitPoint
QTextDocumentLayoutPrivate::hitTest(QTextBlock bl, const QFixedPoint &point, int *position, QTextLayout **l,
Qt::HitTestAccuracy accuracy) const
{
QTextLayout *tl = bl.layout();
QRectF textrect = tl->boundingRect();
textrect.translate(tl->position());
// LDEBUG << " checking block" << bl.position() << "point=" << point
// << " tlrect" << textrect;
*position = bl.position();
if (point.y.toReal() < textrect.top()) {
// LDEBUG << " before pos=" << *position;
return PointBefore;
} else if (point.y.toReal() > textrect.bottom()) {
*position += bl.length();
// LDEBUG << " after pos=" << *position;
return PointAfter;
}
QPointF pos = point.toPointF() - tl->position();
// ### rtl?
HitPoint hit = PointInside;
*l = tl;
int off = 0;
for (int i = 0; i < tl->lineCount(); ++i) {
QTextLine line = tl->lineAt(i);
const QRectF lr = line.naturalTextRect();
if (lr.top() > pos.y()) {
off = qMin(off, line.textStart());
} else if (lr.bottom() <= pos.y()) {
off = qMax(off, line.textStart() + line.textLength());
} else {
if (lr.left() <= pos.x() && lr.right() >= pos.x())
hit = PointExact;
// when trying to hit an anchor we want it to hit not only in the left
// half
if (accuracy == Qt::ExactHit)
off = line.xToCursor(pos.x(), QTextLine::CursorOnCharacter);
else
off = line.xToCursor(pos.x(), QTextLine::CursorBetweenCharacters);
break;
}
}
*position += off;
// LDEBUG << " inside=" << hit << " pos=" << *position;
return hit;
}
// ### could be moved to QTextBlock
QFixed QTextDocumentLayoutPrivate::blockIndent(const QTextBlockFormat &blockFormat) const
{
qreal indent = blockFormat.indent();
QTextObject *object = document->objectForFormat(blockFormat);
if (object)
indent += object->format().toListFormat().indent();
if (qIsNull(indent))
return 0;
qreal scale = 1;
if (paintDevice) {
scale = qreal(paintDevice->logicalDpiY()) / qreal(qt_defaultDpi());
}
return QFixed::fromReal(indent * scale * document->indentWidth());
}
void QTextDocumentLayoutPrivate::drawBorder(QPainter *painter, const QRectF &rect, qreal topMargin, qreal bottomMargin,
qreal border, const QBrush &brush, QTextFrameFormat::BorderStyle style) const
{
const qreal pageHeight = document->pageSize().height();
const int topPage = pageHeight > 0 ? static_cast<int>(rect.top() / pageHeight) : 0;
const int bottomPage = pageHeight > 0 ? static_cast<int>((rect.bottom() + border) / pageHeight) : 0;
#ifndef QT_NO_CSSPARSER
QCss::BorderStyle cssStyle = static_cast<QCss::BorderStyle>(style + 1);
#endif //QT_NO_CSSPARSER
bool turn_off_antialiasing = !(painter->renderHints() & QPainter::Antialiasing);
painter->setRenderHint(QPainter::Antialiasing);
for (int i = topPage; i <= bottomPage; ++i) {
QRectF clipped = rect.toRect();
if (topPage != bottomPage) {
clipped.setTop(qMax(clipped.top(), i * pageHeight + topMargin - border));
clipped.setBottom(qMin(clipped.bottom(), (i + 1) * pageHeight - bottomMargin));
if (clipped.bottom() <= clipped.top())
continue;
}
#ifndef QT_NO_CSSPARSER
qDrawEdge(painter, clipped.left(), clipped.top(), clipped.left() + border, clipped.bottom() + border, 0, 0, QCss::LeftEdge, cssStyle, brush);
qDrawEdge(painter, clipped.left() + border, clipped.top(), clipped.right() + border, clipped.top() + border, 0, 0, QCss::TopEdge, cssStyle, brush);
qDrawEdge(painter, clipped.right(), clipped.top() + border, clipped.right() + border, clipped.bottom(), 0, 0, QCss::RightEdge, cssStyle, brush);
qDrawEdge(painter, clipped.left() + border, clipped.bottom(), clipped.right() + border, clipped.bottom() + border, 0, 0, QCss::BottomEdge, cssStyle, brush);
#else
painter->save();
painter->setPen(Qt::NoPen);
painter->setBrush(brush);
painter->drawRect(QRectF(clipped.left(), clipped.top(), clipped.left() + border, clipped.bottom() + border));
painter->drawRect(QRectF(clipped.left() + border, clipped.top(), clipped.right() + border, clipped.top() + border));
painter->drawRect(QRectF(clipped.right(), clipped.top() + border, clipped.right() + border, clipped.bottom()));
painter->drawRect(QRectF(clipped.left() + border, clipped.bottom(), clipped.right() + border, clipped.bottom() + border));
painter->restore();
#endif //QT_NO_CSSPARSER
}
if (turn_off_antialiasing)
painter->setRenderHint(QPainter::Antialiasing, false);
}
void QTextDocumentLayoutPrivate::drawFrameDecoration(QPainter *painter, QTextFrame *frame, QTextFrameData *fd, const QRectF &clip, const QRectF &rect) const
{
const QBrush bg = frame->frameFormat().background();
if (bg != Qt::NoBrush) {
QRectF bgRect = rect;
bgRect.adjust((fd->leftMargin + fd->border).toReal(),
(fd->topMargin + fd->border).toReal(),
- (fd->rightMargin + fd->border).toReal(),
- (fd->bottomMargin + fd->border).toReal());
QRectF gradientRect; // invalid makes it default to bgRect
QPointF origin = bgRect.topLeft();
if (!frame->parentFrame()) {
bgRect = clip;
gradientRect.setWidth(painter->device()->width());
gradientRect.setHeight(painter->device()->height());
}
fillBackground(painter, bgRect, bg, origin, gradientRect);
}
if (fd->border != 0) {
painter->save();
painter->setBrush(Qt::lightGray);
painter->setPen(Qt::NoPen);
const qreal leftEdge = rect.left() + fd->leftMargin.toReal();
const qreal border = fd->border.toReal();
const qreal topMargin = fd->topMargin.toReal();
const qreal leftMargin = fd->leftMargin.toReal();
const qreal bottomMargin = fd->bottomMargin.toReal();
const qreal rightMargin = fd->rightMargin.toReal();
const qreal w = rect.width() - 2 * border - leftMargin - rightMargin;
const qreal h = rect.height() - 2 * border - topMargin - bottomMargin;
drawBorder(painter, QRectF(leftEdge, rect.top() + topMargin, w + border, h + border),
fd->effectiveTopMargin.toReal(), fd->effectiveBottomMargin.toReal(),
border, frame->frameFormat().borderBrush(), frame->frameFormat().borderStyle());
painter->restore();
}
}
static void adjustContextSelectionsForCell(QAbstractTextDocumentLayout::PaintContext &cell_context,
const QTextTableCell &cell,
int r, int c,
const int *selectedTableCells)
{
for (int i = 0; i < cell_context.selections.size(); ++i) {
int row_start = selectedTableCells[i * 4];
int col_start = selectedTableCells[i * 4 + 1];
int num_rows = selectedTableCells[i * 4 + 2];
int num_cols = selectedTableCells[i * 4 + 3];
if (row_start != -1) {
if (r >= row_start && r < row_start + num_rows
&& c >= col_start && c < col_start + num_cols)
{
int firstPosition = cell.firstPosition();
int lastPosition = cell.lastPosition();
// make sure empty cells are still selected
if (firstPosition == lastPosition)
++lastPosition;
cell_context.selections[i].cursor.setPosition(firstPosition);
cell_context.selections[i].cursor.setPosition(lastPosition, QTextCursor::KeepAnchor);
} else {
cell_context.selections[i].cursor.clearSelection();
}
}
// FullWidthSelection is not useful for tables
cell_context.selections[i].format.clearProperty(QTextFormat::FullWidthSelection);
}
}
void QTextDocumentLayoutPrivate::drawFrame(const QPointF &offset, QPainter *painter,
const QAbstractTextDocumentLayout::PaintContext &context,
QTextFrame *frame) const
{
QTextFrameData *fd = data(frame);
// #######
if (fd->layoutDirty)
return;
Q_ASSERT(!fd->sizeDirty);
Q_ASSERT(!fd->layoutDirty);
const QPointF off = offset + fd->position.toPointF();
if (context.clip.isValid()
&& (off.y() > context.clip.bottom() || off.y() + fd->size.height.toReal() < context.clip.top()
|| off.x() > context.clip.right() || off.x() + fd->size.width.toReal() < context.clip.left()))
return;
// LDEBUG << debug_indent << "drawFrame" << frame->firstPosition() << "--" << frame->lastPosition() << "at" << offset;
// INC_INDENT;
// if the cursor is /on/ a table border we may need to repaint it
// afterwards, as we usually draw the decoration first
QTextBlock cursorBlockNeedingRepaint;
QPointF offsetOfRepaintedCursorBlock = off;
QTextTable *table = qobject_cast<QTextTable *>(frame);
const QRectF frameRect(off, fd->size.toSizeF());
if (table) {
const int rows = table->rows();
const int columns = table->columns();
QTextTableData *td = static_cast<QTextTableData *>(data(table));
QVarLengthArray<int> selectedTableCells(context.selections.size() * 4);
for (int i = 0; i < context.selections.size(); ++i) {
const QAbstractTextDocumentLayout::Selection &s = context.selections.at(i);
int row_start = -1, col_start = -1, num_rows = -1, num_cols = -1;
if (s.cursor.currentTable() == table)
s.cursor.selectedTableCells(&row_start, &num_rows, &col_start, &num_cols);
selectedTableCells[i * 4] = row_start;
selectedTableCells[i * 4 + 1] = col_start;
selectedTableCells[i * 4 + 2] = num_rows;
selectedTableCells[i * 4 + 3] = num_cols;
}
QFixed pageHeight = QFixed::fromReal(document->pageSize().height());
if (pageHeight <= 0)
pageHeight = QFIXED_MAX;
const int tableStartPage = (td->position.y / pageHeight).truncate();
const int tableEndPage = ((td->position.y + td->size.height) / pageHeight).truncate();
qreal border = td->border.toReal();
drawFrameDecoration(painter, frame, fd, context.clip, frameRect);
// draw the table headers
const int headerRowCount = qMin(table->format().headerRowCount(), rows - 1);
int page = tableStartPage + 1;
while (page <= tableEndPage) {
const QFixed pageTop = page * pageHeight + td->effectiveTopMargin + td->cellSpacing + td->border;
const qreal headerOffset = (pageTop - td->rowPositions.at(0)).toReal();
for (int r = 0; r < headerRowCount; ++r) {
for (int c = 0; c < columns; ++c) {
QTextTableCell cell = table->cellAt(r, c);
QAbstractTextDocumentLayout::PaintContext cell_context = context;
adjustContextSelectionsForCell(cell_context, cell, r, c, selectedTableCells.data());
QRectF cellRect = td->cellRect(cell);
cellRect.translate(off.x(), headerOffset);
// we need to account for the cell border in the clipping test
int leftAdjust = qMin(qreal(0), 1 - border);
if (cell_context.clip.isValid() && !cellRect.adjusted(leftAdjust, leftAdjust, border, border).intersects(cell_context.clip))
continue;
drawTableCell(cellRect, painter, cell_context, table, td, r, c, &cursorBlockNeedingRepaint,
&offsetOfRepaintedCursorBlock);
}
}
++page;
}
int firstRow = 0;
int lastRow = rows;
if (context.clip.isValid()) {
QVector<QFixed>::ConstIterator rowIt = qLowerBound(td->rowPositions.constBegin(), td->rowPositions.constEnd(), QFixed::fromReal(context.clip.top() - off.y()));
if (rowIt != td->rowPositions.constEnd() && rowIt != td->rowPositions.constBegin()) {
--rowIt;
firstRow = rowIt - td->rowPositions.constBegin();
}
rowIt = qUpperBound(td->rowPositions.constBegin(), td->rowPositions.constEnd(), QFixed::fromReal(context.clip.bottom() - off.y()));
if (rowIt != td->rowPositions.constEnd()) {
++rowIt;
lastRow = rowIt - td->rowPositions.constBegin();
}
}
for (int c = 0; c < columns; ++c) {
QTextTableCell cell = table->cellAt(firstRow, c);
firstRow = qMin(firstRow, cell.row());
}
for (int r = firstRow; r < lastRow; ++r) {
for (int c = 0; c < columns; ++c) {
QTextTableCell cell = table->cellAt(r, c);
QAbstractTextDocumentLayout::PaintContext cell_context = context;
adjustContextSelectionsForCell(cell_context, cell, r, c, selectedTableCells.data());
QRectF cellRect = td->cellRect(cell);
cellRect.translate(off);
// we need to account for the cell border in the clipping test
int leftAdjust = qMin(qreal(0), 1 - border);
if (cell_context.clip.isValid() && !cellRect.adjusted(leftAdjust, leftAdjust, border, border).intersects(cell_context.clip))
continue;
drawTableCell(cellRect, painter, cell_context, table, td, r, c, &cursorBlockNeedingRepaint,
&offsetOfRepaintedCursorBlock);
}
}
} else {
drawFrameDecoration(painter, frame, fd, context.clip, frameRect);
QTextFrame::Iterator it = frame->begin();
if (frame == docPrivate->rootFrame())
it = frameIteratorForYPosition(QFixed::fromReal(context.clip.top()));
QList<QTextFrame *> floats;
for (int i = 0; i < fd->floats.count(); ++i)
floats.append(fd->floats.at(i));
drawFlow(off, painter, context, it, floats, &cursorBlockNeedingRepaint);
}
if (cursorBlockNeedingRepaint.isValid()) {
const QPen oldPen = painter->pen();
painter->setPen(context.palette.color(QPalette::Text));
const int cursorPos = context.cursorPosition - cursorBlockNeedingRepaint.position();
cursorBlockNeedingRepaint.layout()->drawCursor(painter, offsetOfRepaintedCursorBlock,
cursorPos, cursorWidth);
painter->setPen(oldPen);
}
// DEC_INDENT;
return;
}
void QTextDocumentLayoutPrivate::drawTableCell(const QRectF &cellRect, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &cell_context,
QTextTable *table, QTextTableData *td, int r, int c,
QTextBlock *cursorBlockNeedingRepaint, QPointF *cursorBlockOffset) const
{
QTextTableCell cell = table->cellAt(r, c);
int rspan = cell.rowSpan();
int cspan = cell.columnSpan();
if (rspan != 1) {
int cr = cell.row();
if (cr != r)
return;
}
if (cspan != 1) {
int cc = cell.column();
if (cc != c)
return;
}
QTextFormat fmt = cell.format();
const QFixed leftPadding = td->leftPadding(fmt);
const QFixed topPadding = td->topPadding(fmt);
if (td->border != 0) {
const QBrush oldBrush = painter->brush();
const QPen oldPen = painter->pen();
const qreal border = td->border.toReal();
QRectF borderRect(cellRect.left() - border, cellRect.top() - border, cellRect.width() + border, cellRect.height() + border);
// invert the border style for cells
QTextFrameFormat::BorderStyle cellBorder = table->format().borderStyle();
switch (cellBorder) {
case QTextFrameFormat::BorderStyle_Inset:
cellBorder = QTextFrameFormat::BorderStyle_Outset;
break;
case QTextFrameFormat::BorderStyle_Outset:
cellBorder = QTextFrameFormat::BorderStyle_Inset;
break;
case QTextFrameFormat::BorderStyle_Groove:
cellBorder = QTextFrameFormat::BorderStyle_Ridge;
break;
case QTextFrameFormat::BorderStyle_Ridge:
cellBorder = QTextFrameFormat::BorderStyle_Groove;
break;
default:
break;
}
qreal topMargin = (td->effectiveTopMargin + td->cellSpacing + td->border).toReal();
qreal bottomMargin = (td->effectiveBottomMargin + td->cellSpacing + td->border).toReal();
const int headerRowCount = qMin(table->format().headerRowCount(), table->rows() - 1);
if (r >= headerRowCount)
topMargin += td->headerHeight.toReal();
drawBorder(painter, borderRect, topMargin, bottomMargin,
border, table->format().borderBrush(), cellBorder);
painter->setBrush(oldBrush);
painter->setPen(oldPen);
}
const QBrush bg = cell.format().background();
const QPointF brushOrigin = painter->brushOrigin();
if (bg.style() != Qt::NoBrush) {
fillBackground(painter, cellRect, bg, cellRect.topLeft());
if (bg.style() > Qt::SolidPattern)
painter->setBrushOrigin(cellRect.topLeft());
}
const QFixed verticalOffset = td->cellVerticalOffsets.at(c + r * table->columns());
const QPointF cellPos = QPointF(cellRect.left() + leftPadding.toReal(),
cellRect.top() + (topPadding + verticalOffset).toReal());
QTextBlock repaintBlock;
drawFlow(cellPos, painter, cell_context, cell.begin(),
td->childFrameMap.values(r + c * table->rows()),
&repaintBlock);
if (repaintBlock.isValid()) {
*cursorBlockNeedingRepaint = repaintBlock;
*cursorBlockOffset = cellPos;
}
if (bg.style() > Qt::SolidPattern)
painter->setBrushOrigin(brushOrigin);
}
void QTextDocumentLayoutPrivate::drawFlow(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context,
QTextFrame::Iterator it, const QList<QTextFrame *> &floats, QTextBlock *cursorBlockNeedingRepaint) const
{
Q_Q(const QTextDocumentLayout);
const bool inRootFrame = (!it.atEnd() && it.parentFrame() && it.parentFrame()->parentFrame() == 0);
QVector<QCheckPoint>::ConstIterator lastVisibleCheckPoint = checkPoints.end();
if (inRootFrame && context.clip.isValid()) {
lastVisibleCheckPoint = qLowerBound(checkPoints.begin(), checkPoints.end(), QFixed::fromReal(context.clip.bottom()));
}
QTextBlock previousBlock;
QTextFrame *previousFrame = 0;
for (; !it.atEnd(); ++it) {
QTextFrame *c = it.currentFrame();
if (inRootFrame && !checkPoints.isEmpty()) {
int currentPosInDoc;
if (c)
currentPosInDoc = c->firstPosition();
else
currentPosInDoc = it.currentBlock().position();
// if we're past what is already laid out then we're better off
// not trying to draw things that may not be positioned correctly yet
if (currentPosInDoc >= checkPoints.last().positionInFrame)
break;
if (lastVisibleCheckPoint != checkPoints.end()
&& context.clip.isValid()
&& currentPosInDoc >= lastVisibleCheckPoint->positionInFrame
)
break;
}
if (c)
drawFrame(offset, painter, context, c);
else {
QAbstractTextDocumentLayout::PaintContext pc = context;
if (isEmptyBlockAfterTable(it.currentBlock(), previousFrame))
pc.selections.clear();
drawBlock(offset, painter, pc, it.currentBlock(), inRootFrame);
}
// when entering a table and the previous block is empty
// then layoutFlow 'hides' the block that just causes a
// new line by positioning it /on/ the table border. as we
// draw that block before the table itself the decoration
// 'overpaints' the cursor and we need to paint it afterwards
// again
if (isEmptyBlockBeforeTable(previousBlock, previousBlock.blockFormat(), it)
&& previousBlock.contains(context.cursorPosition)
) {
*cursorBlockNeedingRepaint = previousBlock;
}
previousBlock = it.currentBlock();
previousFrame = c;
}
for (int i = 0; i < floats.count(); ++i) {
QTextFrame *frame = floats.at(i);
if (!isFrameFromInlineObject(frame)
|| frame->frameFormat().position() == QTextFrameFormat::InFlow)
continue;
const int pos = frame->firstPosition() - 1;
QTextCharFormat format = const_cast<QTextDocumentLayout *>(q)->format(pos);
QTextObjectInterface *handler = q->handlerForObject(format.objectType());
if (handler) {
QRectF rect = frameBoundingRectInternal(frame);
handler->drawObject(painter, rect, document, pos, format);
}
}
}
void QTextDocumentLayoutPrivate::drawBlock(const QPointF &offset, QPainter *painter,
const QAbstractTextDocumentLayout::PaintContext &context,
QTextBlock bl, bool inRootFrame) const
{
const QTextLayout *tl = bl.layout();
QRectF r = tl->boundingRect();
r.translate(offset + tl->position());
if (context.clip.isValid() && (r.bottom() < context.clip.y() || r.top() > context.clip.bottom()))
return;
// LDEBUG << debug_indent << "drawBlock" << bl.position() << "at" << offset << "br" << tl->boundingRect();
QTextBlockFormat blockFormat = bl.blockFormat();
QBrush bg = blockFormat.background();
if (bg != Qt::NoBrush) {
QRectF rect = r;
// extend the background rectangle if we're in the root frame with NoWrap,
// as the rect of the text block will then be only the width of the text
// instead of the full page width
if (inRootFrame && document->pageSize().width() <= 0) {
const QTextFrameData *fd = data(document->rootFrame());
rect.setRight((fd->size.width - fd->rightMargin).toReal());
}
fillBackground(painter, rect, bg, r.topLeft());
}
QVector<QTextLayout::FormatRange> selections;
int blpos = bl.position();
int bllen = bl.length();
const QTextCharFormat *selFormat = 0;
for (int i = 0; i < context.selections.size(); ++i) {
const QAbstractTextDocumentLayout::Selection &range = context.selections.at(i);
const int selStart = range.cursor.selectionStart() - blpos;
const int selEnd = range.cursor.selectionEnd() - blpos;
if (selStart < bllen && selEnd > 0
&& selEnd > selStart) {
QTextLayout::FormatRange o;
o.start = selStart;
o.length = selEnd - selStart;
o.format = range.format;
selections.append(o);
} else if (! range.cursor.hasSelection() && range.format.hasProperty(QTextFormat::FullWidthSelection)
&& bl.contains(range.cursor.position())) {
// for full width selections we don't require an actual selection, just
// a position to specify the line. that's more convenience in usage.
QTextLayout::FormatRange o;
QTextLine l = tl->lineForTextPosition(range.cursor.position() - blpos);
o.start = l.textStart();
o.length = l.textLength();
if (o.start + o.length == bllen - 1)
++o.length; // include newline
o.format = range.format;
selections.append(o);
}
if (selStart < 0 && selEnd >= 1)
selFormat = &range.format;
}
QTextObject *object = document->objectForFormat(bl.blockFormat());
if (object && object->format().toListFormat().style() != QTextListFormat::ListStyleUndefined)
drawListItem(offset, painter, context, bl, selFormat);
QPen oldPen = painter->pen();
painter->setPen(context.palette.color(QPalette::Text));
tl->draw(painter, offset, selections, context.clip.isValid() ? (context.clip & clipRect) : clipRect);
if ((context.cursorPosition >= blpos && context.cursorPosition < blpos + bllen)
|| (context.cursorPosition < -1 && !tl->preeditAreaText().isEmpty())) {
int cpos = context.cursorPosition;
if (cpos < -1)
cpos = tl->preeditAreaPosition() - (cpos + 2);
else
cpos -= blpos;
tl->drawCursor(painter, offset, cpos, cursorWidth);
}
if (blockFormat.hasProperty(QTextFormat::BlockTrailingHorizontalRulerWidth)) {
const qreal width = blockFormat.lengthProperty(QTextFormat::BlockTrailingHorizontalRulerWidth).value(r.width());
painter->setPen(context.palette.color(QPalette::Dark));
qreal y = r.bottom();
if (bl.length() == 1)
y = r.top() + r.height() / 2;
const qreal middleX = r.left() + r.width() / 2;
painter->drawLine(QLineF(middleX - width / 2, y, middleX + width / 2, y));
}
painter->setPen(oldPen);
}
void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *painter,
const QAbstractTextDocumentLayout::PaintContext &context,
QTextBlock bl, const QTextCharFormat *selectionFormat) const
{
Q_Q(const QTextDocumentLayout);
const QTextBlockFormat blockFormat = bl.blockFormat();
const QTextCharFormat charFormat = QTextCursor(bl).charFormat();
QFont font(charFormat.font());
if (q->paintDevice())
font = QFont(font, q->paintDevice());
const QFontMetrics fontMetrics(font);
QTextObject * const object = document->objectForFormat(blockFormat);
const QTextListFormat lf = object->format().toListFormat();
int style = lf.style();
QString itemText;
QSizeF size;
if (blockFormat.hasProperty(QTextFormat::ListStyle))
style = QTextListFormat::Style(blockFormat.intProperty(QTextFormat::ListStyle));
QTextLayout *layout = bl.layout();
if (layout->lineCount() == 0)
return;
QTextLine firstLine = layout->lineAt(0);
Q_ASSERT(firstLine.isValid());
QPointF pos = (offset + layout->position()).toPoint();
Qt::LayoutDirection dir = docPrivate->defaultTextOption.textDirection();
if (blockFormat.hasProperty(QTextFormat::LayoutDirection))
dir = blockFormat.layoutDirection();
{
QRectF textRect = firstLine.naturalTextRect();
pos += textRect.topLeft().toPoint();
if (dir == Qt::RightToLeft)
pos.rx() += textRect.width();
}
switch (style) {
case QTextListFormat::ListDecimal:
case QTextListFormat::ListLowerAlpha:
case QTextListFormat::ListUpperAlpha:
case QTextListFormat::ListLowerRoman:
case QTextListFormat::ListUpperRoman:
itemText = static_cast<QTextList *>(object)->itemText(bl);
size.setWidth(fontMetrics.width(itemText));
size.setHeight(fontMetrics.height());
break;
case QTextListFormat::ListSquare:
case QTextListFormat::ListCircle:
case QTextListFormat::ListDisc:
size.setWidth(fontMetrics.lineSpacing() / 3);
size.setHeight(size.width());
break;
case QTextListFormat::ListStyleUndefined:
return;
default: return;
}
QRectF r(pos, size);
qreal xoff = fontMetrics.width(QLatin1Char(' '));
if (dir == Qt::LeftToRight)
xoff = -xoff - size.width();
r.translate( xoff, (fontMetrics.height() / 2 - size.height() / 2));
painter->save();
painter->setRenderHint(QPainter::Antialiasing);
if (selectionFormat) {
painter->setPen(QPen(selectionFormat->foreground(), 0));
painter->fillRect(r, selectionFormat->background());
} else {
QBrush fg = charFormat.foreground();
if (fg == Qt::NoBrush)
fg = context.palette.text();
painter->setPen(QPen(fg, 0));
}
QBrush brush = context.palette.brush(QPalette::Text);
switch (style) {
case QTextListFormat::ListDecimal:
case QTextListFormat::ListLowerAlpha:
case QTextListFormat::ListUpperAlpha:
case QTextListFormat::ListLowerRoman:
case QTextListFormat::ListUpperRoman: {
QTextLayout layout(itemText, font, q->paintDevice());
layout.setCacheEnabled(true);
QTextOption option(Qt::AlignLeft | Qt::AlignAbsolute);
option.setTextDirection(dir);
layout.setTextOption(option);
layout.beginLayout();
QTextLine line = layout.createLine();
if (line.isValid())
line.setLeadingIncluded(true);
layout.endLayout();
layout.draw(painter, QPointF(r.left(), pos.y()));
break;
}
case QTextListFormat::ListSquare:
painter->fillRect(r, brush);
break;
case QTextListFormat::ListCircle:
painter->setPen(QPen(brush, 0));
painter->drawEllipse(r.translated(0.5, 0.5)); // pixel align for sharper rendering
break;
case QTextListFormat::ListDisc:
painter->setBrush(brush);
painter->setPen(Qt::NoPen);
painter->drawEllipse(r);
break;
case QTextListFormat::ListStyleUndefined:
break;
default:
break;
}
painter->restore();
}
static QFixed flowPosition(const QTextFrame::iterator it)
{
if (it.atEnd())
return 0;
if (it.currentFrame()) {
return data(it.currentFrame())->position.y;
} else {
QTextBlock block = it.currentBlock();
QTextLayout *layout = block.layout();
if (layout->lineCount() == 0)
return QFixed::fromReal(layout->position().y());
else
return QFixed::fromReal(layout->position().y() + layout->lineAt(0).y());
}
}
static QFixed firstChildPos(const QTextFrame *f)
{
return flowPosition(f->begin());
}
QLayoutStruct QTextDocumentLayoutPrivate::layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width,
int layoutFrom, int layoutTo, QTextTableData *td,
QFixed absoluteTableY, bool withPageBreaks)
{
LDEBUG << "layoutCell";
QLayoutStruct layoutStruct;
layoutStruct.frame = t;
layoutStruct.minimumWidth = 0;
layoutStruct.maximumWidth = QFIXED_MAX;
layoutStruct.y = 0;
const QTextFormat fmt = cell.format();
const QFixed topPadding = td->topPadding(fmt);
if (withPageBreaks) {
layoutStruct.frameY = absoluteTableY + td->rowPositions.at(cell.row()) + topPadding;
}
layoutStruct.x_left = 0;
layoutStruct.x_right = width;
// we get called with different widths all the time (for example for figuring
// out the min/max widths), so we always have to do the full layout ;(
// also when for example in a table layoutFrom/layoutTo affect only one cell,
// making that one cell grow the available width of the other cells may change
// (shrink) and therefore when layoutCell gets called for them they have to
// be re-laid out, even if layoutFrom/layoutTo is not in their range. Hence
// this line:
layoutStruct.pageHeight = QFixed::fromReal(document->pageSize().height());
if (layoutStruct.pageHeight < 0 || !withPageBreaks)
layoutStruct.pageHeight = QFIXED_MAX;
const int currentPage = layoutStruct.currentPage();
layoutStruct.pageTopMargin = td->effectiveTopMargin + td->cellSpacing + td->border + topPadding;
layoutStruct.pageBottomMargin = td->effectiveBottomMargin + td->cellSpacing + td->border + td->bottomPadding(fmt);
layoutStruct.pageBottom = (currentPage + 1) * layoutStruct.pageHeight - layoutStruct.pageBottomMargin;
layoutStruct.fullLayout = true;
QFixed pageTop = currentPage * layoutStruct.pageHeight + layoutStruct.pageTopMargin - layoutStruct.frameY;
layoutStruct.y = qMax(layoutStruct.y, pageTop);
const QList<QTextFrame *> childFrames = td->childFrameMap.values(cell.row() + cell.column() * t->rows());
for (int i = 0; i < childFrames.size(); ++i) {
QTextFrame *frame = childFrames.at(i);
QTextFrameData *cd = data(frame);
cd->sizeDirty = true;
}
layoutFlow(cell.begin(), &layoutStruct, layoutFrom, layoutTo, width);
QFixed floatMinWidth;
// floats that are located inside the text (like inline images) aren't taken into account by
// layoutFlow with regards to the cell height (layoutStruct->y), so for a safety measure we
// do that here. For example with <td><img align="right" src="..." />blah</td>
// when the image happens to be higher than the text
for (int i = 0; i < childFrames.size(); ++i) {
QTextFrame *frame = childFrames.at(i);
QTextFrameData *cd = data(frame);
if (frame->frameFormat().position() != QTextFrameFormat::InFlow)
layoutStruct.y = qMax(layoutStruct.y, cd->position.y + cd->size.height);
floatMinWidth = qMax(floatMinWidth, cd->minimumWidth);
}
// constraint the maximumWidth by the minimum width of the fixed size floats, to
// keep them visible
layoutStruct.maximumWidth = qMax(layoutStruct.maximumWidth, floatMinWidth);
// as floats in cells get added to the table's float list but must not affect
// floats in other cells we must clear the list here.
data(t)->floats.clear();
// qDebug() << "layoutCell done";
return layoutStruct;
}
QRectF QTextDocumentLayoutPrivate::layoutTable(QTextTable *table, int layoutFrom, int layoutTo, QFixed parentY)
{
LDEBUG << "layoutTable";
QTextTableData *td = static_cast<QTextTableData *>(data(table));
Q_ASSERT(td->sizeDirty);
const int rows = table->rows();
const int columns = table->columns();
const QTextTableFormat fmt = table->format();
td->childFrameMap.clear();
{
const QList<QTextFrame *> children = table->childFrames();
for (int i = 0; i < children.count(); ++i) {
QTextFrame *frame = children.at(i);
QTextTableCell cell = table->cellAt(frame->firstPosition());
td->childFrameMap.insertMulti(cell.row() + cell.column() * rows, frame);
}
}
QVector<QTextLength> columnWidthConstraints = fmt.columnWidthConstraints();
if (columnWidthConstraints.size() != columns)
columnWidthConstraints.resize(columns);
Q_ASSERT(columnWidthConstraints.count() == columns);
const QFixed cellSpacing = td->cellSpacing = QFixed::fromReal(scaleToDevice(fmt.cellSpacing()));
td->deviceScale = scaleToDevice(qreal(1));
td->cellPadding = QFixed::fromReal(scaleToDevice(fmt.cellPadding()));
const QFixed leftMargin = td->leftMargin + td->border + td->padding;
const QFixed rightMargin = td->rightMargin + td->border + td->padding;
const QFixed topMargin = td->topMargin + td->border + td->padding;
const QFixed absoluteTableY = parentY + td->position.y;
const QTextOption::WrapMode oldDefaultWrapMode = docPrivate->defaultTextOption.wrapMode();
recalc_minmax_widths:
QFixed remainingWidth = td->contentsWidth;
// two (vertical) borders per cell per column
remainingWidth -= columns * 2 * td->border;
// inter-cell spacing
remainingWidth -= (columns - 1) * cellSpacing;
// cell spacing at the left and right hand side
remainingWidth -= 2 * cellSpacing;
// remember the width used to distribute to percentaged columns
const QFixed initialTotalWidth = remainingWidth;
td->widths.resize(columns);
td->widths.fill(0);
td->minWidths.resize(columns);
// start with a minimum width of 0. totally empty
// cells of default created tables are invisible otherwise
// and therefore hardly editable
td->minWidths.fill(1);
td->maxWidths.resize(columns);
td->maxWidths.fill(QFIXED_MAX);
// calculate minimum and maximum sizes of the columns
for (int i = 0; i < columns; ++i) {
for (int row = 0; row < rows; ++row) {
const QTextTableCell cell = table->cellAt(row, i);
const int cspan = cell.columnSpan();
if (cspan > 1 && i != cell.column())
continue;
const QTextFormat fmt = cell.format();
const QFixed leftPadding = td->leftPadding(fmt);
const QFixed rightPadding = td->rightPadding(fmt);
const QFixed widthPadding = leftPadding + rightPadding;
// to figure out the min and the max width lay out the cell at
// maximum width. otherwise the maxwidth calculation sometimes
// returns wrong values
QLayoutStruct layoutStruct = layoutCell(table, cell, QFIXED_MAX, layoutFrom,
layoutTo, td, absoluteTableY,
/*withPageBreaks =*/false);
// distribute the minimum width over all columns the cell spans
QFixed widthToDistribute = layoutStruct.minimumWidth + widthPadding;
for (int n = 0; n < cspan; ++n) {
const int col = i + n;
QFixed w = widthToDistribute / (cspan - n);
td->minWidths[col] = qMax(td->minWidths.at(col), w);
widthToDistribute -= td->minWidths.at(col);
if (widthToDistribute <= 0)
break;
}
QFixed maxW = td->maxWidths.at(i);
if (layoutStruct.maximumWidth != QFIXED_MAX) {
if (maxW == QFIXED_MAX)
maxW = layoutStruct.maximumWidth + widthPadding;
else
maxW = qMax(maxW, layoutStruct.maximumWidth + widthPadding);
}
if (maxW == QFIXED_MAX)
continue;
widthToDistribute = maxW;
for (int n = 0; n < cspan; ++n) {
const int col = i + n;
QFixed w = widthToDistribute / (cspan - n);
td->maxWidths[col] = qMax(td->minWidths.at(col), w);
widthToDistribute -= td->maxWidths.at(col);
if (widthToDistribute <= 0)
break;
}
}
}
// set fixed values, figure out total percentages used and number of
// variable length cells. Also assign the minimum width for variable columns.
QFixed totalPercentage;
int variableCols = 0;
QFixed totalMinWidth = 0;
for (int i = 0; i < columns; ++i) {
const QTextLength &length = columnWidthConstraints.at(i);
if (length.type() == QTextLength::FixedLength) {
td->minWidths[i] = td->widths[i] = qMax(scaleToDevice(QFixed::fromReal(length.rawValue())), td->minWidths.at(i));
remainingWidth -= td->widths.at(i);
} else if (length.type() == QTextLength::PercentageLength) {
totalPercentage += QFixed::fromReal(length.rawValue());
} else if (length.type() == QTextLength::VariableLength) {
variableCols++;
td->widths[i] = td->minWidths.at(i);
remainingWidth -= td->minWidths.at(i);
}
totalMinWidth += td->minWidths.at(i);
}
// set percentage values
{
const QFixed totalPercentagedWidth = initialTotalWidth * totalPercentage / 100;
QFixed remainingMinWidths = totalMinWidth;
for (int i = 0; i < columns; ++i) {
remainingMinWidths -= td->minWidths.at(i);
if (columnWidthConstraints.at(i).type() == QTextLength::PercentageLength) {
const QFixed allottedPercentage = QFixed::fromReal(columnWidthConstraints.at(i).rawValue());
const QFixed percentWidth = totalPercentagedWidth * allottedPercentage / totalPercentage;
if (percentWidth >= td->minWidths.at(i)) {
td->widths[i] = qBound(td->minWidths.at(i), percentWidth, remainingWidth - remainingMinWidths);
} else {
td->widths[i] = td->minWidths.at(i);
}
remainingWidth -= td->widths.at(i);
}
}
}
// for variable columns distribute the remaining space
if (variableCols > 0 && remainingWidth > 0) {
QVarLengthArray<int> columnsWithProperMaxSize;
for (int i = 0; i < columns; ++i)
if (columnWidthConstraints.at(i).type() == QTextLength::VariableLength
&& td->maxWidths.at(i) != QFIXED_MAX)
columnsWithProperMaxSize.append(i);
QFixed lastRemainingWidth = remainingWidth;
while (remainingWidth > 0) {
for (int k = 0; k < columnsWithProperMaxSize.count(); ++k) {
const int col = columnsWithProperMaxSize[k];
const int colsLeft = columnsWithProperMaxSize.count() - k;
const QFixed w = qMin(td->maxWidths.at(col) - td->widths.at(col), remainingWidth / colsLeft);
td->widths[col] += w;
remainingWidth -= w;
}
if (remainingWidth == lastRemainingWidth)
break;
lastRemainingWidth = remainingWidth;
}
if (remainingWidth > 0
// don't unnecessarily grow variable length sized tables
&& fmt.width().type() != QTextLength::VariableLength) {
const QFixed widthPerAnySizedCol = remainingWidth / variableCols;
for (int col = 0; col < columns; ++col) {
if (columnWidthConstraints.at(col).type() == QTextLength::VariableLength)
td->widths[col] += widthPerAnySizedCol;
}
}
}
td->columnPositions.resize(columns);
td->columnPositions[0] = leftMargin /*includes table border*/ + cellSpacing + td->border;
for (int i = 1; i < columns; ++i)
td->columnPositions[i] = td->columnPositions.at(i-1) + td->widths.at(i-1) + 2 * td->border + cellSpacing;
// - margin to compensate the + margin in columnPositions[0]
const QFixed contentsWidth = td->columnPositions.last() + td->widths.last() + td->padding + td->border + cellSpacing - leftMargin;
// if the table is too big and causes an overflow re-do the layout with WrapAnywhere as wrap
// mode
if (docPrivate->defaultTextOption.wrapMode() == QTextOption::WrapAtWordBoundaryOrAnywhere
&& contentsWidth > td->contentsWidth) {
docPrivate->defaultTextOption.setWrapMode(QTextOption::WrapAnywhere);
// go back to the top of the function
goto recalc_minmax_widths;
}
td->contentsWidth = contentsWidth;
docPrivate->defaultTextOption.setWrapMode(oldDefaultWrapMode);
td->heights.resize(rows);
td->heights.fill(0);
td->rowPositions.resize(rows);
td->rowPositions[0] = topMargin /*includes table border*/ + cellSpacing + td->border;
bool haveRowSpannedCells = false;
// need to keep track of cell heights for vertical alignment
QVector<QFixed> cellHeights;
cellHeights.reserve(rows * columns);
QFixed pageHeight = QFixed::fromReal(document->pageSize().height());
if (pageHeight <= 0)
pageHeight = QFIXED_MAX;
QVector<QFixed> heightToDistribute;
heightToDistribute.resize(columns);
td->headerHeight = 0;
const int headerRowCount = qMin(table->format().headerRowCount(), rows - 1);
const QFixed originalTopMargin = td->effectiveTopMargin;
bool hasDroppedTable = false;
// now that we have the column widths we can lay out all cells with the right width.
// spanning cells are only allowed to grow the last row spanned by the cell.
//
// ### this could be made faster by iterating over the cells array of QTextTable
for (int r = 0; r < rows; ++r) {
td->calcRowPosition(r);
const int tableStartPage = (absoluteTableY / pageHeight).truncate();
const int currentPage = ((td->rowPositions[r] + absoluteTableY) / pageHeight).truncate();
const QFixed pageBottom = (currentPage + 1) * pageHeight - td->effectiveBottomMargin - absoluteTableY - cellSpacing - td->border;
const QFixed pageTop = currentPage * pageHeight + td->effectiveTopMargin - absoluteTableY + cellSpacing + td->border;
const QFixed nextPageTop = pageTop + pageHeight;
if (td->rowPositions[r] > pageBottom)
td->rowPositions[r] = nextPageTop;
else if (td->rowPositions[r] < pageTop)
td->rowPositions[r] = pageTop;
bool dropRowToNextPage = true;
int cellCountBeforeRow = cellHeights.size();
// if we drop the row to the next page we need to subtract the drop
// distance from any row spanning cells
QFixed dropDistance = 0;
relayout:
const int rowStartPage = ((td->rowPositions[r] + absoluteTableY) / pageHeight).truncate();
// if any of the header rows or the first non-header row start on the next page
// then the entire header should be dropped
if (r <= headerRowCount && rowStartPage > tableStartPage && !hasDroppedTable) {
td->rowPositions[0] = nextPageTop;
cellHeights.clear();
td->effectiveTopMargin = originalTopMargin;
hasDroppedTable = true;
r = -1;
continue;
}
int rowCellCount = 0;
for (int c = 0; c < columns; ++c) {
QTextTableCell cell = table->cellAt(r, c);
const int rspan = cell.rowSpan();
const int cspan = cell.columnSpan();
if (cspan > 1 && cell.column() != c)
continue;
if (rspan > 1) {
haveRowSpannedCells = true;
const int cellRow = cell.row();
if (cellRow != r) {
// the last row gets all the remaining space
if (cellRow + rspan - 1 == r)
td->heights[r] = qMax(td->heights.at(r), heightToDistribute.at(c) - dropDistance);
continue;
}
}
const QTextFormat fmt = cell.format();
const QFixed topPadding = td->topPadding(fmt);
const QFixed bottomPadding = td->bottomPadding(fmt);
const QFixed leftPadding = td->leftPadding(fmt);
const QFixed rightPadding = td->rightPadding(fmt);
const QFixed widthPadding = leftPadding + rightPadding;
++rowCellCount;
const QFixed width = td->cellWidth(c, cspan) - widthPadding;
QLayoutStruct layoutStruct = layoutCell(table, cell, width,
layoutFrom, layoutTo,
td, absoluteTableY,
/*withPageBreaks =*/true);
const QFixed height = layoutStruct.y + bottomPadding + topPadding;
if (rspan > 1)
heightToDistribute[c] = height + dropDistance;
else
td->heights[r] = qMax(td->heights.at(r), height);
cellHeights.append(layoutStruct.y);
QFixed childPos = td->rowPositions.at(r) + topPadding + flowPosition(cell.begin());
if (childPos < pageBottom)
dropRowToNextPage = false;
}
if (rowCellCount > 0 && dropRowToNextPage) {
dropDistance = nextPageTop - td->rowPositions[r];
td->rowPositions[r] = nextPageTop;
td->heights[r] = 0;
dropRowToNextPage = false;
cellHeights.resize(cellCountBeforeRow);
if (r > headerRowCount)
td->heights[r-1] = pageBottom - td->rowPositions[r-1];
goto relayout;
}
if (haveRowSpannedCells) {
const QFixed effectiveHeight = td->heights.at(r) + td->border + cellSpacing + td->border;
for (int c = 0; c < columns; ++c)
heightToDistribute[c] = qMax(heightToDistribute.at(c) - effectiveHeight - dropDistance, QFixed(0));
}
if (r == headerRowCount - 1) {
td->headerHeight = td->rowPositions[r] + td->heights[r] - td->rowPositions[0] + td->cellSpacing + 2 * td->border;
td->headerHeight -= td->headerHeight * (td->headerHeight / pageHeight).truncate();
td->effectiveTopMargin += td->headerHeight;
}
}
td->effectiveTopMargin = originalTopMargin;
// now that all cells have been properly laid out, we can compute the
// vertical offsets for vertical alignment
td->cellVerticalOffsets.resize(rows * columns);
int cellIndex = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < columns; ++c) {
QTextTableCell cell = table->cellAt(r, c);
if (cell.row() != r || cell.column() != c)
continue;
const int rowSpan = cell.rowSpan();
const QFixed availableHeight = td->rowPositions.at(r + rowSpan - 1) + td->heights.at(r + rowSpan - 1) - td->rowPositions.at(r);
const QTextCharFormat cellFormat = cell.format();
const QFixed cellHeight = cellHeights.at(cellIndex++) + td->topPadding(cellFormat) + td->bottomPadding(cellFormat);
QFixed offset = 0;
switch (cellFormat.verticalAlignment()) {
case QTextCharFormat::AlignMiddle:
offset = (availableHeight - cellHeight) / 2;
break;
case QTextCharFormat::AlignBottom:
offset = availableHeight - cellHeight;
break;
default:
break;
};
for (int rd = 0; rd < cell.rowSpan(); ++rd) {
for (int cd = 0; cd < cell.columnSpan(); ++cd) {
const int index = (c + cd) + (r + rd) * columns;
td->cellVerticalOffsets[index] = offset;
}
}
}
}
td->minimumWidth = td->columnPositions.at(0);
for (int i = 0; i < columns; ++i) {
td->minimumWidth += td->minWidths.at(i) + 2 * td->border + cellSpacing;
}
td->minimumWidth += rightMargin - td->border;
td->maximumWidth = td->columnPositions.at(0);
for (int i = 0; i < columns; ++i)
if (td->maxWidths.at(i) != QFIXED_MAX)
td->maximumWidth += td->maxWidths.at(i) + 2 * td->border + cellSpacing;
td->maximumWidth += rightMargin - td->border;
td->updateTableSize();
td->sizeDirty = false;
return QRectF(); // invalid rect -> update everything
}
void QTextDocumentLayoutPrivate::positionFloat(QTextFrame *frame, QTextLine *currentLine)
{
QTextFrameData *fd = data(frame);
QTextFrame *parent = frame->parentFrame();
Q_ASSERT(parent);
QTextFrameData *pd = data(parent);
Q_ASSERT(pd && pd->currentLayoutStruct);
QLayoutStruct *layoutStruct = pd->currentLayoutStruct;
if (!pd->floats.contains(frame))
pd->floats.append(frame);
fd->layoutDirty = true;
Q_ASSERT(!fd->sizeDirty);
// qDebug() << "positionFloat:" << frame << "width=" << fd->size.width;
QFixed y = layoutStruct->y;
if (currentLine) {
QFixed left, right;
floatMargins(y, layoutStruct, &left, &right);
// qDebug() << "have line: right=" << right << "left=" << left << "textWidth=" << currentLine->width();
if (right - left < QFixed::fromReal(currentLine->naturalTextWidth()) + fd->size.width) {
layoutStruct->pendingFloats.append(frame);
// qDebug() << " adding to pending list";
return;
}
}
bool frameSpansIntoNextPage = (y + layoutStruct->frameY + fd->size.height > layoutStruct->pageBottom);
if (frameSpansIntoNextPage && fd->size.height <= layoutStruct->pageHeight) {
layoutStruct->newPage();
y = layoutStruct->y;
frameSpansIntoNextPage = false;
}
y = findY(y, layoutStruct, fd->size.width);
QFixed left, right;
floatMargins(y, layoutStruct, &left, &right);
if (frame->frameFormat().position() == QTextFrameFormat::FloatLeft) {
fd->position.x = left;
fd->position.y = y;
} else {
fd->position.x = right - fd->size.width;
fd->position.y = y;
}
layoutStruct->minimumWidth = qMax(layoutStruct->minimumWidth, fd->minimumWidth);
layoutStruct->maximumWidth = qMin(layoutStruct->maximumWidth, fd->maximumWidth);
// qDebug()<< "float positioned at " << fd->position.x << fd->position.y;
fd->layoutDirty = false;
// If the frame is a table, then positioning it will affect the size if it covers more than
// one page, because of page breaks and repeating the header.
if (qobject_cast<QTextTable *>(frame) != 0)
fd->sizeDirty = frameSpansIntoNextPage;
}
QRectF QTextDocumentLayoutPrivate::layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed parentY)
{
LDEBUG << "layoutFrame (pre)";
Q_ASSERT(data(f)->sizeDirty);
// qDebug("layouting frame (%d--%d), parent=%p", f->firstPosition(), f->lastPosition(), f->parentFrame());
QTextFrameFormat fformat = f->frameFormat();
QTextFrame *parent = f->parentFrame();
const QTextFrameData *pd = parent ? data(parent) : 0;
const qreal maximumWidth = qMax(qreal(0), pd ? pd->contentsWidth.toReal() : document->pageSize().width());
QFixed width = QFixed::fromReal(fformat.width().value(maximumWidth));
if (fformat.width().type() == QTextLength::FixedLength)
width = scaleToDevice(width);
const QFixed maximumHeight = pd ? pd->contentsHeight : -1;
const QFixed height = (maximumHeight != -1 || fformat.height().type() != QTextLength::PercentageLength)
? QFixed::fromReal(fformat.height().value(maximumHeight.toReal()))
: -1;
return layoutFrame(f, layoutFrom, layoutTo, width, height, parentY);
}
QRectF QTextDocumentLayoutPrivate::layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed frameWidth, QFixed frameHeight, QFixed parentY)
{
LDEBUG << "layoutFrame from=" << layoutFrom << "to=" << layoutTo;
Q_ASSERT(data(f)->sizeDirty);
// qDebug("layouting frame (%d--%d), parent=%p", f->firstPosition(), f->lastPosition(), f->parentFrame());
QTextFrameData *fd = data(f);
QFixed newContentsWidth;
{
QTextFrameFormat fformat = f->frameFormat();
// set sizes of this frame from the format
fd->topMargin = QFixed::fromReal(fformat.topMargin());
fd->bottomMargin = QFixed::fromReal(fformat.bottomMargin());
fd->leftMargin = QFixed::fromReal(fformat.leftMargin());
fd->rightMargin = QFixed::fromReal(fformat.rightMargin());
fd->border = QFixed::fromReal(fformat.border());
fd->padding = QFixed::fromReal(fformat.padding());
QTextFrame *parent = f->parentFrame();
const QTextFrameData *pd = parent ? data(parent) : 0;
// accumulate top and bottom margins
if (parent) {
fd->effectiveTopMargin = pd->effectiveTopMargin + fd->topMargin + fd->border + fd->padding;
fd->effectiveBottomMargin = pd->effectiveBottomMargin + fd->topMargin + fd->border + fd->padding;
if (qobject_cast<QTextTable *>(parent)) {
const QTextTableData *td = static_cast<const QTextTableData *>(pd);
fd->effectiveTopMargin += td->cellSpacing + td->border + td->cellPadding;
fd->effectiveBottomMargin += td->cellSpacing + td->border + td->cellPadding;
}
} else {
fd->effectiveTopMargin = fd->topMargin + fd->border + fd->padding;
fd->effectiveBottomMargin = fd->bottomMargin + fd->border + fd->padding;
}
newContentsWidth = frameWidth - 2*(fd->border + fd->padding)
- fd->leftMargin - fd->rightMargin;
if (frameHeight != -1) {
fd->contentsHeight = frameHeight - 2*(fd->border + fd->padding)
- fd->topMargin - fd->bottomMargin;
} else {
fd->contentsHeight = frameHeight;
}
}
if (isFrameFromInlineObject(f)) {
// never reached, handled in resizeInlineObject/positionFloat instead
return QRectF();
}
if (QTextTable *table = qobject_cast<QTextTable *>(f)) {
fd->contentsWidth = newContentsWidth;
return layoutTable(table, layoutFrom, layoutTo, parentY);
}
// set fd->contentsWidth temporarily, so that layoutFrame for the children
// picks the right width. We'll initialize it properly at the end of this
// function.
fd->contentsWidth = newContentsWidth;
QLayoutStruct layoutStruct;
layoutStruct.frame = f;
layoutStruct.x_left = fd->leftMargin + fd->border + fd->padding;
layoutStruct.x_right = layoutStruct.x_left + newContentsWidth;
layoutStruct.y = fd->topMargin + fd->border + fd->padding;
layoutStruct.frameY = parentY + fd->position.y;
layoutStruct.contentsWidth = 0;
layoutStruct.minimumWidth = 0;
layoutStruct.maximumWidth = QFIXED_MAX;
layoutStruct.fullLayout = fd->oldContentsWidth != newContentsWidth;
layoutStruct.updateRect = QRectF(QPointF(0, 0), QSizeF(qreal(INT_MAX), qreal(INT_MAX)));
LDEBUG << "layoutStruct: x_left" << layoutStruct.x_left << "x_right" << layoutStruct.x_right
<< "fullLayout" << layoutStruct.fullLayout;
fd->oldContentsWidth = newContentsWidth;
layoutStruct.pageHeight = QFixed::fromReal(document->pageSize().height());
if (layoutStruct.pageHeight < 0)
layoutStruct.pageHeight = QFIXED_MAX;
const int currentPage = layoutStruct.pageHeight == 0 ? 0 : (layoutStruct.frameY / layoutStruct.pageHeight).truncate();
layoutStruct.pageTopMargin = fd->effectiveTopMargin;
layoutStruct.pageBottomMargin = fd->effectiveBottomMargin;
layoutStruct.pageBottom = (currentPage + 1) * layoutStruct.pageHeight - layoutStruct.pageBottomMargin;
if (!f->parentFrame())
idealWidth = 0; // reset
QTextFrame::Iterator it = f->begin();
layoutFlow(it, &layoutStruct, layoutFrom, layoutTo);
QFixed maxChildFrameWidth = 0;
QList<QTextFrame *> children = f->childFrames();
for (int i = 0; i < children.size(); ++i) {
QTextFrame *c = children.at(i);
QTextFrameData *cd = data(c);
maxChildFrameWidth = qMax(maxChildFrameWidth, cd->size.width);
}
const QFixed marginWidth = 2*(fd->border + fd->padding) + fd->leftMargin + fd->rightMargin;
if (!f->parentFrame()) {
idealWidth = qMax(maxChildFrameWidth, layoutStruct.contentsWidth).toReal();
idealWidth += marginWidth.toReal();
}
QFixed actualWidth = qMax(newContentsWidth, qMax(maxChildFrameWidth, layoutStruct.contentsWidth));
fd->contentsWidth = actualWidth;
if (newContentsWidth <= 0) { // nowrap layout?
fd->contentsWidth = newContentsWidth;
}
fd->minimumWidth = layoutStruct.minimumWidth;
fd->maximumWidth = layoutStruct.maximumWidth;
fd->size.height = fd->contentsHeight == -1
? layoutStruct.y + fd->border + fd->padding + fd->bottomMargin
: fd->contentsHeight + 2*(fd->border + fd->padding) + fd->topMargin + fd->bottomMargin;
fd->size.width = actualWidth + marginWidth;
fd->sizeDirty = false;
if (layoutStruct.updateRectForFloats.isValid())
layoutStruct.updateRect |= layoutStruct.updateRectForFloats;
return layoutStruct.updateRect;
}
void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QLayoutStruct *layoutStruct,
int layoutFrom, int layoutTo, QFixed width)
{
LDEBUG << "layoutFlow from=" << layoutFrom << "to=" << layoutTo;
QTextFrameData *fd = data(layoutStruct->frame);
fd->currentLayoutStruct = layoutStruct;
QTextFrame::Iterator previousIt;
const bool inRootFrame = (it.parentFrame() == document->rootFrame());
if (inRootFrame) {
bool redoCheckPoints = layoutStruct->fullLayout || checkPoints.isEmpty();
if (!redoCheckPoints) {
QVector<QCheckPoint>::Iterator checkPoint = qLowerBound(checkPoints.begin(), checkPoints.end(), layoutFrom);
if (checkPoint != checkPoints.end()) {
if (checkPoint != checkPoints.begin())
--checkPoint;
layoutStruct->y = checkPoint->y;
layoutStruct->frameY = checkPoint->frameY;
layoutStruct->minimumWidth = checkPoint->minimumWidth;
layoutStruct->maximumWidth = checkPoint->maximumWidth;
layoutStruct->contentsWidth = checkPoint->contentsWidth;
if (layoutStruct->pageHeight > 0) {
int page = layoutStruct->currentPage();
layoutStruct->pageBottom = (page + 1) * layoutStruct->pageHeight - layoutStruct->pageBottomMargin;
}
it = frameIteratorForTextPosition(checkPoint->positionInFrame);
checkPoints.resize(checkPoint - checkPoints.begin() + 1);
if (checkPoint != checkPoints.begin()) {
previousIt = it;
--previousIt;
}
} else {
redoCheckPoints = true;
}
}
if (redoCheckPoints) {
checkPoints.clear();
QCheckPoint cp;
cp.y = layoutStruct->y;
cp.frameY = layoutStruct->frameY;
cp.positionInFrame = 0;
cp.minimumWidth = layoutStruct->minimumWidth;
cp.maximumWidth = layoutStruct->maximumWidth;
cp.contentsWidth = layoutStruct->contentsWidth;
checkPoints.append(cp);
}
}
QTextBlockFormat previousBlockFormat = previousIt.currentBlock().blockFormat();
QFixed maximumBlockWidth = 0;
while (!it.atEnd()) {
QTextFrame *c = it.currentFrame();
int docPos;
if (it.currentFrame())
docPos = it.currentFrame()->firstPosition();
else
docPos = it.currentBlock().position();
if (inRootFrame) {
if (qAbs(layoutStruct->y - checkPoints.last().y) > 2000) {
QFixed left, right;
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
if (left == layoutStruct->x_left && right == layoutStruct->x_right) {
QCheckPoint p;
p.y = layoutStruct->y;
p.frameY = layoutStruct->frameY;
p.positionInFrame = docPos;
p.minimumWidth = layoutStruct->minimumWidth;
p.maximumWidth = layoutStruct->maximumWidth;
p.contentsWidth = layoutStruct->contentsWidth;
checkPoints.append(p);
if (currentLazyLayoutPosition != -1
&& docPos > currentLazyLayoutPosition + lazyLayoutStepSize)
break;
}
}
}
if (c) {
// position child frame
QTextFrameData *cd = data(c);
QTextFrameFormat fformat = c->frameFormat();
if (fformat.position() == QTextFrameFormat::InFlow) {
if (fformat.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysBefore)
layoutStruct->newPage();
QFixed left, right;
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
left = qMax(left, layoutStruct->x_left);
right = qMin(right, layoutStruct->x_right);
if (right - left < cd->size.width) {
layoutStruct->y = findY(layoutStruct->y, layoutStruct, cd->size.width);
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
}
QFixedPoint pos(left, layoutStruct->y);
Qt::Alignment align = Qt::AlignLeft;
QTextTable *table = qobject_cast<QTextTable *>(c);
if (table)
align = table->format().alignment() & Qt::AlignHorizontal_Mask;
// detect whether we have any alignment in the document that disallows optimizations,
// such as not laying out the document again in a textedit with wrapping disabled.
if (inRootFrame && !(align & Qt::AlignLeft))
contentHasAlignment = true;
cd->position = pos;
if (document->pageSize().height() > 0.0f)
cd->sizeDirty = true;
if (cd->sizeDirty) {
if (width != 0)
layoutFrame(c, layoutFrom, layoutTo, width, -1, layoutStruct->frameY);
else
layoutFrame(c, layoutFrom, layoutTo, layoutStruct->frameY);
QFixed absoluteChildPos = table ? pos.y + static_cast<QTextTableData *>(data(table))->rowPositions.at(0) : pos.y + firstChildPos(c);
absoluteChildPos += layoutStruct->frameY;
// drop entire frame to next page if first child of frame is on next page
if (absoluteChildPos > layoutStruct->pageBottom) {
layoutStruct->newPage();
pos.y = layoutStruct->y;
cd->position = pos;
cd->sizeDirty = true;
if (width != 0)
layoutFrame(c, layoutFrom, layoutTo, width, -1, layoutStruct->frameY);
else
layoutFrame(c, layoutFrom, layoutTo, layoutStruct->frameY);
}
}
// align only if there is space for alignment
if (right - left > cd->size.width) {
if (align & Qt::AlignRight)
pos.x += layoutStruct->x_right - cd->size.width;
else if (align & Qt::AlignHCenter)
pos.x += (layoutStruct->x_right - cd->size.width) / 2;
}
cd->position = pos;
layoutStruct->y += cd->size.height;
const int page = layoutStruct->currentPage();
layoutStruct->pageBottom = (page + 1) * layoutStruct->pageHeight - layoutStruct->pageBottomMargin;
cd->layoutDirty = false;
if (c->frameFormat().pageBreakPolicy() & QTextFormat::PageBreak_AlwaysAfter)
layoutStruct->newPage();
} else {
QRectF oldFrameRect(cd->position.toPointF(), cd->size.toSizeF());
QRectF updateRect;
if (cd->sizeDirty)
updateRect = layoutFrame(c, layoutFrom, layoutTo);
positionFloat(c);
// If the size was made dirty when the position was set, layout again
if (cd->sizeDirty)
updateRect = layoutFrame(c, layoutFrom, layoutTo);
QRectF frameRect(cd->position.toPointF(), cd->size.toSizeF());
if (frameRect == oldFrameRect && updateRect.isValid())
updateRect.translate(cd->position.toPointF());
else
updateRect = frameRect;
layoutStruct->addUpdateRectForFloat(updateRect);
if (oldFrameRect.isValid())
layoutStruct->addUpdateRectForFloat(oldFrameRect);
}
layoutStruct->minimumWidth = qMax(layoutStruct->minimumWidth, cd->minimumWidth);
layoutStruct->maximumWidth = qMin(layoutStruct->maximumWidth, cd->maximumWidth);
previousIt = it;
++it;
} else {
QTextFrame::Iterator lastIt;
if (!previousIt.atEnd())
lastIt = previousIt;
previousIt = it;
QTextBlock block = it.currentBlock();
++it;
const QTextBlockFormat blockFormat = block.blockFormat();
if (blockFormat.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysBefore)
layoutStruct->newPage();
const QFixed origY = layoutStruct->y;
const QFixed origPageBottom = layoutStruct->pageBottom;
const QFixed origMaximumWidth = layoutStruct->maximumWidth;
layoutStruct->maximumWidth = 0;
const QTextBlockFormat *previousBlockFormatPtr = 0;
if (lastIt.currentBlock().isValid())
previousBlockFormatPtr = &previousBlockFormat;
// layout and position child block
layoutBlock(block, docPos, blockFormat, layoutStruct, layoutFrom, layoutTo, previousBlockFormatPtr);
// detect whether we have any alignment in the document that disallows optimizations,
// such as not laying out the document again in a textedit with wrapping disabled.
if (inRootFrame && !(block.layout()->textOption().alignment() & Qt::AlignLeft))
contentHasAlignment = true;
// if the block right before a table is empty 'hide' it by
// positioning it into the table border
if (isEmptyBlockBeforeTable(block, blockFormat, it)) {
const QTextBlock lastBlock = lastIt.currentBlock();
const qreal lastBlockBottomMargin = lastBlock.isValid() ? lastBlock.blockFormat().bottomMargin() : 0.0f;
layoutStruct->y = origY + QFixed::fromReal(qMax(lastBlockBottomMargin, block.blockFormat().topMargin()));
layoutStruct->pageBottom = origPageBottom;
} else {
// if the block right after a table is empty then 'hide' it, too
if (isEmptyBlockAfterTable(block, lastIt.currentFrame())) {
QTextTableData *td = static_cast<QTextTableData *>(data(lastIt.currentFrame()));
QTextLayout *layout = block.layout();
QPointF pos((td->position.x + td->size.width).toReal(),
(td->position.y + td->size.height).toReal() - layout->boundingRect().height());
layout->setPosition(pos);
layoutStruct->y = origY;
layoutStruct->pageBottom = origPageBottom;
}
// if the block right after a table starts with a line separator, shift it up by one line
if (isLineSeparatorBlockAfterTable(block, lastIt.currentFrame())) {
QTextTableData *td = static_cast<QTextTableData *>(data(lastIt.currentFrame()));
QTextLayout *layout = block.layout();
QFixed height = QFixed::fromReal(layout->lineAt(0).height());
if (layoutStruct->pageBottom == origPageBottom) {
layoutStruct->y -= height;
layout->setPosition(layout->position() - QPointF(0, height.toReal()));
} else {
// relayout block to correctly handle page breaks
layoutStruct->y = origY - height;
layoutStruct->pageBottom = origPageBottom;
layoutBlock(block, docPos, blockFormat, layoutStruct, layoutFrom, layoutTo, previousBlockFormatPtr);
}
QPointF linePos((td->position.x + td->size.width).toReal(),
(td->position.y + td->size.height - height).toReal());
layout->lineAt(0).setPosition(linePos - layout->position());
}
if (blockFormat.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysAfter)
layoutStruct->newPage();
}
maximumBlockWidth = qMax(maximumBlockWidth, layoutStruct->maximumWidth);
layoutStruct->maximumWidth = origMaximumWidth;
previousBlockFormat = blockFormat;
}
}
if (layoutStruct->maximumWidth == QFIXED_MAX && maximumBlockWidth > 0)
layoutStruct->maximumWidth = maximumBlockWidth;
else
layoutStruct->maximumWidth = qMax(layoutStruct->maximumWidth, maximumBlockWidth);
// a float at the bottom of a frame may make it taller, hence the qMax() for layoutStruct->y.
// we don't need to do it for tables though because floats in tables are per table
// and not per cell and layoutCell already takes care of doing the same as we do here
if (!qobject_cast<QTextTable *>(layoutStruct->frame)) {
QList<QTextFrame *> children = layoutStruct->frame->childFrames();
for (int i = 0; i < children.count(); ++i) {
QTextFrameData *fd = data(children.at(i));
if (!fd->layoutDirty && children.at(i)->frameFormat().position() != QTextFrameFormat::InFlow)
layoutStruct->y = qMax(layoutStruct->y, fd->position.y + fd->size.height);
}
}
if (inRootFrame) {
// we assume that any float is aligned in a way that disallows the optimizations that rely
// on unaligned content.
if (!fd->floats.isEmpty())
contentHasAlignment = true;
if (it.atEnd()) {
//qDebug() << "layout done!";
currentLazyLayoutPosition = -1;
QCheckPoint cp;
cp.y = layoutStruct->y;
cp.positionInFrame = docPrivate->length();
cp.minimumWidth = layoutStruct->minimumWidth;
cp.maximumWidth = layoutStruct->maximumWidth;
cp.contentsWidth = layoutStruct->contentsWidth;
checkPoints.append(cp);
checkPoints.reserve(checkPoints.size());
} else {
currentLazyLayoutPosition = checkPoints.last().positionInFrame;
// #######
//checkPoints.last().positionInFrame = q->document()->docHandle()->length();
}
}
fd->currentLayoutStruct = 0;
}
void QTextDocumentLayoutPrivate::layoutBlock(const QTextBlock &bl, int blockPosition, const QTextBlockFormat &blockFormat,
QLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat)
{
Q_Q(QTextDocumentLayout);
QTextLayout *tl = bl.layout();
const int blockLength = bl.length();
LDEBUG << "layoutBlock from=" << layoutFrom << "to=" << layoutTo;
// qDebug() << "layoutBlock; width" << layoutStruct->x_right - layoutStruct->x_left << "(maxWidth is btw" << tl->maximumWidth() << ')';
if (previousBlockFormat) {
qreal margin = qMax(blockFormat.topMargin(), previousBlockFormat->bottomMargin());
if (margin > 0 && q->paintDevice()) {
margin *= qreal(q->paintDevice()->logicalDpiY()) / qreal(qt_defaultDpi());
}
layoutStruct->y += QFixed::fromReal(margin);
}
//QTextFrameData *fd = data(layoutStruct->frame);
Qt::LayoutDirection dir = docPrivate->defaultTextOption.textDirection();
if (blockFormat.hasProperty(QTextFormat::LayoutDirection))
dir = blockFormat.layoutDirection();
QFixed extraMargin;
if (docPrivate->defaultTextOption.flags() & QTextOption::AddSpaceForLineAndParagraphSeparators) {
QFontMetricsF fm(bl.charFormat().font());
extraMargin = QFixed::fromReal(fm.width(QChar(QChar(0x21B5))));
}
const QFixed indent = this->blockIndent(blockFormat);
const QFixed totalLeftMargin = QFixed::fromReal(blockFormat.leftMargin()) + (dir == Qt::RightToLeft ? extraMargin : indent);
const QFixed totalRightMargin = QFixed::fromReal(blockFormat.rightMargin()) + (dir == Qt::RightToLeft ? indent : extraMargin);
const QPointF oldPosition = tl->position();
tl->setPosition(QPointF(layoutStruct->x_left.toReal(), layoutStruct->y.toReal()));
if (layoutStruct->fullLayout
|| (blockPosition + blockLength > layoutFrom && blockPosition <= layoutTo)
// force relayout if we cross a page boundary
|| (layoutStruct->pageHeight != QFIXED_MAX && layoutStruct->absoluteY() + QFixed::fromReal(tl->boundingRect().height()) > layoutStruct->pageBottom)) {
LDEBUG << " do layout";
QTextOption option = docPrivate->defaultTextOption;
option.setTextDirection(dir);
option.setTabs( blockFormat.tabPositions() );
Qt::Alignment align = docPrivate->defaultTextOption.alignment();
if (blockFormat.hasProperty(QTextFormat::BlockAlignment))
align = blockFormat.alignment();
option.setAlignment(QStyle::visualAlignment(dir, align)); // for paragraph that are RTL, alignment is auto-reversed;
if (blockFormat.nonBreakableLines() || document->pageSize().width() < 0) {
option.setWrapMode(QTextOption::ManualWrap);
}
tl->setTextOption(option);
const bool haveWordOrAnyWrapMode = (option.wrapMode() == QTextOption::WrapAtWordBoundaryOrAnywhere);
// qDebug() << " layouting block at" << bl.position();
const QFixed cy = layoutStruct->y;
const QFixed l = layoutStruct->x_left + totalLeftMargin;
const QFixed r = layoutStruct->x_right - totalRightMargin;
tl->beginLayout();
bool firstLine = true;
while (1) {
QTextLine line = tl->createLine();
if (!line.isValid())
break;
line.setLeadingIncluded(true);
QFixed left, right;
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
left = qMax(left, l);
right = qMin(right, r);
QFixed text_indent;
if (firstLine) {
text_indent = QFixed::fromReal(blockFormat.textIndent());
if (dir == Qt::LeftToRight)
left += text_indent;
else
right -= text_indent;
firstLine = false;
}
// qDebug() << "layout line y=" << currentYPos << "left=" << left << "right=" <<right;
if (fixedColumnWidth != -1)
line.setNumColumns(fixedColumnWidth, (right - left).toReal());
else
line.setLineWidth((right - left).toReal());
// qDebug() << "layoutBlock; layouting line with width" << right - left << "->textWidth" << line.textWidth();
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
left = qMax(left, l);
right = qMin(right, r);
if (dir == Qt::LeftToRight)
left += text_indent;
else
right -= text_indent;
if (fixedColumnWidth == -1 && QFixed::fromReal(line.naturalTextWidth()) > right-left) {
// float has been added in the meantime, redo
layoutStruct->pendingFloats.clear();
line.setLineWidth((right-left).toReal());
if (QFixed::fromReal(line.naturalTextWidth()) > right-left) {
if (haveWordOrAnyWrapMode) {
option.setWrapMode(QTextOption::WrapAnywhere);
tl->setTextOption(option);
}
layoutStruct->pendingFloats.clear();
// lines min width more than what we have
layoutStruct->y = findY(layoutStruct->y, layoutStruct, QFixed::fromReal(line.naturalTextWidth()));
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
left = qMax(left, l);
right = qMin(right, r);
if (dir == Qt::LeftToRight)
left += text_indent;
else
right -= text_indent;
line.setLineWidth(qMax<qreal>(line.naturalTextWidth(), (right-left).toReal()));
if (haveWordOrAnyWrapMode) {
option.setWrapMode(QTextOption::WordWrap);
tl->setTextOption(option);
}
}
}
QFixed lineHeight = QFixed::fromReal(line.height());
if (layoutStruct->pageHeight > 0 && layoutStruct->absoluteY() + lineHeight > layoutStruct->pageBottom) {
layoutStruct->newPage();
floatMargins(layoutStruct->y, layoutStruct, &left, &right);
left = qMax(left, l);
right = qMin(right, r);
if (dir == Qt::LeftToRight)
left += text_indent;
else
right -= text_indent;
}
line.setPosition(QPointF((left - layoutStruct->x_left).toReal(), (layoutStruct->y - cy).toReal()));
layoutStruct->y += lineHeight;
layoutStruct->contentsWidth
= qMax<QFixed>(layoutStruct->contentsWidth, QFixed::fromReal(line.x() + line.naturalTextWidth()) + totalRightMargin);
// position floats
for (int i = 0; i < layoutStruct->pendingFloats.size(); ++i) {
QTextFrame *f = layoutStruct->pendingFloats.at(i);
positionFloat(f);
}
layoutStruct->pendingFloats.clear();
}
tl->endLayout();
} else {
const int cnt = tl->lineCount();
for (int i = 0; i < cnt; ++i) {
LDEBUG << "going to move text line" << i;
QTextLine line = tl->lineAt(i);
layoutStruct->contentsWidth
= qMax(layoutStruct->contentsWidth, QFixed::fromReal(line.x() + tl->lineAt(i).naturalTextWidth()) + totalRightMargin);
const QFixed lineHeight = QFixed::fromReal(line.height());
if (layoutStruct->pageHeight != QFIXED_MAX) {
if (layoutStruct->absoluteY() + lineHeight > layoutStruct->pageBottom)
layoutStruct->newPage();
line.setPosition(QPointF(line.position().x(), layoutStruct->y.toReal() - tl->position().y()));
}
layoutStruct->y += lineHeight;
}
if (layoutStruct->updateRect.isValid()
&& blockLength > 1) {
if (layoutFrom >= blockPosition + blockLength) {
// if our height didn't change and the change in the document is
// in one of the later paragraphs, then we don't need to repaint
// this one
layoutStruct->updateRect.setTop(qMax(layoutStruct->updateRect.top(), layoutStruct->y.toReal()));
} else if (layoutTo < blockPosition) {
if (oldPosition == tl->position())
// if the change in the document happened earlier in the document
// and our position did /not/ change because none of the earlier paragraphs
// or frames changed their height, then we don't need to repaint
// this one
layoutStruct->updateRect.setBottom(qMin(layoutStruct->updateRect.bottom(), tl->position().y()));
else
layoutStruct->updateRect.setBottom(qreal(INT_MAX)); // reset
}
}
}
// ### doesn't take floats into account. would need to do it per line. but how to retrieve then? (Simon)
const QFixed margins = totalLeftMargin + totalRightMargin;
layoutStruct->minimumWidth = qMax(layoutStruct->minimumWidth, QFixed::fromReal(tl->minimumWidth()) + margins);
const QFixed maxW = QFixed::fromReal(tl->maximumWidth()) + margins;
if (maxW > 0) {
if (layoutStruct->maximumWidth == QFIXED_MAX)
layoutStruct->maximumWidth = maxW;
else
layoutStruct->maximumWidth = qMax(layoutStruct->maximumWidth, maxW);
}
}
void QTextDocumentLayoutPrivate::floatMargins(const QFixed &y, const QLayoutStruct *layoutStruct,
QFixed *left, QFixed *right) const
{
// qDebug() << "floatMargins y=" << y;
*left = layoutStruct->x_left;
*right = layoutStruct->x_right;
QTextFrameData *lfd = data(layoutStruct->frame);
for (int i = 0; i < lfd->floats.size(); ++i) {
QTextFrameData *fd = data(lfd->floats.at(i));
if (!fd->layoutDirty) {
if (fd->position.y <= y && fd->position.y + fd->size.height > y) {
// qDebug() << "adjusting with float" << f << fd->position.x()<< fd->size.width();
if (lfd->floats.at(i)->frameFormat().position() == QTextFrameFormat::FloatLeft)
*left = qMax(*left, fd->position.x + fd->size.width);
else
*right = qMin(*right, fd->position.x);
}
}
}
// qDebug() << "floatMargins: left="<<*left<<"right="<<*right<<"y="<<y;
}
QFixed QTextDocumentLayoutPrivate::findY(QFixed yFrom, const QLayoutStruct *layoutStruct, QFixed requiredWidth) const
{
QFixed right, left;
requiredWidth = qMin(requiredWidth, layoutStruct->x_right - layoutStruct->x_left);
// qDebug() << "findY:" << yFrom;
while (1) {
floatMargins(yFrom, layoutStruct, &left, &right);
// qDebug() << " yFrom=" << yFrom<<"right=" << right << "left=" << left << "requiredWidth=" << requiredWidth;
if (right-left >= requiredWidth)
break;
// move float down until we find enough space
QFixed newY = QFIXED_MAX;
QTextFrameData *lfd = data(layoutStruct->frame);
for (int i = 0; i < lfd->floats.size(); ++i) {
QTextFrameData *fd = data(lfd->floats.at(i));
if (!fd->layoutDirty) {
if (fd->position.y <= yFrom && fd->position.y + fd->size.height > yFrom)
newY = qMin(newY, fd->position.y + fd->size.height);
}
}
if (newY == QFIXED_MAX)
break;
yFrom = newY;
}
return yFrom;
}
QTextDocumentLayout::QTextDocumentLayout(QTextDocument *doc)
: QAbstractTextDocumentLayout(*new QTextDocumentLayoutPrivate, doc)
{
registerHandler(QTextFormat::ImageObject, new QTextImageHandler(this));
}
void QTextDocumentLayout::draw(QPainter *painter, const PaintContext &context)
{
Q_D(QTextDocumentLayout);
QTextFrame *frame = d->document->rootFrame();
QTextFrameData *fd = data(frame);
if(fd->sizeDirty)
return;
if (context.clip.isValid()) {
d->ensureLayouted(QFixed::fromReal(context.clip.bottom()));
} else {
d->ensureLayoutFinished();
}
QFixed width = fd->size.width;
if (d->document->pageSize().width() == 0 && d->viewportRect.isValid()) {
// we're in NoWrap mode, meaning the frame should expand to the viewport
// so that backgrounds are drawn correctly
fd->size.width = qMax(width, QFixed::fromReal(d->viewportRect.right()));
}
// Make sure we conform to the root frames bounds when drawing.
d->clipRect = QRectF(fd->position.toPointF(), fd->size.toSizeF()).adjusted(fd->leftMargin.toReal(), 0, -fd->rightMargin.toReal(), 0);
d->drawFrame(QPointF(), painter, context, frame);
fd->size.width = width;
}
void QTextDocumentLayout::setViewport(const QRectF &viewport)
{
Q_D(QTextDocumentLayout);
d->viewportRect = viewport;
}
static void markFrames(QTextFrame *current, int from, int oldLength, int length)
{
int end = qMax(oldLength, length) + from;
if (current->firstPosition() >= end || current->lastPosition() < from)
return;
QTextFrameData *fd = data(current);
for (int i = 0; i < fd->floats.size(); ++i) {
QTextFrame *f = fd->floats[i];
if (!f) {
// float got removed in editing operation
fd->floats.removeAt(i);
--i;
}
}
fd->layoutDirty = true;
fd->sizeDirty = true;
// qDebug(" marking frame (%d--%d) as dirty", current->firstPosition(), current->lastPosition());
QList<QTextFrame *> children = current->childFrames();
for (int i = 0; i < children.size(); ++i)
markFrames(children.at(i), from, oldLength, length);
}
void QTextDocumentLayout::documentChanged(int from, int oldLength, int length)
{
Q_D(QTextDocumentLayout);
QTextBlock blockIt = document()->findBlock(from);
QTextBlock endIt = document()->findBlock(qMax(0, from + length - 1));
if (endIt.isValid())
endIt = endIt.next();
for (; blockIt.isValid() && blockIt != endIt; blockIt = blockIt.next())
blockIt.clearLayout();
if (d->docPrivate->pageSize.isNull())
return;
QRectF updateRect;
d->lazyLayoutStepSize = 1000;
d->sizeChangedTimer.stop();
d->insideDocumentChange = true;
const int documentLength = d->docPrivate->length();
const bool fullLayout = (oldLength == 0 && length == documentLength);
const bool smallChange = documentLength > 0
&& (qMax(length, oldLength) * 100 / documentLength) < 5;
// don't show incremental layout progress (avoid scroll bar flicker)
// if we see only a small change in the document and we're either starting
// a layout run or we're already in progress for that and we haven't seen
// any bigger change previously (showLayoutProgress already false)
if (smallChange
&& (d->currentLazyLayoutPosition == -1 || d->showLayoutProgress == false))
d->showLayoutProgress = false;
else
d->showLayoutProgress = true;
if (fullLayout) {
d->contentHasAlignment = false;
d->currentLazyLayoutPosition = 0;
d->checkPoints.clear();
d->layoutStep();
} else {
d->ensureLayoutedByPosition(from);
updateRect = doLayout(from, oldLength, length);
}
if (!d->layoutTimer.isActive() && d->currentLazyLayoutPosition != -1)
d->layoutTimer.start(10, this);
d->insideDocumentChange = false;
if (d->showLayoutProgress) {
const QSizeF newSize = dynamicDocumentSize();
if (newSize != d->lastReportedSize) {
d->lastReportedSize = newSize;
emit documentSizeChanged(newSize);
}
}
if (!updateRect.isValid()) {
// don't use the frame size, it might have shrunken
updateRect = QRectF(QPointF(0, 0), QSizeF(qreal(INT_MAX), qreal(INT_MAX)));
}
emit update(updateRect);
}
QRectF QTextDocumentLayout::doLayout(int from, int oldLength, int length)
{
Q_D(QTextDocumentLayout);
// qDebug("documentChange: from=%d, oldLength=%d, length=%d", from, oldLength, length);
// mark all frames between f_start and f_end as dirty
markFrames(d->docPrivate->rootFrame(), from, oldLength, length);
QRectF updateRect;
QTextFrame *root = d->docPrivate->rootFrame();
if(data(root)->sizeDirty)
updateRect = d->layoutFrame(root, from, from + length);
data(root)->layoutDirty = false;
if (d->currentLazyLayoutPosition == -1)
layoutFinished();
else if (d->showLayoutProgress)
d->sizeChangedTimer.start(0, this);
return updateRect;
}
int QTextDocumentLayout::hitTest(const QPointF &point, Qt::HitTestAccuracy accuracy) const
{
Q_D(const QTextDocumentLayout);
d->ensureLayouted(QFixed::fromReal(point.y()));
QTextFrame *f = d->docPrivate->rootFrame();
int position = 0;
QTextLayout *l = 0;
QFixedPoint pointf;
pointf.x = QFixed::fromReal(point.x());
pointf.y = QFixed::fromReal(point.y());
QTextDocumentLayoutPrivate::HitPoint p = d->hitTest(f, pointf, &position, &l, accuracy);
if (accuracy == Qt::ExactHit && p < QTextDocumentLayoutPrivate::PointExact)
return -1;
// ensure we stay within document bounds
int lastPos = f->lastPosition();
if (l && !l->preeditAreaText().isEmpty())
lastPos += l->preeditAreaText().length();
if (position > lastPos)
position = lastPos;
else if (position < 0)
position = 0;
return position;
}
void QTextDocumentLayout::resizeInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat &format)
{
Q_D(QTextDocumentLayout);
QTextCharFormat f = format.toCharFormat();
Q_ASSERT(f.isValid());
QTextObjectHandler handler = d->handlers.value(f.objectType());
if (!handler.component)
return;
QSizeF intrinsic = handler.iface->intrinsicSize(d->document, posInDocument, format);
QTextFrameFormat::Position pos = QTextFrameFormat::InFlow;
QTextFrame *frame = qobject_cast<QTextFrame *>(d->document->objectForFormat(f));
if (frame) {
pos = frame->frameFormat().position();
QTextFrameData *fd = data(frame);
fd->sizeDirty = false;
fd->size = QFixedSize::fromSizeF(intrinsic);
fd->minimumWidth = fd->maximumWidth = fd->size.width;
}
QSizeF inlineSize = (pos == QTextFrameFormat::InFlow ? intrinsic : QSizeF(0, 0));
item.setWidth(inlineSize.width());
if (f.verticalAlignment() == QTextCharFormat::AlignMiddle) {
item.setDescent(inlineSize.height() / 2);
item.setAscent(inlineSize.height() / 2 - 1);
} else {
item.setDescent(0);
item.setAscent(inlineSize.height() - 1);
}
}
void QTextDocumentLayout::positionInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat &format)
{
Q_D(QTextDocumentLayout);
Q_UNUSED(posInDocument);
if (item.width() != 0)
// inline
return;
QTextCharFormat f = format.toCharFormat();
Q_ASSERT(f.isValid());
QTextObjectHandler handler = d->handlers.value(f.objectType());
if (!handler.component)
return;
QTextFrame *frame = qobject_cast<QTextFrame *>(d->document->objectForFormat(f));
if (!frame)
return;
QTextBlock b = d->document->findBlock(frame->firstPosition());
QTextLine line;
if (b.position() <= frame->firstPosition() && b.position() + b.length() > frame->lastPosition())
line = b.layout()->lineAt(b.layout()->lineCount()-1);
// qDebug() << "layoutObject: line.isValid" << line.isValid() << b.position() << b.length() <<
// frame->firstPosition() << frame->lastPosition();
d->positionFloat(frame, line.isValid() ? &line : 0);
}
void QTextDocumentLayout::drawInlineObject(QPainter *p, const QRectF &rect, QTextInlineObject item,
int posInDocument, const QTextFormat &format)
{
Q_D(QTextDocumentLayout);
QTextCharFormat f = format.toCharFormat();
Q_ASSERT(f.isValid());
QTextFrame *frame = qobject_cast<QTextFrame *>(d->document->objectForFormat(f));
if (frame && frame->frameFormat().position() != QTextFrameFormat::InFlow)
return; // don't draw floating frames from inline objects here but in drawFlow instead
// qDebug() << "drawObject at" << r;
QAbstractTextDocumentLayout::drawInlineObject(p, rect, item, posInDocument, format);
}
int QTextDocumentLayout::dynamicPageCount() const
{
Q_D(const QTextDocumentLayout);
const QSizeF pgSize = d->document->pageSize();
if (pgSize.height() < 0)
return 1;
return qCeil(dynamicDocumentSize().height() / pgSize.height());
}
QSizeF QTextDocumentLayout::dynamicDocumentSize() const
{
Q_D(const QTextDocumentLayout);
return data(d->docPrivate->rootFrame())->size.toSizeF();
}
int QTextDocumentLayout::pageCount() const
{
Q_D(const QTextDocumentLayout);
d->ensureLayoutFinished();
return dynamicPageCount();
}
QSizeF QTextDocumentLayout::documentSize() const
{
Q_D(const QTextDocumentLayout);
d->ensureLayoutFinished();
return dynamicDocumentSize();
}
void QTextDocumentLayoutPrivate::ensureLayouted(QFixed y) const
{
Q_Q(const QTextDocumentLayout);
if (currentLazyLayoutPosition == -1)
return;
const QSizeF oldSize = q->dynamicDocumentSize();
if (checkPoints.isEmpty())
layoutStep();
while (currentLazyLayoutPosition != -1
&& checkPoints.last().y < y)
layoutStep();
}
void QTextDocumentLayoutPrivate::ensureLayoutedByPosition(int position) const
{
if (currentLazyLayoutPosition == -1)
return;
if (position < currentLazyLayoutPosition)
return;
while (currentLazyLayoutPosition != -1
&& currentLazyLayoutPosition < position) {
const_cast<QTextDocumentLayout *>(q_func())->doLayout(currentLazyLayoutPosition, 0, INT_MAX - currentLazyLayoutPosition);
}
}
void QTextDocumentLayoutPrivate::layoutStep() const
{
ensureLayoutedByPosition(currentLazyLayoutPosition + lazyLayoutStepSize);
lazyLayoutStepSize = qMin(200000, lazyLayoutStepSize * 2);
}
void QTextDocumentLayout::setCursorWidth(int width)
{
Q_D(QTextDocumentLayout);
d->cursorWidth = width;
}
int QTextDocumentLayout::cursorWidth() const
{
Q_D(const QTextDocumentLayout);
return d->cursorWidth;
}
void QTextDocumentLayout::setFixedColumnWidth(int width)
{
Q_D(QTextDocumentLayout);
d->fixedColumnWidth = width;
}
QRectF QTextDocumentLayout::frameBoundingRect(QTextFrame *frame) const
{
Q_D(const QTextDocumentLayout);
if (d->docPrivate->pageSize.isNull())
return QRectF();
d->ensureLayoutFinished();
return d->frameBoundingRectInternal(frame);
}
QRectF QTextDocumentLayoutPrivate::frameBoundingRectInternal(QTextFrame *frame) const
{
QPointF pos;
const int framePos = frame->firstPosition();
QTextFrame *f = frame;
while (f) {
QTextFrameData *fd = data(f);
pos += fd->position.toPointF();
if (QTextTable *table = qobject_cast<QTextTable *>(f)) {
QTextTableCell cell = table->cellAt(framePos);
if (cell.isValid())
pos += static_cast<QTextTableData *>(fd)->cellPosition(cell).toPointF();
}
f = f->parentFrame();
}
return QRectF(pos, data(frame)->size.toSizeF());
}
QRectF QTextDocumentLayout::blockBoundingRect(const QTextBlock &block) const
{
Q_D(const QTextDocumentLayout);
if (d->docPrivate->pageSize.isNull())
return QRectF();
d->ensureLayoutedByPosition(block.position() + block.length());
QTextFrame *frame = d->document->frameAt(block.position());
QPointF offset;
const int blockPos = block.position();
while (frame) {
QTextFrameData *fd = data(frame);
offset += fd->position.toPointF();
if (QTextTable *table = qobject_cast<QTextTable *>(frame)) {
QTextTableCell cell = table->cellAt(blockPos);
if (cell.isValid())
offset += static_cast<QTextTableData *>(fd)->cellPosition(cell).toPointF();
}
frame = frame->parentFrame();
}
const QTextLayout *layout = block.layout();
QRectF rect = layout->boundingRect();
rect.moveTopLeft(layout->position() + offset);
return rect;
}
int QTextDocumentLayout::layoutStatus() const
{
Q_D(const QTextDocumentLayout);
int pos = d->currentLazyLayoutPosition;
if (pos == -1)
return 100;
return pos * 100 / d->document->docHandle()->length();
}
void QTextDocumentLayout::timerEvent(QTimerEvent *e)
{
Q_D(QTextDocumentLayout);
if (e->timerId() == d->layoutTimer.timerId()) {
if (d->currentLazyLayoutPosition != -1)
d->layoutStep();
} else if (e->timerId() == d->sizeChangedTimer.timerId()) {
d->lastReportedSize = dynamicDocumentSize();
emit documentSizeChanged(d->lastReportedSize);
d->sizeChangedTimer.stop();
if (d->currentLazyLayoutPosition == -1) {
const int newCount = dynamicPageCount();
if (newCount != d->lastPageCount) {
d->lastPageCount = newCount;
emit pageCountChanged(newCount);
}
}
} else {
QAbstractTextDocumentLayout::timerEvent(e);
}
}
void QTextDocumentLayout::layoutFinished()
{
Q_D(QTextDocumentLayout);
d->layoutTimer.stop();
if (!d->insideDocumentChange)
d->sizeChangedTimer.start(0, this);
// reset
d->showLayoutProgress = true;
}
void QTextDocumentLayout::ensureLayouted(qreal y)
{
d_func()->ensureLayouted(QFixed::fromReal(y));
}
qreal QTextDocumentLayout::idealWidth() const
{
Q_D(const QTextDocumentLayout);
d->ensureLayoutFinished();
return d->idealWidth;
}
bool QTextDocumentLayout::contentHasAlignment() const
{
Q_D(const QTextDocumentLayout);
return d->contentHasAlignment;
}
qreal QTextDocumentLayoutPrivate::scaleToDevice(qreal value) const
{
if (!paintDevice)
return value;
return value * paintDevice->logicalDpiY() / qreal(qt_defaultDpi());
}
QFixed QTextDocumentLayoutPrivate::scaleToDevice(QFixed value) const
{
if (!paintDevice)
return value;
return value * QFixed(paintDevice->logicalDpiY()) / QFixed(qt_defaultDpi());
}
QT_END_NAMESPACE
#include "moc_qtextdocumentlayout_p.cpp"