1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the QtGui module of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | #include "qtextdocumentlayout_p.h" |
41 | #include "qtextdocument_p.h" |
42 | #include "qtextimagehandler_p.h" |
43 | #include "qtexttable.h" |
44 | #include "qtextlist.h" |
45 | #include "qtextengine_p.h" |
46 | #include "private/qcssutil_p.h" |
47 | #include "private/qguiapplication_p.h" |
48 | |
49 | #include "qabstracttextdocumentlayout_p.h" |
50 | #include "qcssparser_p.h" |
51 | |
52 | #include <qpainter.h> |
53 | #include <qmath.h> |
54 | #include <qrect.h> |
55 | #include <qpalette.h> |
56 | #include <qdebug.h> |
57 | #include <qvarlengtharray.h> |
58 | #include <limits.h> |
59 | #include <qbasictimer.h> |
60 | #include "private/qfunctions_p.h" |
61 | #include <qloggingcategory.h> |
62 | |
63 | #include <algorithm> |
64 | |
65 | QT_BEGIN_NAMESPACE |
66 | |
67 | Q_LOGGING_CATEGORY(lcDraw, "qt.text.drawing" ) |
68 | Q_LOGGING_CATEGORY(lcHit, "qt.text.hittest" ) |
69 | Q_LOGGING_CATEGORY(lcLayout, "qt.text.layout" ) |
70 | Q_LOGGING_CATEGORY(lcTable, "qt.text.layout.table" ) |
71 | |
72 | // ################ should probably add frameFormatChange notification! |
73 | |
74 | struct QTextLayoutStruct; |
75 | |
76 | class QTextFrameData : public QTextFrameLayoutData |
77 | { |
78 | public: |
79 | QTextFrameData(); |
80 | |
81 | // relative to parent frame |
82 | QFixedPoint position; |
83 | QFixedSize size; |
84 | |
85 | // contents starts at (margin+border/margin+border) |
86 | QFixed topMargin; |
87 | QFixed bottomMargin; |
88 | QFixed leftMargin; |
89 | QFixed rightMargin; |
90 | QFixed border; |
91 | QFixed padding; |
92 | // contents width includes padding (as we need to treat this on a per cell basis for tables) |
93 | QFixed contentsWidth; |
94 | QFixed contentsHeight; |
95 | QFixed oldContentsWidth; |
96 | |
97 | // accumulated margins |
98 | QFixed effectiveTopMargin; |
99 | QFixed effectiveBottomMargin; |
100 | |
101 | QFixed minimumWidth; |
102 | QFixed maximumWidth; |
103 | |
104 | QTextLayoutStruct *currentLayoutStruct; |
105 | |
106 | bool sizeDirty; |
107 | bool layoutDirty; |
108 | |
109 | QVector<QPointer<QTextFrame> > floats; |
110 | }; |
111 | |
112 | QTextFrameData::QTextFrameData() |
113 | : maximumWidth(QFIXED_MAX), |
114 | currentLayoutStruct(nullptr), sizeDirty(true), layoutDirty(true) |
115 | { |
116 | } |
117 | |
118 | struct QTextLayoutStruct { |
119 | QTextLayoutStruct() : maximumWidth(QFIXED_MAX), fullLayout(false) |
120 | {} |
121 | QTextFrame *frame; |
122 | QFixed x_left; |
123 | QFixed x_right; |
124 | QFixed frameY; // absolute y position of the current frame |
125 | QFixed y; // always relative to the current frame |
126 | QFixed contentsWidth; |
127 | QFixed minimumWidth; |
128 | QFixed maximumWidth; |
129 | bool fullLayout; |
130 | QList<QTextFrame *> pendingFloats; |
131 | QFixed pageHeight; |
132 | QFixed pageBottom; |
133 | QFixed pageTopMargin; |
134 | QFixed pageBottomMargin; |
135 | QRectF updateRect; |
136 | QRectF updateRectForFloats; |
137 | |
138 | inline void addUpdateRectForFloat(const QRectF &rect) { |
139 | if (updateRectForFloats.isValid()) |
140 | updateRectForFloats |= rect; |
141 | else |
142 | updateRectForFloats = rect; |
143 | } |
144 | |
145 | inline QFixed absoluteY() const |
146 | { return frameY + y; } |
147 | |
148 | inline QFixed contentHeight() const |
149 | { return pageHeight - pageBottomMargin - pageTopMargin; } |
150 | |
151 | inline int currentPage() const |
152 | { return pageHeight == 0 ? 0 : (absoluteY() / pageHeight).truncate(); } |
153 | |
154 | inline void newPage() |
155 | { if (pageHeight == QFIXED_MAX) return; pageBottom += pageHeight; y = qMax(a: y, b: pageBottom - pageHeight + pageBottomMargin + pageTopMargin - frameY); } |
156 | }; |
157 | |
158 | #ifndef QT_NO_CSSPARSER |
159 | // helper struct to collect edge data and priorize edges for border-collapse mode |
160 | struct EdgeData { |
161 | |
162 | enum EdgeClass { |
163 | // don't change order, used for comparison |
164 | ClassInvalid, // queried (adjacent) cell does not exist |
165 | ClassNone, // no explicit border, no grid, no table border |
166 | ClassGrid, // 1px grid if drawGrid is true |
167 | ClassTableBorder, // an outermost edge |
168 | ClassExplicit // set in cell's format |
169 | }; |
170 | |
171 | EdgeData(qreal width, const QTextTableCell &cell, QCss::Edge edge, EdgeClass edgeClass) : |
172 | width(width), cell(cell), edge(edge), edgeClass(edgeClass) {} |
173 | EdgeData() : |
174 | width(0), edge(QCss::NumEdges), edgeClass(ClassInvalid) {} |
175 | |
176 | // used for priorization with qMax |
177 | bool operator< (const EdgeData &other) const { |
178 | if (width < other.width) return true; |
179 | if (width > other.width) return false; |
180 | if (edgeClass < other.edgeClass) return true; |
181 | if (edgeClass > other.edgeClass) return false; |
182 | if (edge == QCss::TopEdge && other.edge == QCss::BottomEdge) return true; |
183 | if (edge == QCss::BottomEdge && other.edge == QCss::TopEdge) return false; |
184 | if (edge == QCss::LeftEdge && other.edge == QCss::RightEdge) return true; |
185 | return false; |
186 | } |
187 | bool operator> (const EdgeData &other) const { |
188 | return other < *this; |
189 | } |
190 | |
191 | qreal width; |
192 | QTextTableCell cell; |
193 | QCss::Edge edge; |
194 | EdgeClass edgeClass; |
195 | }; |
196 | |
197 | // axisEdgeData is referenced by QTextTableData's inline methods, so predeclare |
198 | class QTextTableData; |
199 | static inline EdgeData axisEdgeData(QTextTable *table, const QTextTableData *td, const QTextTableCell &cell, QCss::Edge edge); |
200 | #endif |
201 | |
202 | class QTextTableData : public QTextFrameData |
203 | { |
204 | public: |
205 | QFixed cellSpacing, cellPadding; |
206 | qreal deviceScale; |
207 | QVector<QFixed> minWidths; |
208 | QVector<QFixed> maxWidths; |
209 | QVector<QFixed> widths; |
210 | QVector<QFixed> heights; |
211 | QVector<QFixed> columnPositions; |
212 | QVector<QFixed> rowPositions; |
213 | |
214 | QVector<QFixed> cellVerticalOffsets; |
215 | |
216 | // without borderCollapse, those equal QTextFrameData::border; |
217 | // otherwise the widest outermost cell edge will be used |
218 | QFixed effectiveLeftBorder; |
219 | QFixed effectiveTopBorder; |
220 | QFixed effectiveRightBorder; |
221 | QFixed effectiveBottomBorder; |
222 | |
223 | QFixed ; |
224 | |
225 | QFixed borderCell; // 0 if borderCollapse is enabled, QTextFrameData::border otherwise |
226 | bool borderCollapse; |
227 | bool drawGrid; |
228 | |
229 | // maps from cell index (row + col * rowCount) to child frames belonging to |
230 | // the specific cell |
231 | QMultiHash<int, QTextFrame *> childFrameMap; |
232 | |
233 | inline QFixed cellWidth(int column, int colspan) const |
234 | { return columnPositions.at(i: column + colspan - 1) + widths.at(i: column + colspan - 1) |
235 | - columnPositions.at(i: column); } |
236 | |
237 | inline void calcRowPosition(int row) |
238 | { |
239 | if (row > 0) |
240 | rowPositions[row] = rowPositions.at(i: row - 1) + heights.at(i: row - 1) + borderCell + cellSpacing + borderCell; |
241 | } |
242 | |
243 | QRectF cellRect(const QTextTableCell &cell) const; |
244 | |
245 | inline QFixed paddingProperty(const QTextFormat &format, QTextFormat::Property property) const |
246 | { |
247 | QVariant v = format.property(propertyId: property); |
248 | if (v.isNull()) { |
249 | return cellPadding; |
250 | } else { |
251 | Q_ASSERT(v.userType() == QMetaType::Double || v.userType() == QMetaType::Float); |
252 | return QFixed::fromReal(r: v.toReal() * deviceScale); |
253 | } |
254 | } |
255 | |
256 | #ifndef QT_NO_CSSPARSER |
257 | inline QFixed cellBorderWidth(QTextTable *table, const QTextTableCell &cell, QCss::Edge edge) const |
258 | { |
259 | qreal rv = axisEdgeData(table, td: this, cell, edge).width; |
260 | if (borderCollapse) |
261 | rv /= 2; // each cell has to add half of the border's width to its own padding |
262 | return QFixed::fromReal(r: rv * deviceScale); |
263 | } |
264 | #endif |
265 | |
266 | inline QFixed topPadding(QTextTable *table, const QTextTableCell &cell) const |
267 | { |
268 | #ifdef QT_NO_CSSPARSER |
269 | Q_UNUSED(table); |
270 | #endif |
271 | return paddingProperty(format: cell.format(), property: QTextFormat::TableCellTopPadding) |
272 | #ifndef QT_NO_CSSPARSER |
273 | + cellBorderWidth(table, cell, edge: QCss::TopEdge) |
274 | #endif |
275 | ; |
276 | } |
277 | |
278 | inline QFixed bottomPadding(QTextTable *table, const QTextTableCell &cell) const |
279 | { |
280 | #ifdef QT_NO_CSSPARSER |
281 | Q_UNUSED(table); |
282 | #endif |
283 | return paddingProperty(format: cell.format(), property: QTextFormat::TableCellBottomPadding) |
284 | #ifndef QT_NO_CSSPARSER |
285 | + cellBorderWidth(table, cell, edge: QCss::BottomEdge) |
286 | #endif |
287 | ; |
288 | } |
289 | |
290 | inline QFixed leftPadding(QTextTable *table, const QTextTableCell &cell) const |
291 | { |
292 | #ifdef QT_NO_CSSPARSER |
293 | Q_UNUSED(table); |
294 | #endif |
295 | return paddingProperty(format: cell.format(), property: QTextFormat::TableCellLeftPadding) |
296 | #ifndef QT_NO_CSSPARSER |
297 | + cellBorderWidth(table, cell, edge: QCss::LeftEdge) |
298 | #endif |
299 | ; |
300 | } |
301 | |
302 | inline QFixed rightPadding(QTextTable *table, const QTextTableCell &cell) const |
303 | { |
304 | #ifdef QT_NO_CSSPARSER |
305 | Q_UNUSED(table); |
306 | #endif |
307 | return paddingProperty(format: cell.format(), property: QTextFormat::TableCellRightPadding) |
308 | #ifndef QT_NO_CSSPARSER |
309 | + cellBorderWidth(table, cell, edge: QCss::RightEdge) |
310 | #endif |
311 | ; |
312 | } |
313 | |
314 | inline QFixedPoint cellPosition(QTextTable *table, const QTextTableCell &cell) const |
315 | { |
316 | return cellPosition(row: cell.row(), col: cell.column()) + QFixedPoint(leftPadding(table, cell), topPadding(table, cell)); |
317 | } |
318 | |
319 | void updateTableSize(); |
320 | |
321 | private: |
322 | inline QFixedPoint cellPosition(int row, int col) const |
323 | { return QFixedPoint(columnPositions.at(i: col), rowPositions.at(i: row) + cellVerticalOffsets.at(i: col + row * widths.size())); } |
324 | }; |
325 | |
326 | static QTextFrameData *createData(QTextFrame *f) |
327 | { |
328 | QTextFrameData *data; |
329 | if (qobject_cast<QTextTable *>(object: f)) |
330 | data = new QTextTableData; |
331 | else |
332 | data = new QTextFrameData; |
333 | f->setLayoutData(data); |
334 | return data; |
335 | } |
336 | |
337 | static inline QTextFrameData *data(QTextFrame *f) |
338 | { |
339 | QTextFrameData *data = static_cast<QTextFrameData *>(f->layoutData()); |
340 | if (!data) |
341 | data = createData(f); |
342 | return data; |
343 | } |
344 | |
345 | static bool isFrameFromInlineObject(QTextFrame *f) |
346 | { |
347 | return f->firstPosition() > f->lastPosition(); |
348 | } |
349 | |
350 | void QTextTableData::updateTableSize() |
351 | { |
352 | const QFixed effectiveTopMargin = this->topMargin + effectiveTopBorder + padding; |
353 | const QFixed effectiveBottomMargin = this->bottomMargin + effectiveBottomBorder + padding; |
354 | const QFixed effectiveLeftMargin = this->leftMargin + effectiveLeftBorder + padding; |
355 | const QFixed effectiveRightMargin = this->rightMargin + effectiveRightBorder + padding; |
356 | size.height = contentsHeight == -1 |
357 | ? rowPositions.constLast() + heights.constLast() + padding + border + cellSpacing + effectiveBottomMargin |
358 | : effectiveTopMargin + contentsHeight + effectiveBottomMargin; |
359 | size.width = effectiveLeftMargin + contentsWidth + effectiveRightMargin; |
360 | } |
361 | |
362 | QRectF QTextTableData::cellRect(const QTextTableCell &cell) const |
363 | { |
364 | const int row = cell.row(); |
365 | const int rowSpan = cell.rowSpan(); |
366 | const int column = cell.column(); |
367 | const int colSpan = cell.columnSpan(); |
368 | |
369 | return QRectF(columnPositions.at(i: column).toReal(), |
370 | rowPositions.at(i: row).toReal(), |
371 | (columnPositions.at(i: column + colSpan - 1) + widths.at(i: column + colSpan - 1) - columnPositions.at(i: column)).toReal(), |
372 | (rowPositions.at(i: row + rowSpan - 1) + heights.at(i: row + rowSpan - 1) - rowPositions.at(i: row)).toReal()); |
373 | } |
374 | |
375 | static inline bool isEmptyBlockBeforeTable(const QTextBlock &block, const QTextBlockFormat &format, const QTextFrame::Iterator &nextIt) |
376 | { |
377 | return !nextIt.atEnd() |
378 | && qobject_cast<QTextTable *>(object: nextIt.currentFrame()) |
379 | && block.isValid() |
380 | && block.length() == 1 |
381 | && !format.hasProperty(propertyId: QTextFormat::BlockTrailingHorizontalRulerWidth) |
382 | && !format.hasProperty(propertyId: QTextFormat::BackgroundBrush) |
383 | && nextIt.currentFrame()->firstPosition() == block.position() + 1 |
384 | ; |
385 | } |
386 | |
387 | static inline bool isEmptyBlockBeforeTable(const QTextFrame::Iterator &it) |
388 | { |
389 | QTextFrame::Iterator next = it; ++next; |
390 | if (it.currentFrame()) |
391 | return false; |
392 | QTextBlock block = it.currentBlock(); |
393 | return isEmptyBlockBeforeTable(block, format: block.blockFormat(), nextIt: next); |
394 | } |
395 | |
396 | static inline bool isEmptyBlockAfterTable(const QTextBlock &block, const QTextFrame *previousFrame) |
397 | { |
398 | return qobject_cast<const QTextTable *>(object: previousFrame) |
399 | && block.isValid() |
400 | && block.length() == 1 |
401 | && previousFrame->lastPosition() == block.position() - 1 |
402 | ; |
403 | } |
404 | |
405 | static inline bool isLineSeparatorBlockAfterTable(const QTextBlock &block, const QTextFrame *previousFrame) |
406 | { |
407 | return qobject_cast<const QTextTable *>(object: previousFrame) |
408 | && block.isValid() |
409 | && block.length() > 1 |
410 | && block.text().at(i: 0) == QChar::LineSeparator |
411 | && previousFrame->lastPosition() == block.position() - 1 |
412 | ; |
413 | } |
414 | |
415 | /* |
416 | |
417 | Optimization strategies: |
418 | |
419 | HTML layout: |
420 | |
421 | * Distinguish between normal and special flow. For normal flow the condition: |
422 | y1 > y2 holds for all blocks with b1.key() > b2.key(). |
423 | * Special flow is: floats, table cells |
424 | |
425 | * Normal flow within table cells. Tables (not cells) are part of the normal flow. |
426 | |
427 | |
428 | * If blocks grows/shrinks in height and extends over whole page width at the end, move following blocks. |
429 | * If height doesn't change, no need to do anything |
430 | |
431 | Table cells: |
432 | |
433 | * If minWidth of cell changes, recalculate table width, relayout if needed. |
434 | * What about maxWidth when doing auto layout? |
435 | |
436 | Floats: |
437 | * need fixed or proportional width, otherwise don't float! |
438 | * On width/height change relayout surrounding paragraphs. |
439 | |
440 | Document width change: |
441 | * full relayout needed |
442 | |
443 | |
444 | Float handling: |
445 | |
446 | * Floats are specified by a special format object. |
447 | * currently only floating images are implemented. |
448 | |
449 | */ |
450 | |
451 | /* |
452 | |
453 | On the table layouting: |
454 | |
455 | +---[ table border ]------------------------- |
456 | | [ cell spacing ] |
457 | | +------[ cell border ]-----+ +-------- |
458 | | | | | |
459 | | | |
460 | | | |
461 | | | |
462 | | |
463 | |
464 | rowPositions[i] and columnPositions[i] point at the cell content |
465 | position. So for example the left border is drawn at |
466 | x = columnPositions[i] - fd->border and similar for y. |
467 | |
468 | */ |
469 | |
470 | struct QCheckPoint |
471 | { |
472 | QFixed y; |
473 | QFixed frameY; // absolute y position of the current frame |
474 | int positionInFrame; |
475 | QFixed minimumWidth; |
476 | QFixed maximumWidth; |
477 | QFixed contentsWidth; |
478 | }; |
479 | Q_DECLARE_TYPEINFO(QCheckPoint, Q_PRIMITIVE_TYPE); |
480 | |
481 | static bool operator<(const QCheckPoint &checkPoint, QFixed y) |
482 | { |
483 | return checkPoint.y < y; |
484 | } |
485 | |
486 | static bool operator<(const QCheckPoint &checkPoint, int pos) |
487 | { |
488 | return checkPoint.positionInFrame < pos; |
489 | } |
490 | |
491 | static void fillBackground(QPainter *p, const QRectF &rect, QBrush brush, const QPointF &origin, const QRectF &gradientRect = QRectF()) |
492 | { |
493 | p->save(); |
494 | if (brush.style() >= Qt::LinearGradientPattern && brush.style() <= Qt::ConicalGradientPattern) { |
495 | if (!gradientRect.isNull()) { |
496 | QTransform m; |
497 | m.translate(dx: gradientRect.left(), dy: gradientRect.top()); |
498 | m.scale(sx: gradientRect.width(), sy: gradientRect.height()); |
499 | brush.setTransform(m); |
500 | const_cast<QGradient *>(brush.gradient())->setCoordinateMode(QGradient::LogicalMode); |
501 | } |
502 | } else { |
503 | p->setBrushOrigin(origin); |
504 | } |
505 | p->fillRect(rect, brush); |
506 | p->restore(); |
507 | } |
508 | |
509 | class QTextDocumentLayoutPrivate : public QAbstractTextDocumentLayoutPrivate |
510 | { |
511 | Q_DECLARE_PUBLIC(QTextDocumentLayout) |
512 | public: |
513 | QTextDocumentLayoutPrivate(); |
514 | |
515 | QTextOption::WrapMode wordWrapMode; |
516 | #ifdef LAYOUT_DEBUG |
517 | mutable QString debug_indent; |
518 | #endif |
519 | |
520 | int fixedColumnWidth; |
521 | int cursorWidth; |
522 | |
523 | QSizeF lastReportedSize; |
524 | QRectF viewportRect; |
525 | QRectF clipRect; |
526 | |
527 | mutable int currentLazyLayoutPosition; |
528 | mutable int lazyLayoutStepSize; |
529 | QBasicTimer layoutTimer; |
530 | mutable QBasicTimer sizeChangedTimer; |
531 | uint showLayoutProgress : 1; |
532 | uint insideDocumentChange : 1; |
533 | |
534 | int lastPageCount; |
535 | qreal idealWidth; |
536 | bool contentHasAlignment; |
537 | |
538 | QFixed blockIndent(const QTextBlockFormat &blockFormat) const; |
539 | |
540 | void drawFrame(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context, |
541 | QTextFrame *f) const; |
542 | void drawFlow(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context, |
543 | QTextFrame::Iterator it, const QList<QTextFrame *> &floats, QTextBlock *cursorBlockNeedingRepaint) const; |
544 | void drawBlock(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context, |
545 | const QTextBlock &bl, bool inRootFrame) const; |
546 | void drawListItem(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context, |
547 | const QTextBlock &bl, const QTextCharFormat *selectionFormat) const; |
548 | void drawTableCellBorder(const QRectF &cellRect, QPainter *painter, QTextTable *table, QTextTableData *td, const QTextTableCell &cell) const; |
549 | void drawTableCell(const QRectF &cellRect, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &cell_context, |
550 | QTextTable *table, QTextTableData *td, int r, int c, |
551 | QTextBlock *cursorBlockNeedingRepaint, QPointF *cursorBlockOffset) const; |
552 | void drawBorder(QPainter *painter, const QRectF &rect, qreal topMargin, qreal bottomMargin, qreal border, |
553 | const QBrush &brush, QTextFrameFormat::BorderStyle style) const; |
554 | void drawFrameDecoration(QPainter *painter, QTextFrame *frame, QTextFrameData *fd, const QRectF &clip, const QRectF &rect) const; |
555 | |
556 | enum HitPoint { |
557 | PointBefore, |
558 | PointAfter, |
559 | PointInside, |
560 | PointExact |
561 | }; |
562 | HitPoint hitTest(QTextFrame *frame, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const; |
563 | HitPoint hitTest(QTextFrame::Iterator it, HitPoint hit, const QFixedPoint &p, |
564 | int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const; |
565 | HitPoint hitTest(QTextTable *table, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const; |
566 | HitPoint hitTest(const QTextBlock &bl, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const; |
567 | |
568 | QTextLayoutStruct layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width, |
569 | int layoutFrom, int layoutTo, QTextTableData *tableData, QFixed absoluteTableY, |
570 | bool withPageBreaks); |
571 | void setCellPosition(QTextTable *t, const QTextTableCell &cell, const QPointF &pos); |
572 | QRectF layoutTable(QTextTable *t, int layoutFrom, int layoutTo, QFixed parentY); |
573 | |
574 | void positionFloat(QTextFrame *frame, QTextLine *currentLine = nullptr); |
575 | |
576 | // calls the next one |
577 | QRectF layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed parentY = 0); |
578 | QRectF layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed frameWidth, QFixed frameHeight, QFixed parentY = 0); |
579 | |
580 | void layoutBlock(const QTextBlock &bl, int blockPosition, const QTextBlockFormat &blockFormat, |
581 | QTextLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat); |
582 | void layoutFlow(QTextFrame::Iterator it, QTextLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, QFixed width = 0); |
583 | |
584 | void floatMargins(const QFixed &y, const QTextLayoutStruct *layoutStruct, QFixed *left, QFixed *right) const; |
585 | QFixed findY(QFixed yFrom, const QTextLayoutStruct *layoutStruct, QFixed requiredWidth) const; |
586 | |
587 | QVector<QCheckPoint> checkPoints; |
588 | |
589 | QTextFrame::Iterator frameIteratorForYPosition(QFixed y) const; |
590 | QTextFrame::Iterator frameIteratorForTextPosition(int position) const; |
591 | |
592 | void ensureLayouted(QFixed y) const; |
593 | void ensureLayoutedByPosition(int position) const; |
594 | inline void ensureLayoutFinished() const |
595 | { ensureLayoutedByPosition(INT_MAX); } |
596 | void layoutStep() const; |
597 | |
598 | QRectF frameBoundingRectInternal(QTextFrame *frame) const; |
599 | |
600 | qreal scaleToDevice(qreal value) const; |
601 | QFixed scaleToDevice(QFixed value) const; |
602 | }; |
603 | |
604 | QTextDocumentLayoutPrivate::QTextDocumentLayoutPrivate() |
605 | : fixedColumnWidth(-1), |
606 | cursorWidth(1), |
607 | currentLazyLayoutPosition(-1), |
608 | lazyLayoutStepSize(1000), |
609 | lastPageCount(-1) |
610 | { |
611 | showLayoutProgress = true; |
612 | insideDocumentChange = false; |
613 | idealWidth = 0; |
614 | contentHasAlignment = false; |
615 | } |
616 | |
617 | QTextFrame::Iterator QTextDocumentLayoutPrivate::frameIteratorForYPosition(QFixed y) const |
618 | { |
619 | QTextFrame *rootFrame = document->rootFrame(); |
620 | |
621 | if (checkPoints.isEmpty() |
622 | || y < 0 || y > data(f: rootFrame)->size.height) |
623 | return rootFrame->begin(); |
624 | |
625 | QVector<QCheckPoint>::ConstIterator checkPoint = std::lower_bound(checkPoints.begin(), checkPoints.end(), y); |
626 | if (checkPoint == checkPoints.end()) |
627 | return rootFrame->begin(); |
628 | |
629 | if (checkPoint != checkPoints.begin()) |
630 | --checkPoint; |
631 | |
632 | const int position = rootFrame->firstPosition() + checkPoint->positionInFrame; |
633 | return frameIteratorForTextPosition(position); |
634 | } |
635 | |
636 | QTextFrame::Iterator QTextDocumentLayoutPrivate::frameIteratorForTextPosition(int position) const |
637 | { |
638 | QTextFrame *rootFrame = docPrivate->rootFrame(); |
639 | |
640 | const QTextDocumentPrivate::BlockMap &map = docPrivate->blockMap(); |
641 | const int begin = map.findNode(k: rootFrame->firstPosition()); |
642 | const int end = map.findNode(k: rootFrame->lastPosition()+1); |
643 | |
644 | const int block = map.findNode(k: position); |
645 | const int blockPos = map.position(node: block); |
646 | |
647 | QTextFrame::iterator it(rootFrame, block, begin, end); |
648 | |
649 | QTextFrame *containingFrame = docPrivate->frameAt(pos: blockPos); |
650 | if (containingFrame != rootFrame) { |
651 | while (containingFrame->parentFrame() != rootFrame) { |
652 | containingFrame = containingFrame->parentFrame(); |
653 | Q_ASSERT(containingFrame); |
654 | } |
655 | |
656 | it.cf = containingFrame; |
657 | it.cb = 0; |
658 | } |
659 | |
660 | return it; |
661 | } |
662 | |
663 | QTextDocumentLayoutPrivate::HitPoint |
664 | QTextDocumentLayoutPrivate::hitTest(QTextFrame *frame, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const |
665 | { |
666 | QTextFrameData *fd = data(f: frame); |
667 | // ######### |
668 | if (fd->layoutDirty) |
669 | return PointAfter; |
670 | Q_ASSERT(!fd->layoutDirty); |
671 | Q_ASSERT(!fd->sizeDirty); |
672 | const QFixedPoint relativePoint(point.x - fd->position.x, point.y - fd->position.y); |
673 | |
674 | QTextFrame *rootFrame = docPrivate->rootFrame(); |
675 | |
676 | qCDebug(lcHit) << "checking frame" << frame->firstPosition() << "point=" << point.toPointF() |
677 | << "position" << fd->position.toPointF() << "size" << fd->size.toSizeF(); |
678 | if (frame != rootFrame) { |
679 | if (relativePoint.y < 0 || relativePoint.x < 0) { |
680 | *position = frame->firstPosition() - 1; |
681 | qCDebug(lcHit) << "before pos=" << *position; |
682 | return PointBefore; |
683 | } else if (relativePoint.y > fd->size.height || relativePoint.x > fd->size.width) { |
684 | *position = frame->lastPosition() + 1; |
685 | qCDebug(lcHit) << "after pos=" << *position; |
686 | return PointAfter; |
687 | } |
688 | } |
689 | |
690 | if (isFrameFromInlineObject(f: frame)) { |
691 | *position = frame->firstPosition() - 1; |
692 | return PointExact; |
693 | } |
694 | |
695 | if (QTextTable *table = qobject_cast<QTextTable *>(object: frame)) { |
696 | const int rows = table->rows(); |
697 | const int columns = table->columns(); |
698 | QTextTableData *td = static_cast<QTextTableData *>(data(f: table)); |
699 | |
700 | if (!td->childFrameMap.isEmpty()) { |
701 | for (int r = 0; r < rows; ++r) { |
702 | for (int c = 0; c < columns; ++c) { |
703 | QTextTableCell cell = table->cellAt(row: r, col: c); |
704 | if (cell.row() != r || cell.column() != c) |
705 | continue; |
706 | |
707 | QRectF cellRect = td->cellRect(cell); |
708 | const QFixedPoint cellPos = QFixedPoint::fromPointF(p: cellRect.topLeft()); |
709 | const QFixedPoint pointInCell = relativePoint - cellPos; |
710 | |
711 | const QList<QTextFrame *> childFrames = td->childFrameMap.values(akey: r + c * rows); |
712 | for (int i = 0; i < childFrames.size(); ++i) { |
713 | QTextFrame *child = childFrames.at(i); |
714 | if (isFrameFromInlineObject(f: child) |
715 | && child->frameFormat().position() != QTextFrameFormat::InFlow |
716 | && hitTest(frame: child, point: pointInCell, position, l, accuracy) == PointExact) |
717 | { |
718 | return PointExact; |
719 | } |
720 | } |
721 | } |
722 | } |
723 | } |
724 | |
725 | return hitTest(table, point: relativePoint, position, l, accuracy); |
726 | } |
727 | |
728 | const QList<QTextFrame *> childFrames = frame->childFrames(); |
729 | for (int i = 0; i < childFrames.size(); ++i) { |
730 | QTextFrame *child = childFrames.at(i); |
731 | if (isFrameFromInlineObject(f: child) |
732 | && child->frameFormat().position() != QTextFrameFormat::InFlow |
733 | && hitTest(frame: child, point: relativePoint, position, l, accuracy) == PointExact) |
734 | { |
735 | return PointExact; |
736 | } |
737 | } |
738 | |
739 | QTextFrame::Iterator it = frame->begin(); |
740 | |
741 | if (frame == rootFrame) { |
742 | it = frameIteratorForYPosition(y: relativePoint.y); |
743 | |
744 | Q_ASSERT(it.parentFrame() == frame); |
745 | } |
746 | |
747 | if (it.currentFrame()) |
748 | *position = it.currentFrame()->firstPosition(); |
749 | else |
750 | *position = it.currentBlock().position(); |
751 | |
752 | return hitTest(it, hit: PointBefore, p: relativePoint, position, l, accuracy); |
753 | } |
754 | |
755 | QTextDocumentLayoutPrivate::HitPoint |
756 | QTextDocumentLayoutPrivate::hitTest(QTextFrame::Iterator it, HitPoint hit, const QFixedPoint &p, |
757 | int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const |
758 | { |
759 | for (; !it.atEnd(); ++it) { |
760 | QTextFrame *c = it.currentFrame(); |
761 | HitPoint hp; |
762 | int pos = -1; |
763 | if (c) { |
764 | hp = hitTest(frame: c, point: p, position: &pos, l, accuracy); |
765 | } else { |
766 | hp = hitTest(bl: it.currentBlock(), point: p, position: &pos, l, accuracy); |
767 | } |
768 | if (hp >= PointInside) { |
769 | if (isEmptyBlockBeforeTable(it)) |
770 | continue; |
771 | hit = hp; |
772 | *position = pos; |
773 | break; |
774 | } |
775 | if (hp == PointBefore && pos < *position) { |
776 | *position = pos; |
777 | hit = hp; |
778 | } else if (hp == PointAfter && pos > *position) { |
779 | *position = pos; |
780 | hit = hp; |
781 | } |
782 | } |
783 | |
784 | qCDebug(lcHit) << "inside=" << hit << " pos=" << *position; |
785 | return hit; |
786 | } |
787 | |
788 | QTextDocumentLayoutPrivate::HitPoint |
789 | QTextDocumentLayoutPrivate::hitTest(QTextTable *table, const QFixedPoint &point, |
790 | int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const |
791 | { |
792 | QTextTableData *td = static_cast<QTextTableData *>(data(f: table)); |
793 | |
794 | QVector<QFixed>::ConstIterator rowIt = std::lower_bound(td->rowPositions.constBegin(), td->rowPositions.constEnd(), point.y); |
795 | if (rowIt == td->rowPositions.constEnd()) { |
796 | rowIt = td->rowPositions.constEnd() - 1; |
797 | } else if (rowIt != td->rowPositions.constBegin()) { |
798 | --rowIt; |
799 | } |
800 | |
801 | QVector<QFixed>::ConstIterator colIt = std::lower_bound(td->columnPositions.constBegin(), td->columnPositions.constEnd(), point.x); |
802 | if (colIt == td->columnPositions.constEnd()) { |
803 | colIt = td->columnPositions.constEnd() - 1; |
804 | } else if (colIt != td->columnPositions.constBegin()) { |
805 | --colIt; |
806 | } |
807 | |
808 | QTextTableCell cell = table->cellAt(row: rowIt - td->rowPositions.constBegin(), |
809 | col: colIt - td->columnPositions.constBegin()); |
810 | if (!cell.isValid()) |
811 | return PointBefore; |
812 | |
813 | *position = cell.firstPosition(); |
814 | |
815 | HitPoint hp = hitTest(it: cell.begin(), hit: PointInside, p: point - td->cellPosition(table, cell), position, l, accuracy); |
816 | |
817 | if (hp == PointExact) |
818 | return hp; |
819 | if (hp == PointAfter) |
820 | *position = cell.lastPosition(); |
821 | return PointInside; |
822 | } |
823 | |
824 | QTextDocumentLayoutPrivate::HitPoint |
825 | QTextDocumentLayoutPrivate::hitTest(const QTextBlock &bl, const QFixedPoint &point, int *position, QTextLayout **l, |
826 | Qt::HitTestAccuracy accuracy) const |
827 | { |
828 | QTextLayout *tl = bl.layout(); |
829 | QRectF textrect = tl->boundingRect(); |
830 | textrect.translate(p: tl->position()); |
831 | qCDebug(lcHit) << " checking block" << bl.position() << "point=" << point.toPointF() << " tlrect" << textrect; |
832 | *position = bl.position(); |
833 | if (point.y.toReal() < textrect.top()) { |
834 | qCDebug(lcHit) << " before pos=" << *position; |
835 | return PointBefore; |
836 | } else if (point.y.toReal() > textrect.bottom()) { |
837 | *position += bl.length(); |
838 | qCDebug(lcHit) << " after pos=" << *position; |
839 | return PointAfter; |
840 | } |
841 | |
842 | QPointF pos = point.toPointF() - tl->position(); |
843 | |
844 | // ### rtl? |
845 | |
846 | HitPoint hit = PointInside; |
847 | *l = tl; |
848 | int off = 0; |
849 | for (int i = 0; i < tl->lineCount(); ++i) { |
850 | QTextLine line = tl->lineAt(i); |
851 | const QRectF lr = line.naturalTextRect(); |
852 | if (lr.top() > pos.y()) { |
853 | off = qMin(a: off, b: line.textStart()); |
854 | } else if (lr.bottom() <= pos.y()) { |
855 | off = qMax(a: off, b: line.textStart() + line.textLength()); |
856 | } else { |
857 | if (lr.left() <= pos.x() && lr.right() >= pos.x()) |
858 | hit = PointExact; |
859 | // when trying to hit an anchor we want it to hit not only in the left |
860 | // half |
861 | if (accuracy == Qt::ExactHit) |
862 | off = line.xToCursor(x: pos.x(), QTextLine::CursorOnCharacter); |
863 | else |
864 | off = line.xToCursor(x: pos.x(), QTextLine::CursorBetweenCharacters); |
865 | break; |
866 | } |
867 | } |
868 | *position += off; |
869 | |
870 | qCDebug(lcHit) << " inside=" << hit << " pos=" << *position; |
871 | return hit; |
872 | } |
873 | |
874 | // ### could be moved to QTextBlock |
875 | QFixed QTextDocumentLayoutPrivate::blockIndent(const QTextBlockFormat &blockFormat) const |
876 | { |
877 | qreal indent = blockFormat.indent(); |
878 | |
879 | QTextObject *object = document->objectForFormat(blockFormat); |
880 | if (object) |
881 | indent += object->format().toListFormat().indent(); |
882 | |
883 | if (qIsNull(d: indent)) |
884 | return 0; |
885 | |
886 | qreal scale = 1; |
887 | if (paintDevice) { |
888 | scale = qreal(paintDevice->logicalDpiY()) / qreal(qt_defaultDpi()); |
889 | } |
890 | |
891 | return QFixed::fromReal(r: indent * scale * document->indentWidth()); |
892 | } |
893 | |
894 | struct BorderPaginator |
895 | { |
896 | BorderPaginator(QTextDocument *document, const QRectF &rect, qreal topMarginAfterPageBreak, qreal bottomMargin, qreal border) : |
897 | pageHeight(document->pageSize().height()), |
898 | topPage(pageHeight > 0 ? static_cast<int>(rect.top() / pageHeight) : 0), |
899 | bottomPage(pageHeight > 0 ? static_cast<int>((rect.bottom() + border) / pageHeight) : 0), |
900 | rect(rect), |
901 | topMarginAfterPageBreak(topMarginAfterPageBreak), |
902 | bottomMargin(bottomMargin), border(border) |
903 | {} |
904 | |
905 | QRectF clipRect(int page) const |
906 | { |
907 | QRectF clipped = rect.toRect(); |
908 | |
909 | if (topPage != bottomPage) { |
910 | clipped.setTop(qMax(a: clipped.top(), b: page * pageHeight + topMarginAfterPageBreak - border)); |
911 | clipped.setBottom(qMin(a: clipped.bottom(), b: (page + 1) * pageHeight - bottomMargin)); |
912 | |
913 | if (clipped.bottom() <= clipped.top()) |
914 | return QRectF(); |
915 | } |
916 | |
917 | return clipped; |
918 | } |
919 | |
920 | qreal pageHeight; |
921 | int topPage; |
922 | int bottomPage; |
923 | QRectF rect; |
924 | qreal topMarginAfterPageBreak; |
925 | qreal bottomMargin; |
926 | qreal border; |
927 | }; |
928 | |
929 | void QTextDocumentLayoutPrivate::drawBorder(QPainter *painter, const QRectF &rect, qreal topMargin, qreal bottomMargin, |
930 | qreal border, const QBrush &brush, QTextFrameFormat::BorderStyle style) const |
931 | { |
932 | BorderPaginator paginator(document, rect, topMargin, bottomMargin, border); |
933 | |
934 | #ifndef QT_NO_CSSPARSER |
935 | QCss::BorderStyle cssStyle = static_cast<QCss::BorderStyle>(style + 1); |
936 | #else |
937 | Q_UNUSED(style); |
938 | #endif //QT_NO_CSSPARSER |
939 | |
940 | bool turn_off_antialiasing = !(painter->renderHints() & QPainter::Antialiasing); |
941 | painter->setRenderHint(hint: QPainter::Antialiasing); |
942 | |
943 | for (int i = paginator.topPage; i <= paginator.bottomPage; ++i) { |
944 | QRectF clipped = paginator.clipRect(page: i); |
945 | if (!clipped.isValid()) |
946 | continue; |
947 | |
948 | #ifndef QT_NO_CSSPARSER |
949 | qDrawEdge(p: painter, x1: clipped.left(), y1: clipped.top(), x2: clipped.left() + border, y2: clipped.bottom() + border, dw1: 0, dw2: 0, edge: QCss::LeftEdge, style: cssStyle, c: brush); |
950 | qDrawEdge(p: painter, x1: clipped.left() + border, y1: clipped.top(), x2: clipped.right() + border, y2: clipped.top() + border, dw1: 0, dw2: 0, edge: QCss::TopEdge, style: cssStyle, c: brush); |
951 | qDrawEdge(p: painter, x1: clipped.right(), y1: clipped.top() + border, x2: clipped.right() + border, y2: clipped.bottom(), dw1: 0, dw2: 0, edge: QCss::RightEdge, style: cssStyle, c: brush); |
952 | qDrawEdge(p: painter, x1: clipped.left() + border, y1: clipped.bottom(), x2: clipped.right() + border, y2: clipped.bottom() + border, dw1: 0, dw2: 0, edge: QCss::BottomEdge, style: cssStyle, c: brush); |
953 | #else |
954 | painter->save(); |
955 | painter->setPen(Qt::NoPen); |
956 | painter->setBrush(brush); |
957 | painter->drawRect(QRectF(clipped.left(), clipped.top(), clipped.left() + border, clipped.bottom() + border)); |
958 | painter->drawRect(QRectF(clipped.left() + border, clipped.top(), clipped.right() + border, clipped.top() + border)); |
959 | painter->drawRect(QRectF(clipped.right(), clipped.top() + border, clipped.right() + border, clipped.bottom())); |
960 | painter->drawRect(QRectF(clipped.left() + border, clipped.bottom(), clipped.right() + border, clipped.bottom() + border)); |
961 | painter->restore(); |
962 | #endif //QT_NO_CSSPARSER |
963 | } |
964 | if (turn_off_antialiasing) |
965 | painter->setRenderHint(hint: QPainter::Antialiasing, on: false); |
966 | } |
967 | |
968 | void QTextDocumentLayoutPrivate::drawFrameDecoration(QPainter *painter, QTextFrame *frame, QTextFrameData *fd, const QRectF &clip, const QRectF &rect) const |
969 | { |
970 | |
971 | const QBrush bg = frame->frameFormat().background(); |
972 | if (bg != Qt::NoBrush) { |
973 | QRectF bgRect = rect; |
974 | bgRect.adjust(xp1: (fd->leftMargin + fd->border).toReal(), |
975 | yp1: (fd->topMargin + fd->border).toReal(), |
976 | xp2: - (fd->rightMargin + fd->border).toReal(), |
977 | yp2: - (fd->bottomMargin + fd->border).toReal()); |
978 | |
979 | QRectF gradientRect; // invalid makes it default to bgRect |
980 | QPointF origin = bgRect.topLeft(); |
981 | if (!frame->parentFrame()) { |
982 | bgRect = clip; |
983 | gradientRect.setWidth(painter->device()->width()); |
984 | gradientRect.setHeight(painter->device()->height()); |
985 | } |
986 | fillBackground(p: painter, rect: bgRect, brush: bg, origin, gradientRect); |
987 | } |
988 | if (fd->border != 0) { |
989 | painter->save(); |
990 | painter->setBrush(Qt::lightGray); |
991 | painter->setPen(Qt::NoPen); |
992 | |
993 | const qreal leftEdge = rect.left() + fd->leftMargin.toReal(); |
994 | const qreal border = fd->border.toReal(); |
995 | const qreal topMargin = fd->topMargin.toReal(); |
996 | const qreal leftMargin = fd->leftMargin.toReal(); |
997 | const qreal bottomMargin = fd->bottomMargin.toReal(); |
998 | const qreal rightMargin = fd->rightMargin.toReal(); |
999 | const qreal w = rect.width() - 2 * border - leftMargin - rightMargin; |
1000 | const qreal h = rect.height() - 2 * border - topMargin - bottomMargin; |
1001 | |
1002 | drawBorder(painter, rect: QRectF(leftEdge, rect.top() + topMargin, w + border, h + border), |
1003 | topMargin: fd->effectiveTopMargin.toReal(), bottomMargin: fd->effectiveBottomMargin.toReal(), |
1004 | border, brush: frame->frameFormat().borderBrush(), style: frame->frameFormat().borderStyle()); |
1005 | |
1006 | painter->restore(); |
1007 | } |
1008 | } |
1009 | |
1010 | static void adjustContextSelectionsForCell(QAbstractTextDocumentLayout::PaintContext &cell_context, |
1011 | const QTextTableCell &cell, |
1012 | int r, int c, |
1013 | const int *selectedTableCells) |
1014 | { |
1015 | for (int i = 0; i < cell_context.selections.size(); ++i) { |
1016 | int row_start = selectedTableCells[i * 4]; |
1017 | int col_start = selectedTableCells[i * 4 + 1]; |
1018 | int num_rows = selectedTableCells[i * 4 + 2]; |
1019 | int num_cols = selectedTableCells[i * 4 + 3]; |
1020 | |
1021 | if (row_start != -1) { |
1022 | if (r >= row_start && r < row_start + num_rows |
1023 | && c >= col_start && c < col_start + num_cols) |
1024 | { |
1025 | int firstPosition = cell.firstPosition(); |
1026 | int lastPosition = cell.lastPosition(); |
1027 | |
1028 | // make sure empty cells are still selected |
1029 | if (firstPosition == lastPosition) |
1030 | ++lastPosition; |
1031 | |
1032 | cell_context.selections[i].cursor.setPosition(pos: firstPosition); |
1033 | cell_context.selections[i].cursor.setPosition(pos: lastPosition, mode: QTextCursor::KeepAnchor); |
1034 | } else { |
1035 | cell_context.selections[i].cursor.clearSelection(); |
1036 | } |
1037 | } |
1038 | |
1039 | // FullWidthSelection is not useful for tables |
1040 | cell_context.selections[i].format.clearProperty(propertyId: QTextFormat::FullWidthSelection); |
1041 | } |
1042 | } |
1043 | |
1044 | static bool cellClipTest(QTextTable *table, QTextTableData *td, |
1045 | const QAbstractTextDocumentLayout::PaintContext &cell_context, |
1046 | const QTextTableCell &cell, |
1047 | QRectF cellRect) |
1048 | { |
1049 | #ifdef QT_NO_CSSPARSER |
1050 | Q_UNUSED(table); |
1051 | Q_UNUSED(cell); |
1052 | #endif |
1053 | |
1054 | if (!cell_context.clip.isValid()) |
1055 | return false; |
1056 | |
1057 | if (td->borderCollapse) { |
1058 | // we need to account for the cell borders in the clipping test |
1059 | #ifndef QT_NO_CSSPARSER |
1060 | cellRect.adjust(xp1: -axisEdgeData(table, td, cell, edge: QCss::LeftEdge).width / 2, |
1061 | yp1: -axisEdgeData(table, td, cell, edge: QCss::TopEdge).width / 2, |
1062 | xp2: axisEdgeData(table, td, cell, edge: QCss::RightEdge).width / 2, |
1063 | yp2: axisEdgeData(table, td, cell, edge: QCss::BottomEdge).width / 2); |
1064 | #endif |
1065 | } else { |
1066 | qreal border = td->border.toReal(); |
1067 | cellRect.adjust(xp1: -border, yp1: -border, xp2: border, yp2: border); |
1068 | } |
1069 | |
1070 | if (!cellRect.intersects(r: cell_context.clip)) |
1071 | return true; |
1072 | |
1073 | return false; |
1074 | } |
1075 | |
1076 | void QTextDocumentLayoutPrivate::drawFrame(const QPointF &offset, QPainter *painter, |
1077 | const QAbstractTextDocumentLayout::PaintContext &context, |
1078 | QTextFrame *frame) const |
1079 | { |
1080 | QTextFrameData *fd = data(f: frame); |
1081 | // ####### |
1082 | if (fd->layoutDirty) |
1083 | return; |
1084 | Q_ASSERT(!fd->sizeDirty); |
1085 | Q_ASSERT(!fd->layoutDirty); |
1086 | |
1087 | // floor the offset to avoid painting artefacts when drawing adjacent borders |
1088 | // we later also round table cell heights and widths |
1089 | const QPointF off = QPointF(QPointF(offset + fd->position.toPointF()).toPoint()); |
1090 | |
1091 | if (context.clip.isValid() |
1092 | && (off.y() > context.clip.bottom() || off.y() + fd->size.height.toReal() < context.clip.top() |
1093 | || off.x() > context.clip.right() || off.x() + fd->size.width.toReal() < context.clip.left())) |
1094 | return; |
1095 | |
1096 | qCDebug(lcDraw) << "drawFrame" << frame->firstPosition() << "--" << frame->lastPosition() << "at" << offset; |
1097 | |
1098 | // if the cursor is /on/ a table border we may need to repaint it |
1099 | // afterwards, as we usually draw the decoration first |
1100 | QTextBlock cursorBlockNeedingRepaint; |
1101 | QPointF offsetOfRepaintedCursorBlock = off; |
1102 | |
1103 | QTextTable *table = qobject_cast<QTextTable *>(object: frame); |
1104 | const QRectF frameRect(off, fd->size.toSizeF()); |
1105 | |
1106 | if (table) { |
1107 | const int rows = table->rows(); |
1108 | const int columns = table->columns(); |
1109 | QTextTableData *td = static_cast<QTextTableData *>(data(f: table)); |
1110 | |
1111 | QVarLengthArray<int> selectedTableCells(context.selections.size() * 4); |
1112 | for (int i = 0; i < context.selections.size(); ++i) { |
1113 | const QAbstractTextDocumentLayout::Selection &s = context.selections.at(i); |
1114 | int row_start = -1, col_start = -1, num_rows = -1, num_cols = -1; |
1115 | |
1116 | if (s.cursor.currentTable() == table) |
1117 | s.cursor.selectedTableCells(firstRow: &row_start, numRows: &num_rows, firstColumn: &col_start, numColumns: &num_cols); |
1118 | |
1119 | selectedTableCells[i * 4] = row_start; |
1120 | selectedTableCells[i * 4 + 1] = col_start; |
1121 | selectedTableCells[i * 4 + 2] = num_rows; |
1122 | selectedTableCells[i * 4 + 3] = num_cols; |
1123 | } |
1124 | |
1125 | QFixed pageHeight = QFixed::fromReal(r: document->pageSize().height()); |
1126 | if (pageHeight <= 0) |
1127 | pageHeight = QFIXED_MAX; |
1128 | |
1129 | QFixed absYPos = td->position.y; |
1130 | QTextFrame *parentFrame = table->parentFrame(); |
1131 | while (parentFrame) { |
1132 | absYPos += data(f: parentFrame)->position.y; |
1133 | parentFrame = parentFrame->parentFrame(); |
1134 | } |
1135 | const int tableStartPage = (absYPos / pageHeight).truncate(); |
1136 | const int tableEndPage = ((absYPos + td->size.height) / pageHeight).truncate(); |
1137 | |
1138 | // for borderCollapse draw frame decoration by drawing the outermost |
1139 | // cell edges with width = td->border |
1140 | if (!td->borderCollapse) |
1141 | drawFrameDecoration(painter, frame, fd, clip: context.clip, rect: frameRect); |
1142 | |
1143 | // draw the repeated table headers for table continuation after page breaks |
1144 | const int = qMin(a: table->format().headerRowCount(), b: rows - 1); |
1145 | int page = tableStartPage + 1; |
1146 | while (page <= tableEndPage) { |
1147 | const QFixed pageTop = page * pageHeight + td->effectiveTopMargin + td->cellSpacing + td->border; |
1148 | const qreal = (pageTop - td->rowPositions.at(i: 0)).toReal(); |
1149 | for (int r = 0; r < headerRowCount; ++r) { |
1150 | for (int c = 0; c < columns; ++c) { |
1151 | QTextTableCell cell = table->cellAt(row: r, col: c); |
1152 | QAbstractTextDocumentLayout::PaintContext cell_context = context; |
1153 | adjustContextSelectionsForCell(cell_context, cell, r, c, selectedTableCells: selectedTableCells.data()); |
1154 | QRectF cellRect = td->cellRect(cell); |
1155 | |
1156 | cellRect.translate(dx: off.x(), dy: headerOffset); |
1157 | if (cellClipTest(table, td, cell_context, cell, cellRect)) |
1158 | continue; |
1159 | |
1160 | drawTableCell(cellRect, painter, cell_context, table, td, r, c, cursorBlockNeedingRepaint: &cursorBlockNeedingRepaint, |
1161 | cursorBlockOffset: &offsetOfRepaintedCursorBlock); |
1162 | } |
1163 | } |
1164 | ++page; |
1165 | } |
1166 | |
1167 | int firstRow = 0; |
1168 | int lastRow = rows; |
1169 | |
1170 | if (context.clip.isValid()) { |
1171 | QVector<QFixed>::ConstIterator rowIt = std::lower_bound(td->rowPositions.constBegin(), td->rowPositions.constEnd(), QFixed::fromReal(r: context.clip.top() - off.y())); |
1172 | if (rowIt != td->rowPositions.constEnd() && rowIt != td->rowPositions.constBegin()) { |
1173 | --rowIt; |
1174 | firstRow = rowIt - td->rowPositions.constBegin(); |
1175 | } |
1176 | |
1177 | rowIt = std::upper_bound(first: td->rowPositions.constBegin(), last: td->rowPositions.constEnd(), val: QFixed::fromReal(r: context.clip.bottom() - off.y())); |
1178 | if (rowIt != td->rowPositions.constEnd()) { |
1179 | ++rowIt; |
1180 | lastRow = rowIt - td->rowPositions.constBegin(); |
1181 | } |
1182 | } |
1183 | |
1184 | for (int c = 0; c < columns; ++c) { |
1185 | QTextTableCell cell = table->cellAt(row: firstRow, col: c); |
1186 | firstRow = qMin(a: firstRow, b: cell.row()); |
1187 | } |
1188 | |
1189 | for (int r = firstRow; r < lastRow; ++r) { |
1190 | for (int c = 0; c < columns; ++c) { |
1191 | QTextTableCell cell = table->cellAt(row: r, col: c); |
1192 | QAbstractTextDocumentLayout::PaintContext cell_context = context; |
1193 | adjustContextSelectionsForCell(cell_context, cell, r, c, selectedTableCells: selectedTableCells.data()); |
1194 | QRectF cellRect = td->cellRect(cell); |
1195 | |
1196 | cellRect.translate(p: off); |
1197 | if (cellClipTest(table, td, cell_context, cell, cellRect)) |
1198 | continue; |
1199 | |
1200 | drawTableCell(cellRect, painter, cell_context, table, td, r, c, cursorBlockNeedingRepaint: &cursorBlockNeedingRepaint, |
1201 | cursorBlockOffset: &offsetOfRepaintedCursorBlock); |
1202 | } |
1203 | } |
1204 | |
1205 | } else { |
1206 | drawFrameDecoration(painter, frame, fd, clip: context.clip, rect: frameRect); |
1207 | |
1208 | QTextFrame::Iterator it = frame->begin(); |
1209 | |
1210 | if (frame == docPrivate->rootFrame()) |
1211 | it = frameIteratorForYPosition(y: QFixed::fromReal(r: context.clip.top())); |
1212 | |
1213 | QList<QTextFrame *> floats; |
1214 | const int numFloats = fd->floats.count(); |
1215 | floats.reserve(size: numFloats); |
1216 | for (int i = 0; i < numFloats; ++i) |
1217 | floats.append(t: fd->floats.at(i)); |
1218 | |
1219 | drawFlow(offset: off, painter, context, it, floats, cursorBlockNeedingRepaint: &cursorBlockNeedingRepaint); |
1220 | } |
1221 | |
1222 | if (cursorBlockNeedingRepaint.isValid()) { |
1223 | const QPen oldPen = painter->pen(); |
1224 | painter->setPen(context.palette.color(cr: QPalette::Text)); |
1225 | const int cursorPos = context.cursorPosition - cursorBlockNeedingRepaint.position(); |
1226 | cursorBlockNeedingRepaint.layout()->drawCursor(p: painter, pos: offsetOfRepaintedCursorBlock, |
1227 | cursorPosition: cursorPos, width: cursorWidth); |
1228 | painter->setPen(oldPen); |
1229 | } |
1230 | |
1231 | return; |
1232 | } |
1233 | |
1234 | #ifndef QT_NO_CSSPARSER |
1235 | |
1236 | static inline QTextFormat::Property borderPropertyForEdge(QCss::Edge edge) |
1237 | { |
1238 | switch (edge) { |
1239 | case QCss::TopEdge: |
1240 | return QTextFormat::TableCellTopBorder; |
1241 | case QCss::BottomEdge: |
1242 | return QTextFormat::TableCellBottomBorder; |
1243 | case QCss::LeftEdge: |
1244 | return QTextFormat::TableCellLeftBorder; |
1245 | case QCss::RightEdge: |
1246 | return QTextFormat::TableCellRightBorder; |
1247 | default: |
1248 | Q_UNREACHABLE(); |
1249 | return QTextFormat::UserProperty; |
1250 | } |
1251 | } |
1252 | |
1253 | static inline QTextFormat::Property borderStylePropertyForEdge(QCss::Edge edge) |
1254 | { |
1255 | switch (edge) { |
1256 | case QCss::TopEdge: |
1257 | return QTextFormat::TableCellTopBorderStyle; |
1258 | case QCss::BottomEdge: |
1259 | return QTextFormat::TableCellBottomBorderStyle; |
1260 | case QCss::LeftEdge: |
1261 | return QTextFormat::TableCellLeftBorderStyle; |
1262 | case QCss::RightEdge: |
1263 | return QTextFormat::TableCellRightBorderStyle; |
1264 | default: |
1265 | Q_UNREACHABLE(); |
1266 | return QTextFormat::UserProperty; |
1267 | } |
1268 | } |
1269 | |
1270 | static inline QCss::Edge adjacentEdge(QCss::Edge edge) |
1271 | { |
1272 | switch (edge) { |
1273 | case QCss::TopEdge: |
1274 | return QCss::BottomEdge; |
1275 | case QCss::RightEdge: |
1276 | return QCss::LeftEdge; |
1277 | case QCss::BottomEdge: |
1278 | return QCss::TopEdge; |
1279 | case QCss::LeftEdge: |
1280 | return QCss::RightEdge; |
1281 | default: |
1282 | Q_UNREACHABLE(); |
1283 | return QCss::NumEdges; |
1284 | } |
1285 | } |
1286 | |
1287 | static inline bool isSameAxis(QCss::Edge e1, QCss::Edge e2) |
1288 | { |
1289 | return e1 == e2 || e1 == adjacentEdge(edge: e2); |
1290 | } |
1291 | |
1292 | static inline bool isVerticalAxis(QCss::Edge e) |
1293 | { |
1294 | return e % 2 > 0; |
1295 | } |
1296 | |
1297 | static inline QTextTableCell adjacentCell(QTextTable *table, const QTextTableCell &cell, |
1298 | QCss::Edge edge) |
1299 | { |
1300 | int dc = 0; |
1301 | int dr = 0; |
1302 | |
1303 | switch (edge) { |
1304 | case QCss::LeftEdge: |
1305 | dc = -1; |
1306 | break; |
1307 | case QCss::RightEdge: |
1308 | dc = cell.columnSpan(); |
1309 | break; |
1310 | case QCss::TopEdge: |
1311 | dr = -1; |
1312 | break; |
1313 | case QCss::BottomEdge: |
1314 | dr = cell.rowSpan(); |
1315 | break; |
1316 | default: |
1317 | Q_UNREACHABLE(); |
1318 | break; |
1319 | } |
1320 | |
1321 | // get sibling cell |
1322 | int col = cell.column() + dc; |
1323 | int row = cell.row() + dr; |
1324 | |
1325 | if (col < 0 || row < 0 || col >= table->columns() || row >= table->rows()) |
1326 | return QTextTableCell(); |
1327 | else |
1328 | return table->cellAt(row: cell.row() + dr, col: cell.column() + dc); |
1329 | } |
1330 | |
1331 | // returns true if the specified edges of both cells |
1332 | // are "one the same line" aka axis. |
1333 | // |
1334 | // | C0 |
1335 | // |-----|-----|----|----- < "axis" |
1336 | // | C1 | C2 | C3 | C4 |
1337 | // |
1338 | // cell edge competingCell competingEdge result |
1339 | // C0 Left C1 Left true |
1340 | // C0 Left C2 Left false |
1341 | // C0 Bottom C2 Top true |
1342 | // C0 Bottom C4 Left INVALID |
1343 | static inline bool sharesAxis(const QTextTableCell &cell, QCss::Edge edge, |
1344 | const QTextTableCell &competingCell, QCss::Edge competingCellEdge) |
1345 | { |
1346 | Q_ASSERT(isVerticalAxis(edge) == isVerticalAxis(competingCellEdge)); |
1347 | |
1348 | switch (edge) { |
1349 | case QCss::TopEdge: |
1350 | return cell.row() == |
1351 | competingCell.row() + (competingCellEdge == QCss::BottomEdge ? competingCell.rowSpan() : 0); |
1352 | case QCss::BottomEdge: |
1353 | return cell.row() + cell.rowSpan() == |
1354 | competingCell.row() + (competingCellEdge == QCss::TopEdge ? 0 : competingCell.rowSpan()); |
1355 | case QCss::LeftEdge: |
1356 | return cell.column() == |
1357 | competingCell.column() + (competingCellEdge == QCss::RightEdge ? competingCell.columnSpan() : 0); |
1358 | case QCss::RightEdge: |
1359 | return cell.column() + cell.columnSpan() == |
1360 | competingCell.column() + (competingCellEdge == QCss::LeftEdge ? 0 : competingCell.columnSpan()); |
1361 | default: |
1362 | Q_UNREACHABLE(); |
1363 | return false; |
1364 | } |
1365 | } |
1366 | |
1367 | // returns the applicable EdgeData for the given cell and edge. |
1368 | // this is either set explicitly by the cell's format, an activated grid |
1369 | // or the general table border width for outermost edges. |
1370 | static inline EdgeData cellEdgeData(QTextTable *table, const QTextTableData *td, |
1371 | const QTextTableCell &cell, QCss::Edge edge) |
1372 | { |
1373 | if (!cell.isValid()) { |
1374 | // e.g. non-existing adjacent cell |
1375 | return EdgeData(); |
1376 | } |
1377 | |
1378 | QTextTableCellFormat f = cell.format().toTableCellFormat(); |
1379 | if (f.hasProperty(propertyId: borderStylePropertyForEdge(edge))) { |
1380 | // border style is set |
1381 | double width = 3; // default to 3 like browsers do |
1382 | if (f.hasProperty(propertyId: borderPropertyForEdge(edge))) |
1383 | width = f.property(propertyId: borderPropertyForEdge(edge)).toDouble(); |
1384 | return EdgeData(width, cell, edge, EdgeData::ClassExplicit); |
1385 | } else if (td->drawGrid) { |
1386 | const bool outermost = |
1387 | (edge == QCss::LeftEdge && cell.column() == 0) || |
1388 | (edge == QCss::TopEdge && cell.row() == 0) || |
1389 | (edge == QCss::RightEdge && cell.column() + cell.columnSpan() >= table->columns()) || |
1390 | (edge == QCss::BottomEdge && cell.row() + cell.rowSpan() >= table->rows()); |
1391 | |
1392 | if (outermost) { |
1393 | qreal border = table->format().border(); |
1394 | if (border > 1.0) { |
1395 | // table border |
1396 | return EdgeData(border, cell, edge, EdgeData::ClassTableBorder); |
1397 | } |
1398 | } |
1399 | // 1px clean grid |
1400 | return EdgeData(1.0, cell, edge, EdgeData::ClassGrid); |
1401 | } |
1402 | else { |
1403 | return EdgeData(0, cell, edge, EdgeData::ClassNone); |
1404 | } |
1405 | } |
1406 | |
1407 | // returns the EdgeData with the larger width of either the cell's edge its adjacent cell's edge |
1408 | static inline EdgeData axisEdgeData(QTextTable *table, const QTextTableData *td, |
1409 | const QTextTableCell &cell, QCss::Edge edge) |
1410 | { |
1411 | Q_ASSERT(cell.isValid()); |
1412 | |
1413 | EdgeData result = cellEdgeData(table, td, cell, edge); |
1414 | if (!td->borderCollapse) |
1415 | return result; |
1416 | |
1417 | QTextTableCell ac = adjacentCell(table, cell, edge); |
1418 | result = qMax(a: result, b: cellEdgeData(table, td, cell: ac, edge: adjacentEdge(edge))); |
1419 | |
1420 | bool mustCheckThirdCell = false; |
1421 | if (ac.isValid()) { |
1422 | /* if C0 and C3 don't share the left/top axis, we must |
1423 | * also check C1. |
1424 | * |
1425 | * C0 and C4 don't share the left axis so we have |
1426 | * to take the top edge of C1 (T1) into account |
1427 | * because this might be wider than C0's bottom |
1428 | * edge (B0). For the sake of simplicity we skip |
1429 | * checking T2 and T3. |
1430 | * |
1431 | * | C0 |
1432 | * |-----|-----|----|----- |
1433 | * | C1 | C2 | C3 | C4 |
1434 | * |
1435 | * width(T4) = max(T4, B0, T1) (T2 and T3 won't be checked) |
1436 | */ |
1437 | switch (edge) { |
1438 | case QCss::TopEdge: |
1439 | case QCss::BottomEdge: |
1440 | mustCheckThirdCell = !sharesAxis(cell, edge: QCss::LeftEdge, competingCell: ac, competingCellEdge: QCss::LeftEdge); |
1441 | break; |
1442 | case QCss::LeftEdge: |
1443 | case QCss::RightEdge: |
1444 | mustCheckThirdCell = !sharesAxis(cell, edge: QCss::TopEdge, competingCell: ac, competingCellEdge: QCss::TopEdge); |
1445 | break; |
1446 | default: |
1447 | Q_UNREACHABLE(); |
1448 | break; |
1449 | } |
1450 | } |
1451 | |
1452 | if (mustCheckThirdCell) |
1453 | result = qMax(a: result, b: cellEdgeData(table, td, cell: adjacentCell(table, cell: ac, edge: adjacentEdge(edge)), edge)); |
1454 | |
1455 | return result; |
1456 | } |
1457 | |
1458 | // checks an edge's joined competing edge according to priority rules and |
1459 | // adjusts maxCompetingEdgeData and maxOrthogonalEdgeData |
1460 | static inline void checkJoinedEdge(QTextTable *table, const QTextTableData *td, const QTextTableCell &cell, |
1461 | QCss::Edge competingEdge, |
1462 | const EdgeData &edgeData, |
1463 | bool couldHaveContinuation, |
1464 | EdgeData *maxCompetingEdgeData, |
1465 | EdgeData *maxOrthogonalEdgeData) |
1466 | { |
1467 | EdgeData competingEdgeData = axisEdgeData(table, td, cell, edge: competingEdge); |
1468 | |
1469 | if (competingEdgeData > edgeData) { |
1470 | *maxCompetingEdgeData = competingEdgeData; |
1471 | } else if (competingEdgeData.width == edgeData.width) { |
1472 | if ((isSameAxis(e1: edgeData.edge, e2: competingEdge) && couldHaveContinuation) |
1473 | || (!isVerticalAxis(e: edgeData.edge) && isVerticalAxis(e: competingEdge)) /* both widths are equal, vertical edge has priority */ ) { |
1474 | *maxCompetingEdgeData = competingEdgeData; |
1475 | } |
1476 | } |
1477 | |
1478 | if (maxOrthogonalEdgeData && competingEdgeData.width > maxOrthogonalEdgeData->width) |
1479 | *maxOrthogonalEdgeData = competingEdgeData; |
1480 | } |
1481 | |
1482 | // the offset to make adjacent edges overlap in border collapse mode |
1483 | static inline qreal collapseOffset(const QTextDocumentLayoutPrivate *p, const EdgeData &w) |
1484 | { |
1485 | return p->scaleToDevice(value: w.width) / 2.0; |
1486 | } |
1487 | |
1488 | // returns the offset that must be applied to the edge's |
1489 | // anchor (start point or end point) to avoid overlapping edges. |
1490 | // |
1491 | // Example 1: |
1492 | // 2 |
1493 | // 2 |
1494 | // 11111144444444 4 = top edge of cell, 4 pixels width |
1495 | // 3 3 = right edge of cell, 3 pixels width |
1496 | // 3 cell 4 |
1497 | // |
1498 | // cell 4's top border is the widest border and will be |
1499 | // drawn with horiz. offset = -3/2 whereas its left border |
1500 | // of width 3 will be drawn with vert. offset = +4/2. |
1501 | // |
1502 | // Example 2: |
1503 | // 2 |
1504 | // 2 |
1505 | // 11111143333333 |
1506 | // 4 |
1507 | // 4 cell 4 |
1508 | // |
1509 | // cell 4's left border is the widest and will be drawn |
1510 | // with vert. offset = -3/2 whereas its top border |
1511 | // of of width 3 will be drawn with hor. offset = +4/2. |
1512 | // |
1513 | // couldHaveContinuation: true for "end" anchor of an edge: |
1514 | // C |
1515 | // AAAAABBBBBB |
1516 | // D |
1517 | // width(A) == width(B) we consider B to be a continuation of A, so that B wins |
1518 | // and will be painted. A would only be painted including the right anchor if |
1519 | // there was no edge B (due to a rowspan or the axis C-D being the table's right |
1520 | // border). |
1521 | // |
1522 | // ignoreEdgesAbove: true if an egde (left, right or top) for the first row |
1523 | // after a table page break should be painted. In this case the edges of the |
1524 | // row above must be ignored. |
1525 | static inline double prioritizedEdgeAnchorOffset(const QTextDocumentLayoutPrivate *p, |
1526 | QTextTable *table, const QTextTableData *td, |
1527 | const QTextTableCell &cell, |
1528 | const EdgeData &edgeData, |
1529 | QCss::Edge orthogonalEdge, |
1530 | bool couldHaveContinuation, |
1531 | bool ignoreEdgesAbove) |
1532 | { |
1533 | EdgeData maxCompetingEdgeData; |
1534 | EdgeData maxOrthogonalEdgeData; |
1535 | QTextTableCell competingCell; |
1536 | |
1537 | // reference scenario for the inline comments: |
1538 | // - edgeData being the top "T0" edge of C0 |
1539 | // - right anchor is '+', orthogonal edge is "R0" |
1540 | // B C3 R|L C2 B |
1541 | // ------+------ |
1542 | // T C0 R|L C1 T |
1543 | |
1544 | // C0: T0/B3 |
1545 | // this is "edgeData" |
1546 | |
1547 | // C0: R0/L1 |
1548 | checkJoinedEdge(table, td, cell, competingEdge: orthogonalEdge, edgeData, couldHaveContinuation: false, |
1549 | maxCompetingEdgeData: &maxCompetingEdgeData, maxOrthogonalEdgeData: &maxOrthogonalEdgeData); |
1550 | |
1551 | if (td->borderCollapse) { |
1552 | // C1: T1/B2 |
1553 | if (!isVerticalAxis(e: edgeData.edge) || !ignoreEdgesAbove) { |
1554 | competingCell = adjacentCell(table, cell, edge: orthogonalEdge); |
1555 | if (competingCell.isValid()) { |
1556 | checkJoinedEdge(table, td, cell: competingCell, competingEdge: edgeData.edge, edgeData, couldHaveContinuation, |
1557 | maxCompetingEdgeData: &maxCompetingEdgeData, maxOrthogonalEdgeData: nullptr); |
1558 | } |
1559 | } |
1560 | |
1561 | // C3: R3/L2 |
1562 | if (edgeData.edge != QCss::TopEdge || !ignoreEdgesAbove) { |
1563 | competingCell = adjacentCell(table, cell, edge: edgeData.edge); |
1564 | if (competingCell.isValid() && sharesAxis(cell, edge: orthogonalEdge, competingCell, competingCellEdge: orthogonalEdge)) { |
1565 | checkJoinedEdge(table, td, cell: competingCell, competingEdge: orthogonalEdge, edgeData, couldHaveContinuation: false, |
1566 | maxCompetingEdgeData: &maxCompetingEdgeData, maxOrthogonalEdgeData: &maxOrthogonalEdgeData); |
1567 | } |
1568 | } |
1569 | } |
1570 | |
1571 | // wider edge has priority |
1572 | bool hasPriority = edgeData > maxCompetingEdgeData; |
1573 | |
1574 | if (td->borderCollapse) { |
1575 | qreal offset = collapseOffset(p, w: maxOrthogonalEdgeData); |
1576 | return hasPriority ? -offset : offset; |
1577 | } |
1578 | else |
1579 | return hasPriority ? 0 : p->scaleToDevice(value: maxOrthogonalEdgeData.width); |
1580 | } |
1581 | |
1582 | // draw one edge of the given cell |
1583 | // |
1584 | // these options are for pagination / pagebreak handling: |
1585 | // |
1586 | // forceHeaderRow: true for all rows directly below a (repeated) header row. |
1587 | // if the table has headers the first row after a page break must check against |
1588 | // the last table header's row, not its actual predecessor. |
1589 | // |
1590 | // adjustTopAnchor: false for rows that are a continuation of a row after a page break |
1591 | // only evaluated for left/right edges |
1592 | // |
1593 | // adjustBottomAnchor: false for rows that will continue after a page break |
1594 | // only evaluated for left/right edges |
1595 | // |
1596 | // ignoreEdgesAbove: true if a row starts on top of the page and the |
1597 | // bottom edges of the prior row can therefore be ignored. |
1598 | static inline |
1599 | void drawCellBorder(const QTextDocumentLayoutPrivate *p, QPainter *painter, |
1600 | QTextTable *table, const QTextTableData *td, const QTextTableCell &cell, |
1601 | const QRectF &borderRect, QCss::Edge edge, |
1602 | int , bool adjustTopAnchor, bool adjustBottomAnchor, |
1603 | bool ignoreEdgesAbove) |
1604 | { |
1605 | QPointF p1, p2; |
1606 | qreal wh = 0; |
1607 | qreal wv = 0; |
1608 | EdgeData edgeData = axisEdgeData(table, td, cell, edge); |
1609 | |
1610 | if (edgeData.width == 0) |
1611 | return; |
1612 | |
1613 | QTextTableCellFormat fmt = edgeData.cell.format().toTableCellFormat(); |
1614 | QTextFrameFormat::BorderStyle borderStyle = QTextFrameFormat::BorderStyle_None; |
1615 | QBrush brush; |
1616 | |
1617 | if (edgeData.edgeClass != EdgeData::ClassExplicit && td->drawGrid) { |
1618 | borderStyle = QTextFrameFormat::BorderStyle_Solid; |
1619 | brush = table->format().borderBrush(); |
1620 | } |
1621 | else { |
1622 | switch (edgeData.edge) { |
1623 | case QCss::TopEdge: |
1624 | brush = fmt.topBorderBrush(); |
1625 | borderStyle = fmt.topBorderStyle(); |
1626 | break; |
1627 | case QCss::BottomEdge: |
1628 | brush = fmt.bottomBorderBrush(); |
1629 | borderStyle = fmt.bottomBorderStyle(); |
1630 | break; |
1631 | case QCss::LeftEdge: |
1632 | brush = fmt.leftBorderBrush(); |
1633 | borderStyle = fmt.leftBorderStyle(); |
1634 | break; |
1635 | case QCss::RightEdge: |
1636 | brush = fmt.rightBorderBrush(); |
1637 | borderStyle = fmt.rightBorderStyle(); |
1638 | break; |
1639 | default: |
1640 | Q_UNREACHABLE(); |
1641 | break; |
1642 | } |
1643 | } |
1644 | |
1645 | if (borderStyle == QTextFrameFormat::BorderStyle_None) |
1646 | return; |
1647 | |
1648 | // assume black if not explicit brush is set |
1649 | if (brush.style() == Qt::NoBrush) |
1650 | brush = Qt::black; |
1651 | |
1652 | QTextTableCell = cell; |
1653 | if (forceHeaderRow != -1) |
1654 | cellOrHeader = table->cellAt(row: forceHeaderRow, col: cell.column()); |
1655 | |
1656 | // adjust start and end anchors (e.g. left/right for top) according to priority rules |
1657 | switch (edge) { |
1658 | case QCss::TopEdge: |
1659 | wv = p->scaleToDevice(value: edgeData.width); |
1660 | p1 = borderRect.topLeft() |
1661 | + QPointF(qFloor(v: prioritizedEdgeAnchorOffset(p, table, td, cell, edgeData, orthogonalEdge: QCss::LeftEdge, couldHaveContinuation: false, ignoreEdgesAbove)), 0); |
1662 | p2 = borderRect.topRight() |
1663 | + QPointF(-qCeil(v: prioritizedEdgeAnchorOffset(p, table, td, cell, edgeData, orthogonalEdge: QCss::RightEdge, couldHaveContinuation: true, ignoreEdgesAbove)), 0); |
1664 | break; |
1665 | case QCss::BottomEdge: |
1666 | wv = p->scaleToDevice(value: edgeData.width); |
1667 | p1 = borderRect.bottomLeft() |
1668 | + QPointF(qFloor(v: prioritizedEdgeAnchorOffset(p, table, td, cell, edgeData, orthogonalEdge: QCss::LeftEdge, couldHaveContinuation: false, ignoreEdgesAbove: false)), -wv); |
1669 | p2 = borderRect.bottomRight() |
1670 | + QPointF(-qCeil(v: prioritizedEdgeAnchorOffset(p, table, td, cell, edgeData, orthogonalEdge: QCss::RightEdge, couldHaveContinuation: true, ignoreEdgesAbove: false)), -wv); |
1671 | break; |
1672 | case QCss::LeftEdge: |
1673 | wh = p->scaleToDevice(value: edgeData.width); |
1674 | p1 = borderRect.topLeft() |
1675 | + QPointF(0, adjustTopAnchor ? qFloor(v: prioritizedEdgeAnchorOffset(p, table, td, cell: cellOrHeader, edgeData, |
1676 | orthogonalEdge: forceHeaderRow != -1 ? QCss::BottomEdge : QCss::TopEdge, |
1677 | couldHaveContinuation: false, ignoreEdgesAbove)) |
1678 | : 0); |
1679 | p2 = borderRect.bottomLeft() |
1680 | + QPointF(0, adjustBottomAnchor ? -qCeil(v: prioritizedEdgeAnchorOffset(p, table, td, cell, edgeData, orthogonalEdge: QCss::BottomEdge, couldHaveContinuation: true, ignoreEdgesAbove: false)) |
1681 | : 0); |
1682 | break; |
1683 | case QCss::RightEdge: |
1684 | wh = p->scaleToDevice(value: edgeData.width); |
1685 | p1 = borderRect.topRight() |
1686 | + QPointF(-wh, adjustTopAnchor ? qFloor(v: prioritizedEdgeAnchorOffset(p, table, td, cell: cellOrHeader, edgeData, |
1687 | orthogonalEdge: forceHeaderRow != -1 ? QCss::BottomEdge : QCss::TopEdge, |
1688 | couldHaveContinuation: false, ignoreEdgesAbove)) |
1689 | : 0); |
1690 | p2 = borderRect.bottomRight() |
1691 | + QPointF(-wh, adjustBottomAnchor ? -qCeil(v: prioritizedEdgeAnchorOffset(p, table, td, cell, edgeData, orthogonalEdge: QCss::BottomEdge, couldHaveContinuation: true, ignoreEdgesAbove: false)) |
1692 | : 0); |
1693 | break; |
1694 | default: break; |
1695 | } |
1696 | |
1697 | // for borderCollapse move edge width/2 pixel out of the borderRect |
1698 | // so that it shares space with the adjacent cell's edge. |
1699 | // to avoid fractional offsets, qCeil/qFloor is used |
1700 | if (td->borderCollapse) { |
1701 | QPointF offset; |
1702 | switch (edge) { |
1703 | case QCss::TopEdge: |
1704 | offset = QPointF(0, -qCeil(v: collapseOffset(p, w: edgeData))); |
1705 | break; |
1706 | case QCss::BottomEdge: |
1707 | offset = QPointF(0, qFloor(v: collapseOffset(p, w: edgeData))); |
1708 | break; |
1709 | case QCss::LeftEdge: |
1710 | offset = QPointF(-qCeil(v: collapseOffset(p, w: edgeData)), 0); |
1711 | break; |
1712 | case QCss::RightEdge: |
1713 | offset = QPointF(qFloor(v: collapseOffset(p, w: edgeData)), 0); |
1714 | break; |
1715 | default: break; |
1716 | } |
1717 | p1 += offset; |
1718 | p2 += offset; |
1719 | } |
1720 | |
1721 | QCss::BorderStyle cssStyle = static_cast<QCss::BorderStyle>(borderStyle + 1); |
1722 | |
1723 | // this reveals errors in the drawing logic |
1724 | #ifdef COLLAPSE_DEBUG |
1725 | QColor c = brush.color(); |
1726 | c.setAlpha(150); |
1727 | brush.setColor(c); |
1728 | #endif |
1729 | |
1730 | qDrawEdge(p: painter, x1: p1.x(), y1: p1.y(), x2: p2.x() + wh, y2: p2.y() + wv, dw1: 0, dw2: 0, edge, style: cssStyle, c: brush); |
1731 | } |
1732 | #endif |
1733 | |
1734 | void QTextDocumentLayoutPrivate::drawTableCellBorder(const QRectF &cellRect, QPainter *painter, |
1735 | QTextTable *table, QTextTableData *td, |
1736 | const QTextTableCell &cell) const |
1737 | { |
1738 | #ifndef QT_NO_CSSPARSER |
1739 | qreal topMarginAfterPageBreak = (td->effectiveTopMargin + td->cellSpacing + td->border).toReal(); |
1740 | qreal bottomMargin = (td->effectiveBottomMargin + td->cellSpacing + td->border).toReal(); |
1741 | |
1742 | const int = qMin(a: table->format().headerRowCount(), b: table->rows() - 1); |
1743 | if (headerRowCount > 0 && cell.row() >= headerRowCount) |
1744 | topMarginAfterPageBreak += td->headerHeight.toReal(); |
1745 | |
1746 | BorderPaginator paginator(document, cellRect, topMarginAfterPageBreak, bottomMargin, 0); |
1747 | |
1748 | bool turn_off_antialiasing = !(painter->renderHints() & QPainter::Antialiasing); |
1749 | painter->setRenderHint(hint: QPainter::Antialiasing); |
1750 | |
1751 | // paint cell borders for every page the cell appears on |
1752 | for (int page = paginator.topPage; page <= paginator.bottomPage; ++page) { |
1753 | const QRectF clipped = paginator.clipRect(page); |
1754 | if (!clipped.isValid()) |
1755 | continue; |
1756 | |
1757 | const qreal offset = cellRect.top() - td->rowPositions.at(i: cell.row()).toReal(); |
1758 | const int = table->format().headerRowCount() - 1; |
1759 | const bool = table->format().headerRowCount() > 0; |
1760 | const bool = cell.row() < table->format().headerRowCount(); |
1761 | const bool isFirstRow = cell.row() == lastHeaderRow + 1; |
1762 | const bool isLastRow = cell.row() + cell.rowSpan() >= table->rows(); |
1763 | const bool previousRowOnPreviousPage = !isFirstRow |
1764 | && !isHeaderRow |
1765 | && BorderPaginator(document, |
1766 | td->cellRect(cell: adjacentCell(table, cell, edge: QCss::TopEdge)).translated(dx: 0, dy: offset), |
1767 | topMarginAfterPageBreak, |
1768 | bottomMargin, |
1769 | 0).bottomPage < page; |
1770 | const bool nextRowOnNextPage = !isLastRow |
1771 | && BorderPaginator(document, |
1772 | td->cellRect(cell: adjacentCell(table, cell, edge: QCss::BottomEdge)).translated(dx: 0, dy: offset), |
1773 | topMarginAfterPageBreak, |
1774 | bottomMargin, |
1775 | 0).topPage > page; |
1776 | const bool rowStartsOnPage = page == paginator.topPage; |
1777 | const bool rowEndsOnPage = page == paginator.bottomPage; |
1778 | const bool rowStartsOnPageTop = !tableHasHeader |
1779 | && rowStartsOnPage |
1780 | && previousRowOnPreviousPage; |
1781 | const bool = tableHasHeader |
1782 | && rowStartsOnPage |
1783 | && previousRowOnPreviousPage; |
1784 | |
1785 | const bool suppressTopBorder = td->borderCollapse |
1786 | ? !isHeaderRow && (!rowStartsOnPage || rowStartsOnPageBelowHeader) |
1787 | : !rowStartsOnPage; |
1788 | const bool suppressBottomBorder = td->borderCollapse |
1789 | ? !isHeaderRow && (!rowEndsOnPage || nextRowOnNextPage) |
1790 | : !rowEndsOnPage; |
1791 | const bool doNotAdjustTopAnchor = td->borderCollapse |
1792 | ? !tableHasHeader && !rowStartsOnPage |
1793 | : !rowStartsOnPage; |
1794 | const bool doNotAdjustBottomAnchor = suppressBottomBorder; |
1795 | |
1796 | if (!suppressTopBorder) { |
1797 | drawCellBorder(p: this, painter, table, td, cell, borderRect: clipped, edge: QCss::TopEdge, |
1798 | forceHeaderRow: -1, adjustTopAnchor: true, adjustBottomAnchor: true, ignoreEdgesAbove: rowStartsOnPageTop); |
1799 | } |
1800 | |
1801 | drawCellBorder(p: this, painter, table, td, cell, borderRect: clipped, edge: QCss::LeftEdge, |
1802 | forceHeaderRow: suppressTopBorder ? lastHeaderRow : -1, |
1803 | adjustTopAnchor: !doNotAdjustTopAnchor, |
1804 | adjustBottomAnchor: !doNotAdjustBottomAnchor, |
1805 | ignoreEdgesAbove: rowStartsOnPageTop); |
1806 | drawCellBorder(p: this, painter, table, td, cell, borderRect: clipped, edge: QCss::RightEdge, |
1807 | forceHeaderRow: suppressTopBorder ? lastHeaderRow : -1, |
1808 | adjustTopAnchor: !doNotAdjustTopAnchor, |
1809 | adjustBottomAnchor: !doNotAdjustBottomAnchor, |
1810 | ignoreEdgesAbove: rowStartsOnPageTop); |
1811 | |
1812 | if (!suppressBottomBorder) { |
1813 | drawCellBorder(p: this, painter, table, td, cell, borderRect: clipped, edge: QCss::BottomEdge, |
1814 | forceHeaderRow: -1, adjustTopAnchor: true, adjustBottomAnchor: true, ignoreEdgesAbove: false); |
1815 | } |
1816 | } |
1817 | |
1818 | if (turn_off_antialiasing) |
1819 | painter->setRenderHint(hint: QPainter::Antialiasing, on: false); |
1820 | #else |
1821 | Q_UNUSED(cell); |
1822 | Q_UNUSED(cellRect); |
1823 | Q_UNUSED(painter); |
1824 | Q_UNUSED(table); |
1825 | Q_UNUSED(td); |
1826 | Q_UNUSED(cell); |
1827 | #endif |
1828 | } |
1829 | |
1830 | void QTextDocumentLayoutPrivate::drawTableCell(const QRectF &cellRect, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &cell_context, |
1831 | QTextTable *table, QTextTableData *td, int r, int c, |
1832 | QTextBlock *cursorBlockNeedingRepaint, QPointF *cursorBlockOffset) const |
1833 | { |
1834 | QTextTableCell cell = table->cellAt(row: r, col: c); |
1835 | int rspan = cell.rowSpan(); |
1836 | int cspan = cell.columnSpan(); |
1837 | if (rspan != 1) { |
1838 | int cr = cell.row(); |
1839 | if (cr != r) |
1840 | return; |
1841 | } |
1842 | if (cspan != 1) { |
1843 | int cc = cell.column(); |
1844 | if (cc != c) |
1845 | return; |
1846 | } |
1847 | |
1848 | const QFixed leftPadding = td->leftPadding(table, cell); |
1849 | const QFixed topPadding = td->topPadding(table, cell); |
1850 | |
1851 | qreal topMargin = (td->effectiveTopMargin + td->cellSpacing + td->border).toReal(); |
1852 | qreal bottomMargin = (td->effectiveBottomMargin + td->cellSpacing + td->border).toReal(); |
1853 | |
1854 | const int = qMin(a: table->format().headerRowCount(), b: table->rows() - 1); |
1855 | if (r >= headerRowCount) |
1856 | topMargin += td->headerHeight.toReal(); |
1857 | |
1858 | if (!td->borderCollapse && td->border != 0) { |
1859 | const QBrush oldBrush = painter->brush(); |
1860 | const QPen oldPen = painter->pen(); |
1861 | |
1862 | const qreal border = td->border.toReal(); |
1863 | |
1864 | QRectF borderRect(cellRect.left() - border, cellRect.top() - border, cellRect.width() + border, cellRect.height() + border); |
1865 | |
1866 | // invert the border style for cells |
1867 | QTextFrameFormat::BorderStyle cellBorder = table->format().borderStyle(); |
1868 | switch (cellBorder) { |
1869 | case QTextFrameFormat::BorderStyle_Inset: |
1870 | cellBorder = QTextFrameFormat::BorderStyle_Outset; |
1871 | break; |
1872 | case QTextFrameFormat::BorderStyle_Outset: |
1873 | cellBorder = QTextFrameFormat::BorderStyle_Inset; |
1874 | break; |
1875 | case QTextFrameFormat::BorderStyle_Groove: |
1876 | cellBorder = QTextFrameFormat::BorderStyle_Ridge; |
1877 | break; |
1878 | case QTextFrameFormat::BorderStyle_Ridge: |
1879 | cellBorder = QTextFrameFormat::BorderStyle_Groove; |
1880 | break; |
1881 | default: |
1882 | break; |
1883 | } |
1884 | |
1885 | drawBorder(painter, rect: borderRect, topMargin, bottomMargin, |
1886 | border, brush: table->format().borderBrush(), style: cellBorder); |
1887 | |
1888 | painter->setBrush(oldBrush); |
1889 | painter->setPen(oldPen); |
1890 | } |
1891 | |
1892 | const QBrush bg = cell.format().background(); |
1893 | const QPointF brushOrigin = painter->brushOrigin(); |
1894 | if (bg.style() != Qt::NoBrush) { |
1895 | const qreal pageHeight = document->pageSize().height(); |
1896 | const int topPage = pageHeight > 0 ? static_cast<int>(cellRect.top() / pageHeight) : 0; |
1897 | const int bottomPage = pageHeight > 0 ? static_cast<int>((cellRect.bottom()) / pageHeight) : 0; |
1898 | |
1899 | if (topPage == bottomPage) |
1900 | fillBackground(p: painter, rect: cellRect, brush: bg, origin: cellRect.topLeft()); |
1901 | else { |
1902 | for (int i = topPage; i <= bottomPage; ++i) { |
1903 | QRectF clipped = cellRect.toRect(); |
1904 | |
1905 | if (topPage != bottomPage) { |
1906 | const qreal top = qMax(a: i * pageHeight + topMargin, b: cell_context.clip.top()); |
1907 | const qreal bottom = qMin(a: (i + 1) * pageHeight - bottomMargin, b: cell_context.clip.bottom()); |
1908 | |
1909 | clipped.setTop(qMax(a: clipped.top(), b: top)); |
1910 | clipped.setBottom(qMin(a: clipped.bottom(), b: bottom)); |
1911 | |
1912 | if (clipped.bottom() <= clipped.top()) |
1913 | continue; |
1914 | |
1915 | fillBackground(p: painter, rect: clipped, brush: bg, origin: cellRect.topLeft()); |
1916 | } |
1917 | } |
1918 | } |
1919 | |
1920 | if (bg.style() > Qt::SolidPattern) |
1921 | painter->setBrushOrigin(cellRect.topLeft()); |
1922 | } |
1923 | |
1924 | // paint over the background - otherwise we would have to adjust the background paint cellRect for the border values |
1925 | drawTableCellBorder(cellRect, painter, table, td, cell); |
1926 | |
1927 | const QFixed verticalOffset = td->cellVerticalOffsets.at(i: c + r * table->columns()); |
1928 | |
1929 | const QPointF cellPos = QPointF(cellRect.left() + leftPadding.toReal(), |
1930 | cellRect.top() + (topPadding + verticalOffset).toReal()); |
1931 | |
1932 | QTextBlock repaintBlock; |
1933 | drawFlow(offset: cellPos, painter, context: cell_context, it: cell.begin(), |
1934 | floats: td->childFrameMap.values(akey: r + c * table->rows()), |
1935 | cursorBlockNeedingRepaint: &repaintBlock); |
1936 | if (repaintBlock.isValid()) { |
1937 | *cursorBlockNeedingRepaint = repaintBlock; |
1938 | *cursorBlockOffset = cellPos; |
1939 | } |
1940 | |
1941 | if (bg.style() > Qt::SolidPattern) |
1942 | painter->setBrushOrigin(brushOrigin); |
1943 | } |
1944 | |
1945 | void QTextDocumentLayoutPrivate::drawFlow(const QPointF &offset, QPainter *painter, const QAbstractTextDocumentLayout::PaintContext &context, |
1946 | QTextFrame::Iterator it, const QList<QTextFrame *> &floats, QTextBlock *cursorBlockNeedingRepaint) const |
1947 | { |
1948 | Q_Q(const QTextDocumentLayout); |
1949 | const bool inRootFrame = (!it.atEnd() && it.parentFrame() && it.parentFrame()->parentFrame() == nullptr); |
1950 | |
1951 | QVector<QCheckPoint>::ConstIterator lastVisibleCheckPoint = checkPoints.end(); |
1952 | if (inRootFrame && context.clip.isValid()) { |
1953 | lastVisibleCheckPoint = std::lower_bound(checkPoints.begin(), checkPoints.end(), QFixed::fromReal(r: context.clip.bottom())); |
1954 | } |
1955 | |
1956 | QTextBlock previousBlock; |
1957 | QTextFrame *previousFrame = nullptr; |
1958 | |
1959 | for (; !it.atEnd(); ++it) { |
1960 | QTextFrame *c = it.currentFrame(); |
1961 | |
1962 | if (inRootFrame && !checkPoints.isEmpty()) { |
1963 | int currentPosInDoc; |
1964 | if (c) |
1965 | currentPosInDoc = c->firstPosition(); |
1966 | else |
1967 | currentPosInDoc = it.currentBlock().position(); |
1968 | |
1969 | // if we're past what is already laid out then we're better off |
1970 | // not trying to draw things that may not be positioned correctly yet |
1971 | if (currentPosInDoc >= checkPoints.constLast().positionInFrame) |
1972 | break; |
1973 | |
1974 | if (lastVisibleCheckPoint != checkPoints.end() |
1975 | && context.clip.isValid() |
1976 | && currentPosInDoc >= lastVisibleCheckPoint->positionInFrame |
1977 | ) |
1978 | break; |
1979 | } |
1980 | |
1981 | if (c) |
1982 | drawFrame(offset, painter, context, frame: c); |
1983 | else { |
1984 | QAbstractTextDocumentLayout::PaintContext pc = context; |
1985 | if (isEmptyBlockAfterTable(block: it.currentBlock(), previousFrame)) |
1986 | pc.selections.clear(); |
1987 | drawBlock(offset, painter, context: pc, bl: it.currentBlock(), inRootFrame); |
1988 | } |
1989 | |
1990 | // when entering a table and the previous block is empty |
1991 | // then layoutFlow 'hides' the block that just causes a |
1992 | // new line by positioning it /on/ the table border. as we |
1993 | // draw that block before the table itself the decoration |
1994 | // 'overpaints' the cursor and we need to paint it afterwards |
1995 | // again |
1996 | if (isEmptyBlockBeforeTable(block: previousBlock, format: previousBlock.blockFormat(), nextIt: it) |
1997 | && previousBlock.contains(position: context.cursorPosition) |
1998 | ) { |
1999 | *cursorBlockNeedingRepaint = previousBlock; |
2000 | } |
2001 | |
2002 | previousBlock = it.currentBlock(); |
2003 | previousFrame = c; |
2004 | } |
2005 | |
2006 | for (int i = 0; i < floats.count(); ++i) { |
2007 | QTextFrame *frame = floats.at(i); |
2008 | if (!isFrameFromInlineObject(f: frame) |
2009 | || frame->frameFormat().position() == QTextFrameFormat::InFlow) |
2010 | continue; |
2011 | |
2012 | const int pos = frame->firstPosition() - 1; |
2013 | QTextCharFormat format = const_cast<QTextDocumentLayout *>(q)->format(pos); |
2014 | QTextObjectInterface *handler = q->handlerForObject(objectType: format.objectType()); |
2015 | if (handler) { |
2016 | QRectF rect = frameBoundingRectInternal(frame); |
2017 | handler->drawObject(painter, rect, doc: document, posInDocument: pos, format); |
2018 | } |
2019 | } |
2020 | } |
2021 | |
2022 | void QTextDocumentLayoutPrivate::drawBlock(const QPointF &offset, QPainter *painter, |
2023 | const QAbstractTextDocumentLayout::PaintContext &context, |
2024 | const QTextBlock &bl, bool inRootFrame) const |
2025 | { |
2026 | const QTextLayout *tl = bl.layout(); |
2027 | QRectF r = tl->boundingRect(); |
2028 | r.translate(p: offset + tl->position()); |
2029 | if (!bl.isVisible() || (context.clip.isValid() && (r.bottom() < context.clip.y() || r.top() > context.clip.bottom()))) |
2030 | return; |
2031 | qCDebug(lcDraw) << "drawBlock" << bl.position() << "at" << offset << "br" << tl->boundingRect(); |
2032 | |
2033 | QTextBlockFormat blockFormat = bl.blockFormat(); |
2034 | |
2035 | QBrush bg = blockFormat.background(); |
2036 | if (bg != Qt::NoBrush) { |
2037 | QRectF rect = r; |
2038 | |
2039 | // extend the background rectangle if we're in the root frame with NoWrap, |
2040 | // as the rect of the text block will then be only the width of the text |
2041 | // instead of the full page width |
2042 | if (inRootFrame && document->pageSize().width() <= 0) { |
2043 | const QTextFrameData *fd = data(f: document->rootFrame()); |
2044 | rect.setRight((fd->size.width - fd->rightMargin).toReal()); |
2045 | } |
2046 | |
2047 | fillBackground(p: painter, rect, brush: bg, origin: r.topLeft()); |
2048 | } |
2049 | |
2050 | QVector<QTextLayout::FormatRange> selections; |
2051 | int blpos = bl.position(); |
2052 | int bllen = bl.length(); |
2053 | const QTextCharFormat *selFormat = nullptr; |
2054 | for (int i = 0; i < context.selections.size(); ++i) { |
2055 | const QAbstractTextDocumentLayout::Selection &range = context.selections.at(i); |
2056 | const int selStart = range.cursor.selectionStart() - blpos; |
2057 | const int selEnd = range.cursor.selectionEnd() - blpos; |
2058 | if (selStart < bllen && selEnd > 0 |
2059 | && selEnd > selStart) { |
2060 | QTextLayout::FormatRange o; |
2061 | o.start = selStart; |
2062 | o.length = selEnd - selStart; |
2063 | o.format = range.format; |
2064 | selections.append(t: o); |
2065 | } else if (! range.cursor.hasSelection() && range.format.hasProperty(propertyId: QTextFormat::FullWidthSelection) |
2066 | && bl.contains(position: range.cursor.position())) { |
2067 | // for full width selections we don't require an actual selection, just |
2068 | // a position to specify the line. that's more convenience in usage. |
2069 | QTextLayout::FormatRange o; |
2070 | QTextLine l = tl->lineForTextPosition(pos: range.cursor.position() - blpos); |
2071 | o.start = l.textStart(); |
2072 | o.length = l.textLength(); |
2073 | if (o.start + o.length == bllen - 1) |
2074 | ++o.length; // include newline |
2075 | o.format = range.format; |
2076 | selections.append(t: o); |
2077 | } |
2078 | if (selStart < 0 && selEnd >= 1) |
2079 | selFormat = &range.format; |
2080 | } |
2081 | |
2082 | QTextObject *object = document->objectForFormat(bl.blockFormat()); |
2083 | if (object && object->format().toListFormat().style() != QTextListFormat::ListStyleUndefined) |
2084 | drawListItem(offset, painter, context, bl, selectionFormat: selFormat); |
2085 | |
2086 | QPen oldPen = painter->pen(); |
2087 | painter->setPen(context.palette.color(cr: QPalette::Text)); |
2088 | |
2089 | tl->draw(p: painter, pos: offset, selections, clip: context.clip.isValid() ? (context.clip & clipRect) : clipRect); |
2090 | |
2091 | // if the block is empty and it precedes a table, do not draw the cursor. |
2092 | // the cursor is drawn later after the table has been drawn so no need |
2093 | // to draw it here. |
2094 | if (!isEmptyBlockBeforeTable(it: frameIteratorForTextPosition(position: blpos)) |
2095 | && ((context.cursorPosition >= blpos && context.cursorPosition < blpos + bllen) |
2096 | || (context.cursorPosition < -1 && !tl->preeditAreaText().isEmpty()))) { |
2097 | int cpos = context.cursorPosition; |
2098 | if (cpos < -1) |
2099 | cpos = tl->preeditAreaPosition() - (cpos + 2); |
2100 | else |
2101 | cpos -= blpos; |
2102 | tl->drawCursor(p: painter, pos: offset, cursorPosition: cpos, width: cursorWidth); |
2103 | } |
2104 | |
2105 | if (blockFormat.hasProperty(propertyId: QTextFormat::BlockTrailingHorizontalRulerWidth)) { |
2106 | const qreal width = blockFormat.lengthProperty(propertyId: QTextFormat::BlockTrailingHorizontalRulerWidth).value(maximumLength: r.width()); |
2107 | painter->setPen(context.palette.color(cr: QPalette::Dark)); |
2108 | qreal y = r.bottom(); |
2109 | if (bl.length() == 1) |
2110 | y = r.top() + r.height() / 2; |
2111 | |
2112 | const qreal middleX = r.left() + r.width() / 2; |
2113 | painter->drawLine(l: QLineF(middleX - width / 2, y, middleX + width / 2, y)); |
2114 | } |
2115 | |
2116 | painter->setPen(oldPen); |
2117 | } |
2118 | |
2119 | |
2120 | void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *painter, |
2121 | const QAbstractTextDocumentLayout::PaintContext &context, |
2122 | const QTextBlock &bl, const QTextCharFormat *selectionFormat) const |
2123 | { |
2124 | Q_Q(const QTextDocumentLayout); |
2125 | const QTextBlockFormat blockFormat = bl.blockFormat(); |
2126 | const QTextCharFormat charFormat = bl.charFormat(); |
2127 | QFont font(charFormat.font()); |
2128 | if (q->paintDevice()) |
2129 | font = QFont(font, q->paintDevice()); |
2130 | |
2131 | const QFontMetrics fontMetrics(font); |
2132 | QTextObject * const object = document->objectForFormat(blockFormat); |
2133 | const QTextListFormat lf = object->format().toListFormat(); |
2134 | int style = lf.style(); |
2135 | QString itemText; |
2136 | QSizeF size; |
2137 | |
2138 | if (blockFormat.hasProperty(propertyId: QTextFormat::ListStyle)) |
2139 | style = QTextListFormat::Style(blockFormat.intProperty(propertyId: QTextFormat::ListStyle)); |
2140 | |
2141 | QTextLayout *layout = bl.layout(); |
2142 | if (layout->lineCount() == 0) |
2143 | return; |
2144 | QTextLine firstLine = layout->lineAt(i: 0); |
2145 | Q_ASSERT(firstLine.isValid()); |
2146 | QPointF pos = (offset + layout->position()).toPoint(); |
2147 | Qt::LayoutDirection dir = bl.textDirection(); |
2148 | { |
2149 | QRectF textRect = firstLine.naturalTextRect(); |
2150 | pos += textRect.topLeft().toPoint(); |
2151 | if (dir == Qt::RightToLeft) |
2152 | pos.rx() += textRect.width(); |
2153 | } |
2154 | |
2155 | switch (style) { |
2156 | case QTextListFormat::ListDecimal: |
2157 | case QTextListFormat::ListLowerAlpha: |
2158 | case QTextListFormat::ListUpperAlpha: |
2159 | case QTextListFormat::ListLowerRoman: |
2160 | case QTextListFormat::ListUpperRoman: |
2161 | itemText = static_cast<QTextList *>(object)->itemText(bl); |
2162 | size.setWidth(fontMetrics.horizontalAdvance(itemText)); |
2163 | size.setHeight(fontMetrics.height()); |
2164 | break; |
2165 | |
2166 | case QTextListFormat::ListSquare: |
2167 | case QTextListFormat::ListCircle: |
2168 | case QTextListFormat::ListDisc: |
2169 | size.setWidth(fontMetrics.lineSpacing() / 3); |
2170 | size.setHeight(size.width()); |
2171 | break; |
2172 | |
2173 | case QTextListFormat::ListStyleUndefined: |
2174 | return; |
2175 | default: return; |
2176 | } |
2177 | |
2178 | QRectF r(pos, size); |
2179 | |
2180 | qreal xoff = fontMetrics.horizontalAdvance(QLatin1Char(' ')); |
2181 | if (dir == Qt::LeftToRight) |
2182 | xoff = -xoff - size.width(); |
2183 | r.translate( dx: xoff, dy: (fontMetrics.height() / 2) - (size.height() / 2)); |
2184 | |
2185 | painter->save(); |
2186 | |
2187 | painter->setRenderHint(hint: QPainter::Antialiasing); |
2188 | |
2189 | const bool marker = bl.blockFormat().marker() != QTextBlockFormat::MarkerType::NoMarker; |
2190 | if (selectionFormat) { |
2191 | painter->setPen(QPen(selectionFormat->foreground(), 0)); |
2192 | if (!marker) |
2193 | painter->fillRect(r, selectionFormat->background()); |
2194 | } else { |
2195 | QBrush fg = charFormat.foreground(); |
2196 | if (fg == Qt::NoBrush) |
2197 | fg = context.palette.text(); |
2198 | painter->setPen(QPen(fg, 0)); |
2199 | } |
2200 | |
2201 | QBrush brush = context.palette.brush(cr: QPalette::Text); |
2202 | |
2203 | if (marker) { |
2204 | int adj = fontMetrics.lineSpacing() / 6; |
2205 | r.adjust(xp1: -adj, yp1: 0, xp2: -adj, yp2: 0); |
2206 | const QRectF outer = r.adjusted(xp1: -adj, yp1: -adj, xp2: adj, yp2: adj); |
2207 | if (selectionFormat) |
2208 | painter->fillRect(outer, selectionFormat->background()); |
2209 | if (bl.blockFormat().marker() == QTextBlockFormat::MarkerType::Checked) { |
2210 | // ### Qt7: render with QStyle / PE_IndicatorCheckBox. We don't currently |
2211 | // have access to that here, because it would be a widget dependency. |
2212 | painter->setPen(QPen(painter->pen().color(), 2)); |
2213 | painter->drawLine(p1: r.topLeft(), p2: r.bottomRight()); |
2214 | painter->drawLine(p1: r.topRight(), p2: r.bottomLeft()); |
2215 | painter->setPen(QPen(painter->pen().color(), 0)); |
2216 | } |
2217 | painter->drawRect(rect: outer); |
2218 | } |
2219 | |
2220 | switch (style) { |
2221 | case QTextListFormat::ListDecimal: |
2222 | case QTextListFormat::ListLowerAlpha: |
2223 | case QTextListFormat::ListUpperAlpha: |
2224 | case QTextListFormat::ListLowerRoman: |
2225 | case QTextListFormat::ListUpperRoman: { |
2226 | QTextLayout layout(itemText, font, q->paintDevice()); |
2227 | layout.setCacheEnabled(true); |
2228 | QTextOption option(Qt::AlignLeft | Qt::AlignAbsolute); |
2229 | option.setTextDirection(dir); |
2230 | layout.setTextOption(option); |
2231 | layout.beginLayout(); |
2232 | QTextLine line = layout.createLine(); |
2233 | if (line.isValid()) |
2234 | line.setLeadingIncluded(true); |
2235 | layout.endLayout(); |
2236 | layout.draw(p: painter, pos: QPointF(r.left(), pos.y())); |
2237 | break; |
2238 | } |
2239 | case QTextListFormat::ListSquare: |
2240 | if (!marker) |
2241 | painter->fillRect(r, brush); |
2242 | break; |
2243 | case QTextListFormat::ListCircle: |
2244 | if (!marker) { |
2245 | painter->setPen(QPen(brush, 0)); |
2246 | painter->drawEllipse(r: r.translated(dx: 0.5, dy: 0.5)); // pixel align for sharper rendering |
2247 | } |
2248 | break; |
2249 | case QTextListFormat::ListDisc: |
2250 | if (!marker) { |
2251 | painter->setBrush(brush); |
2252 | painter->setPen(Qt::NoPen); |
2253 | painter->drawEllipse(r); |
2254 | } |
2255 | break; |
2256 | case QTextListFormat::ListStyleUndefined: |
2257 | break; |
2258 | default: |
2259 | break; |
2260 | } |
2261 | |
2262 | painter->restore(); |
2263 | } |
2264 | |
2265 | static QFixed flowPosition(const QTextFrame::iterator &it) |
2266 | { |
2267 | if (it.atEnd()) |
2268 | return 0; |
2269 | |
2270 | if (it.currentFrame()) { |
2271 | return data(f: it.currentFrame())->position.y; |
2272 | } else { |
2273 | QTextBlock block = it.currentBlock(); |
2274 | QTextLayout *layout = block.layout(); |
2275 | if (layout->lineCount() == 0) |
2276 | return QFixed::fromReal(r: layout->position().y()); |
2277 | else |
2278 | return QFixed::fromReal(r: layout->position().y() + layout->lineAt(i: 0).y()); |
2279 | } |
2280 | } |
2281 | |
2282 | static QFixed firstChildPos(const QTextFrame *f) |
2283 | { |
2284 | return flowPosition(it: f->begin()); |
2285 | } |
2286 | |
2287 | QTextLayoutStruct QTextDocumentLayoutPrivate::layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width, |
2288 | int layoutFrom, int layoutTo, QTextTableData *td, |
2289 | QFixed absoluteTableY, bool withPageBreaks) |
2290 | { |
2291 | qCDebug(lcTable) << "layoutCell" ; |
2292 | QTextLayoutStruct layoutStruct; |
2293 | layoutStruct.frame = t; |
2294 | layoutStruct.minimumWidth = 0; |
2295 | layoutStruct.maximumWidth = QFIXED_MAX; |
2296 | layoutStruct.y = 0; |
2297 | |
2298 | const QFixed topPadding = td->topPadding(table: t, cell); |
2299 | if (withPageBreaks) { |
2300 | layoutStruct.frameY = absoluteTableY + td->rowPositions.at(i: cell.row()) + topPadding; |
2301 | } |
2302 | layoutStruct.x_left = 0; |
2303 | layoutStruct.x_right = width; |
2304 | // we get called with different widths all the time (for example for figuring |
2305 | // out the min/max widths), so we always have to do the full layout ;( |
2306 | // also when for example in a table layoutFrom/layoutTo affect only one cell, |
2307 | // making that one cell grow the available width of the other cells may change |
2308 | // (shrink) and therefore when layoutCell gets called for them they have to |
2309 | // be re-laid out, even if layoutFrom/layoutTo is not in their range. Hence |
2310 | // this line: |
2311 | |
2312 | layoutStruct.pageHeight = QFixed::fromReal(r: document->pageSize().height()); |
2313 | if (layoutStruct.pageHeight < 0 || !withPageBreaks) |
2314 | layoutStruct.pageHeight = QFIXED_MAX; |
2315 | const int currentPage = layoutStruct.currentPage(); |
2316 | |
2317 | layoutStruct.pageTopMargin = td->effectiveTopMargin |
2318 | + td->cellSpacing |
2319 | + td->border |
2320 | + td->paddingProperty(format: cell.format(), property: QTextFormat::TableCellTopPadding); // top cell-border is not repeated |
2321 | |
2322 | #ifndef QT_NO_CSSPARSER |
2323 | const int = t->format().headerRowCount(); |
2324 | if (td->borderCollapse && headerRowCount > 0) { |
2325 | // consider the header row's bottom edge width |
2326 | qreal = axisEdgeData(table: t, td, cell: t->cellAt(row: headerRowCount - 1, col: cell.column()), edge: QCss::BottomEdge).width; |
2327 | layoutStruct.pageTopMargin += QFixed::fromReal(r: scaleToDevice(value: headerRowBottomBorderWidth) / 2); |
2328 | } |
2329 | #endif |
2330 | |
2331 | layoutStruct.pageBottomMargin = td->effectiveBottomMargin + td->cellSpacing + td->effectiveBottomBorder + td->bottomPadding(table: t, cell); |
2332 | layoutStruct.pageBottom = (currentPage + 1) * layoutStruct.pageHeight - layoutStruct.pageBottomMargin; |
2333 | |
2334 | layoutStruct.fullLayout = true; |
2335 | |
2336 | QFixed pageTop = currentPage * layoutStruct.pageHeight + layoutStruct.pageTopMargin - layoutStruct.frameY; |
2337 | layoutStruct.y = qMax(a: layoutStruct.y, b: pageTop); |
2338 | |
2339 | const QList<QTextFrame *> childFrames = td->childFrameMap.values(akey: cell.row() + cell.column() * t->rows()); |
2340 | for (int i = 0; i < childFrames.size(); ++i) { |
2341 | QTextFrame *frame = childFrames.at(i); |
2342 | QTextFrameData *cd = data(f: frame); |
2343 | cd->sizeDirty = true; |
2344 | } |
2345 | |
2346 | layoutFlow(it: cell.begin(), layoutStruct: &layoutStruct, layoutFrom, layoutTo, width); |
2347 | |
2348 | QFixed floatMinWidth; |
2349 | |
2350 | // floats that are located inside the text (like inline images) aren't taken into account by |
2351 | // layoutFlow with regards to the cell height (layoutStruct->y), so for a safety measure we |
2352 | // do that here. For example with <td><img align="right" src="..." />blah</td> |
2353 | // when the image happens to be higher than the text |
2354 | for (int i = 0; i < childFrames.size(); ++i) { |
2355 | QTextFrame *frame = childFrames.at(i); |
2356 | QTextFrameData *cd = data(f: frame); |
2357 | |
2358 | if (frame->frameFormat().position() != QTextFrameFormat::InFlow) |
2359 | layoutStruct.y = qMax(a: layoutStruct.y, b: cd->position.y + cd->size.height); |
2360 | |
2361 | floatMinWidth = qMax(a: floatMinWidth, b: cd->minimumWidth); |
2362 | } |
2363 | |
2364 | // constraint the maximum/minimumWidth by the minimum width of the fixed size floats, |
2365 | // to keep them visible |
2366 | layoutStruct.maximumWidth = qMax(a: layoutStruct.maximumWidth, b: floatMinWidth); |
2367 | layoutStruct.minimumWidth = qMax(a: layoutStruct.minimumWidth, b: floatMinWidth); |
2368 | |
2369 | // as floats in cells get added to the table's float list but must not affect |
2370 | // floats in other cells we must clear the list here. |
2371 | data(f: t)->floats.clear(); |
2372 | |
2373 | // qDebug("layoutCell done"); |
2374 | |
2375 | return layoutStruct; |
2376 | } |
2377 | |
2378 | #ifndef QT_NO_CSSPARSER |
2379 | static inline void findWidestOutermostBorder(QTextTable *table, QTextTableData *td, |
2380 | const QTextTableCell &cell, QCss::Edge edge, |
2381 | qreal *outerBorders) |
2382 | { |
2383 | EdgeData w = cellEdgeData(table, td, cell, edge); |
2384 | if (w.width > outerBorders[edge]) |
2385 | outerBorders[edge] = w.width; |
2386 | } |
2387 | #endif |
2388 | |
2389 | QRectF QTextDocumentLayoutPrivate::layoutTable(QTextTable *table, int layoutFrom, int layoutTo, QFixed parentY) |
2390 | { |
2391 | qCDebug(lcTable) << "layoutTable from" << layoutFrom << "to" << layoutTo << "parentY" << parentY; |
2392 | QTextTableData *td = static_cast<QTextTableData *>(data(f: table)); |
2393 | Q_ASSERT(td->sizeDirty); |
2394 | const int rows = table->rows(); |
2395 | const int columns = table->columns(); |
2396 | |
2397 | const QTextTableFormat fmt = table->format(); |
2398 | |
2399 | td->childFrameMap.clear(); |
2400 | { |
2401 | const QList<QTextFrame *> children = table->childFrames(); |
2402 | for (int i = 0; i < children.count(); ++i) { |
2403 | QTextFrame *frame = children.at(i); |
2404 | QTextTableCell cell = table->cellAt(position: frame->firstPosition()); |
2405 | td->childFrameMap.insert(key: cell.row() + cell.column() * rows, value: frame); |
2406 | } |
2407 | } |
2408 | |
2409 | QVector<QTextLength> columnWidthConstraints = fmt.columnWidthConstraints(); |
2410 | if (columnWidthConstraints.size() != columns) |
2411 | columnWidthConstraints.resize(size: columns); |
2412 | Q_ASSERT(columnWidthConstraints.count() == columns); |
2413 | |
2414 | // borderCollapse will disable drawing the html4 style table cell borders |
2415 | // and draw a 1px grid instead. This also sets a fixed cellspacing |
2416 | // of 1px if border > 0 (for the grid) and ignore any explicitly set |
2417 | // cellspacing. |
2418 | td->borderCollapse = fmt.borderCollapse(); |
2419 | td->borderCell = td->borderCollapse ? 0 : td->border; |
2420 | const QFixed cellSpacing = td->cellSpacing = QFixed::fromReal(r: scaleToDevice(value: td->borderCollapse ? 0 : fmt.cellSpacing())).round(); |
2421 | |
2422 | td->drawGrid = (td->borderCollapse && fmt.border() >= 1); |
2423 | |
2424 | td->effectiveTopBorder = td->effectiveBottomBorder = td->effectiveLeftBorder = td->effectiveRightBorder = td->border; |
2425 | |
2426 | #ifndef QT_NO_CSSPARSER |
2427 | if (td->borderCollapse) { |
2428 | // find the widest borders of the outermost cells |
2429 | qreal outerBorders[QCss::NumEdges]; |
2430 | for (int i = 0; i < QCss::NumEdges; ++i) |
2431 | outerBorders[i] = 0; |
2432 | |
2433 | for (int r = 0; r < rows; ++r) { |
2434 | if (r == 0) { |
2435 | for (int c = 0; c < columns; ++c) |
2436 | findWidestOutermostBorder(table, td, cell: table->cellAt(row: r, col: c), edge: QCss::TopEdge, outerBorders); |
2437 | } |
2438 | if (r == rows - 1) { |
2439 | for (int c = 0; c < columns; ++c) |
2440 | findWidestOutermostBorder(table, td, cell: table->cellAt(row: r, col: c), edge: QCss::BottomEdge, outerBorders); |
2441 | } |
2442 | findWidestOutermostBorder(table, td, cell: table->cellAt(row: r, col: 0), edge: QCss::LeftEdge, outerBorders); |
2443 | findWidestOutermostBorder(table, td, cell: table->cellAt(row: r, col: columns - 1), edge: QCss::RightEdge, outerBorders); |
2444 | } |
2445 | td->effectiveTopBorder = QFixed::fromReal(r: scaleToDevice(value: outerBorders[QCss::TopEdge] / 2)).round(); |
2446 | td->effectiveBottomBorder = QFixed::fromReal(r: scaleToDevice(value: outerBorders[QCss::BottomEdge] / 2)).round(); |
2447 | td->effectiveLeftBorder = QFixed::fromReal(r: scaleToDevice(value: outerBorders[QCss::LeftEdge] / 2)).round(); |
2448 | td->effectiveRightBorder = QFixed::fromReal(r: scaleToDevice(value: outerBorders[QCss::RightEdge] / 2)).round(); |
2449 | } |
2450 | #endif |
2451 | |
2452 | td->deviceScale = scaleToDevice(value: qreal(1)); |
2453 | td->cellPadding = QFixed::fromReal(r: scaleToDevice(value: fmt.cellPadding())); |
2454 | const QFixed leftMargin = td->leftMargin + td->padding + td->effectiveLeftBorder; |
2455 | const QFixed rightMargin = td->rightMargin + td->padding + td->effectiveRightBorder; |
2456 | const QFixed topMargin = td->topMargin + td->padding + td->effectiveTopBorder; |
2457 | |
2458 | const QFixed absoluteTableY = parentY + td->position.y; |
2459 | |
2460 | const QTextOption::WrapMode oldDefaultWrapMode = docPrivate->defaultTextOption.wrapMode(); |
2461 | |
2462 | recalc_minmax_widths: |
2463 | |
2464 | QFixed remainingWidth = td->contentsWidth; |
2465 | // two (vertical) borders per cell per column |
2466 | remainingWidth -= columns * 2 * td->borderCell; |
2467 | // inter-cell spacing |
2468 | remainingWidth -= (columns - 1) * cellSpacing; |
2469 | // cell spacing at the left and right hand side |
2470 | remainingWidth -= 2 * cellSpacing; |
2471 | |
2472 | if (td->borderCollapse) { |
2473 | remainingWidth -= td->effectiveLeftBorder; |
2474 | remainingWidth -= td->effectiveRightBorder; |
2475 | } |
2476 | |
2477 | // remember the width used to distribute to percentaged columns |
2478 | const QFixed initialTotalWidth = remainingWidth; |
2479 | |
2480 | td->widths.resize(size: columns); |
2481 | td->widths.fill(from: 0); |
2482 | |
2483 | td->minWidths.resize(size: columns); |
2484 | // start with a minimum width of 0. totally empty |
2485 | // cells of default created tables are invisible otherwise |
2486 | // and therefore hardly editable |
2487 | td->minWidths.fill(from: 1); |
2488 | |
2489 | td->maxWidths.resize(size: columns); |
2490 | td->maxWidths.fill(QFIXED_MAX); |
2491 | |
2492 | // calculate minimum and maximum sizes of the columns |
2493 | for (int i = 0; i < columns; ++i) { |
2494 | for (int row = 0; row < rows; ++row) { |
2495 | const QTextTableCell cell = table->cellAt(row, col: i); |
2496 | const int cspan = cell.columnSpan(); |
2497 | |
2498 | if (cspan > 1 && i != cell.column()) |
2499 | continue; |
2500 | |
2501 | const QFixed leftPadding = td->leftPadding(table, cell); |
2502 | const QFixed rightPadding = td->rightPadding(table, cell); |
2503 | const QFixed widthPadding = leftPadding + rightPadding; |
2504 | |
2505 | // to figure out the min and the max width lay out the cell at |
2506 | // maximum width. otherwise the maxwidth calculation sometimes |
2507 | // returns wrong values |
2508 | QTextLayoutStruct layoutStruct = layoutCell(t: table, cell, QFIXED_MAX, layoutFrom, |
2509 | layoutTo, td, absoluteTableY, |
2510 | /*withPageBreaks =*/false); |
2511 | |
2512 | // distribute the minimum width over all columns the cell spans |
2513 | QFixed widthToDistribute = layoutStruct.minimumWidth + widthPadding; |
2514 | for (int n = 0; n < cspan; ++n) { |
2515 | const int col = i + n; |
2516 | QFixed w = widthToDistribute / (cspan - n); |
2517 | // ceil to avoid going below minWidth when rounding all column widths later |
2518 | td->minWidths[col] = qMax(a: td->minWidths.at(i: col), b: w).ceil(); |
2519 | widthToDistribute -= td->minWidths.at(i: col); |
2520 | if (widthToDistribute <= 0) |
2521 | break; |
2522 | } |
2523 | |
2524 | QFixed maxW = td->maxWidths.at(i); |
2525 | if (layoutStruct.maximumWidth != QFIXED_MAX) { |
2526 | if (maxW == QFIXED_MAX) |
2527 | maxW = layoutStruct.maximumWidth + widthPadding; |
2528 | else |
2529 | maxW = qMax(a: maxW, b: layoutStruct.maximumWidth + widthPadding); |
2530 | } |
2531 | if (maxW == QFIXED_MAX) |
2532 | continue; |
2533 | |
2534 | // for variable columns the maxWidth will later be considered as the |
2535 | // column width (column width = content width). We must avoid that the |
2536 | // pixel-alignment rounding step floors this value and thus the text |
2537 | // rendering later erroneously wraps the content. |
2538 | maxW = maxW.ceil(); |
2539 | |
2540 | widthToDistribute = maxW; |
2541 | for (int n = 0; n < cspan; ++n) { |
2542 | const int col = i + n; |
2543 | QFixed w = widthToDistribute / (cspan - n); |
2544 | if (td->maxWidths[col] != QFIXED_MAX) |
2545 | w = qMax(a: td->maxWidths[col], b: w); |
2546 | td->maxWidths[col] = qMax(a: td->minWidths.at(i: col), b: w); |
2547 | widthToDistribute -= td->maxWidths.at(i: col); |
2548 | if (widthToDistribute <= 0) |
2549 | break; |
2550 | } |
2551 | } |
2552 | } |
2553 | |
2554 | // set fixed values, figure out total percentages used and number of |
2555 | // variable length cells. Also assign the minimum width for variable columns. |
2556 | QFixed totalPercentage; |
2557 | int variableCols = 0; |
2558 | QFixed totalMinWidth = 0; |
2559 | for (int i = 0; i < columns; ++i) { |
2560 | const QTextLength &length = columnWidthConstraints.at(i); |
2561 | if (length.type() == QTextLength::FixedLength) { |
2562 | td->minWidths[i] = td->widths[i] = qMax(a: scaleToDevice(value: QFixed::fromReal(r: length.rawValue())), b: td->minWidths.at(i)); |
2563 | remainingWidth -= td->widths.at(i); |
2564 | qCDebug(lcTable) << "column" << i << "has width constraint" << td->minWidths.at(i) << "px, remaining width now" << remainingWidth; |
2565 | } else if (length.type() == QTextLength::PercentageLength) { |
2566 | totalPercentage += QFixed::fromReal(r: length.rawValue()); |
2567 | } else if (length.type() == QTextLength::VariableLength) { |
2568 | variableCols++; |
2569 | |
2570 | td->widths[i] = td->minWidths.at(i); |
2571 | remainingWidth -= td->minWidths.at(i); |
2572 | qCDebug(lcTable) << "column" << i << "has variable width, min" << td->minWidths.at(i) << "remaining width now" << remainingWidth; |
2573 | } |
2574 | totalMinWidth += td->minWidths.at(i); |
2575 | } |
2576 | |
2577 | // set percentage values |
2578 | { |
2579 | const QFixed totalPercentagedWidth = initialTotalWidth * totalPercentage / 100; |
2580 | QFixed remainingMinWidths = totalMinWidth; |
2581 | for (int i = 0; i < columns; ++i) { |
2582 | remainingMinWidths -= td->minWidths.at(i); |
2583 | if (columnWidthConstraints.at(i).type() == QTextLength::PercentageLength) { |
2584 | const QFixed allottedPercentage = QFixed::fromReal(r: columnWidthConstraints.at(i).rawValue()); |
2585 | |
2586 | const QFixed percentWidth = totalPercentagedWidth * allottedPercentage / totalPercentage; |
2587 | if (percentWidth >= td->minWidths.at(i)) { |
2588 | td->widths[i] = qBound(min: td->minWidths.at(i), val: percentWidth, max: remainingWidth - remainingMinWidths); |
2589 | } else { |
2590 | td->widths[i] = td->minWidths.at(i); |
2591 | } |
2592 | qCDebug(lcTable) << "column" << i << "has width constraint" << columnWidthConstraints.at(i).rawValue() |
2593 | << "%, allocated width" << td->widths[i] << "remaining width now" << remainingWidth; |
2594 | remainingWidth -= td->widths.at(i); |
2595 | } |
2596 | } |
2597 | } |
2598 | |
2599 | // for variable columns distribute the remaining space |
2600 | if (variableCols > 0 && remainingWidth > 0) { |
2601 | QVarLengthArray<int> columnsWithProperMaxSize; |
2602 | for (int i = 0; i < columns; ++i) |
2603 | if (columnWidthConstraints.at(i).type() == QTextLength::VariableLength |
2604 | && td->maxWidths.at(i) != QFIXED_MAX) |
2605 | columnsWithProperMaxSize.append(t: i); |
2606 | |
2607 | QFixed lastRemainingWidth = remainingWidth; |
2608 | while (remainingWidth > 0) { |
2609 | for (int k = 0; k < columnsWithProperMaxSize.count(); ++k) { |
2610 | const int col = columnsWithProperMaxSize[k]; |
2611 | const int colsLeft = columnsWithProperMaxSize.count() - k; |
2612 | const QFixed w = qMin(a: td->maxWidths.at(i: col) - td->widths.at(i: col), b: remainingWidth / colsLeft); |
2613 | td->widths[col] += w; |
2614 | remainingWidth -= w; |
2615 | } |
2616 | if (remainingWidth == lastRemainingWidth) |
2617 | break; |
2618 | lastRemainingWidth = remainingWidth; |
2619 | } |
2620 | |
2621 | if (remainingWidth > 0 |
2622 | // don't unnecessarily grow variable length sized tables |
2623 | && fmt.width().type() != QTextLength::VariableLength) { |
2624 | const QFixed widthPerAnySizedCol = remainingWidth / variableCols; |
2625 | for (int col = 0; col < columns; ++col) { |
2626 | if (columnWidthConstraints.at(i: col).type() == QTextLength::VariableLength) |
2627 | td->widths[col] += widthPerAnySizedCol; |
2628 | } |
2629 | } |
2630 | } |
2631 | |
2632 | // in order to get a correct border rendering we must ensure that the distance between |
2633 | // two cells is exactly 2 * td->cellBorder pixel. we do this by rounding the calculated width |
2634 | // values here. |
2635 | // to minimize the total rounding error we propagate the rounding error for each width |
2636 | // to its successor. |
2637 | QFixed error = 0; |
2638 | for (int i = 0; i < columns; ++i) { |
2639 | QFixed orig = td->widths[i]; |
2640 | td->widths[i] = (td->widths[i] - error).round(); |
2641 | error = td->widths[i] - orig; |
2642 | } |
2643 | |
2644 | td->columnPositions.resize(size: columns); |
2645 | td->columnPositions[0] = leftMargin /*includes table border*/ + cellSpacing + td->border; |
2646 | |
2647 | for (int i = 1; i < columns; ++i) |
2648 | td->columnPositions[i] = td->columnPositions.at(i: i-1) + td->widths.at(i: i-1) + 2 * td->borderCell + cellSpacing; |
2649 | |
2650 | // - margin to compensate the + margin in columnPositions[0] |
2651 | const QFixed contentsWidth = td->columnPositions.constLast() + td->widths.constLast() + td->padding + td->border + cellSpacing - leftMargin; |
2652 | |
2653 | // if the table is too big and causes an overflow re-do the layout with WrapAnywhere as wrap |
2654 | // mode |
2655 | if (docPrivate->defaultTextOption.wrapMode() == QTextOption::WrapAtWordBoundaryOrAnywhere |
2656 | && contentsWidth > td->contentsWidth) { |
2657 | docPrivate->defaultTextOption.setWrapMode(QTextOption::WrapAnywhere); |
2658 | // go back to the top of the function |
2659 | goto recalc_minmax_widths; |
2660 | } |
2661 | |
2662 | td->contentsWidth = contentsWidth; |
2663 | |
2664 | docPrivate->defaultTextOption.setWrapMode(oldDefaultWrapMode); |
2665 | |
2666 | td->heights.resize(size: rows); |
2667 | td->heights.fill(from: 0); |
2668 | |
2669 | td->rowPositions.resize(size: rows); |
2670 | td->rowPositions[0] = topMargin /*includes table border*/ + cellSpacing + td->border; |
2671 | |
2672 | bool haveRowSpannedCells = false; |
2673 | |
2674 | // need to keep track of cell heights for vertical alignment |
2675 | QVector<QFixed> cellHeights; |
2676 | cellHeights.reserve(size: rows * columns); |
2677 | |
2678 | QFixed pageHeight = QFixed::fromReal(r: document->pageSize().height()); |
2679 | if (pageHeight <= 0) |
2680 | pageHeight = QFIXED_MAX; |
2681 | |
2682 | QVector<QFixed> heightToDistribute; |
2683 | heightToDistribute.resize(size: columns); |
2684 | |
2685 | td->headerHeight = 0; |
2686 | const int = qMin(a: table->format().headerRowCount(), b: rows - 1); |
2687 | const QFixed originalTopMargin = td->effectiveTopMargin; |
2688 | bool hasDroppedTable = false; |
2689 | |
2690 | // now that we have the column widths we can lay out all cells with the right width. |
2691 | // spanning cells are only allowed to grow the last row spanned by the cell. |
2692 | // |
2693 | // ### this could be made faster by iterating over the cells array of QTextTable |
2694 | for (int r = 0; r < rows; ++r) { |
2695 | td->calcRowPosition(row: r); |
2696 | |
2697 | const int tableStartPage = (absoluteTableY / pageHeight).truncate(); |
2698 | const int currentPage = ((td->rowPositions.at(i: r) + absoluteTableY) / pageHeight).truncate(); |
2699 | const QFixed pageBottom = (currentPage + 1) * pageHeight - td->effectiveBottomMargin - absoluteTableY - cellSpacing - td->border; |
2700 | const QFixed pageTop = currentPage * pageHeight + td->effectiveTopMargin - absoluteTableY + cellSpacing + td->border; |
2701 | const QFixed nextPageTop = pageTop + pageHeight; |
2702 | |
2703 | if (td->rowPositions.at(i: r) > pageBottom) |
2704 | td->rowPositions[r] = nextPageTop; |
2705 | else if (td->rowPositions.at(i: r) < pageTop) |
2706 | td->rowPositions[r] = pageTop; |
2707 | |
2708 | bool dropRowToNextPage = true; |
2709 | int cellCountBeforeRow = cellHeights.size(); |
2710 | |
2711 | // if we drop the row to the next page we need to subtract the drop |
2712 | // distance from any row spanning cells |
2713 | QFixed dropDistance = 0; |
2714 | |
2715 | relayout: |
2716 | const int rowStartPage = ((td->rowPositions.at(i: r) + absoluteTableY) / pageHeight).truncate(); |
2717 | // if any of the header rows or the first non-header row start on the next page |
2718 | // then the entire header should be dropped |
2719 | if (r <= headerRowCount && rowStartPage > tableStartPage && !hasDroppedTable) { |
2720 | td->rowPositions[0] = nextPageTop; |
2721 | cellHeights.clear(); |
2722 | td->effectiveTopMargin = originalTopMargin; |
2723 | hasDroppedTable = true; |
2724 | r = -1; |
2725 | continue; |
2726 | } |
2727 | |
2728 | int rowCellCount = 0; |
2729 | for (int c = 0; c < columns; ++c) { |
2730 | QTextTableCell cell = table->cellAt(row: r, col: c); |
2731 | const int rspan = cell.rowSpan(); |
2732 | const int cspan = cell.columnSpan(); |
2733 | |
2734 | if (cspan > 1 && cell.column() != c) |
2735 | continue; |
2736 | |
2737 | if (rspan > 1) { |
2738 | haveRowSpannedCells = true; |
2739 | |
2740 | const int cellRow = cell.row(); |
2741 | if (cellRow != r) { |
2742 | // the last row gets all the remaining space |
2743 | if (cellRow + rspan - 1 == r) |
2744 | td->heights[r] = qMax(a: td->heights.at(i: r), b: heightToDistribute.at(i: c) - dropDistance).round(); |
2745 | continue; |
2746 | } |
2747 | } |
2748 | |
2749 | const QFixed topPadding = td->topPadding(table, cell); |
2750 | const QFixed bottomPadding = td->bottomPadding(table, cell); |
2751 | const QFixed leftPadding = td->leftPadding(table, cell); |
2752 | const QFixed rightPadding = td->rightPadding(table, cell); |
2753 | const QFixed widthPadding = leftPadding + rightPadding; |
2754 | |
2755 | ++rowCellCount; |
2756 | |
2757 | const QFixed width = td->cellWidth(column: c, colspan: cspan) - widthPadding; |
2758 | QTextLayoutStruct layoutStruct = layoutCell(t: table, cell, width, |
2759 | layoutFrom, layoutTo, |
2760 | td, absoluteTableY, |
2761 | /*withPageBreaks =*/true); |
2762 | |
2763 | const QFixed height = (layoutStruct.y + bottomPadding + topPadding).round(); |
2764 | |
2765 | if (rspan > 1) |
2766 | heightToDistribute[c] = height + dropDistance; |
2767 | else |
2768 | td->heights[r] = qMax(a: td->heights.at(i: r), b: height); |
2769 | |
2770 | cellHeights.append(t: layoutStruct.y); |
2771 | |
2772 | QFixed childPos = td->rowPositions.at(i: r) + topPadding + flowPosition(it: cell.begin()); |
2773 | if (childPos < pageBottom) |
2774 | dropRowToNextPage = false; |
2775 | } |
2776 | |
2777 | if (rowCellCount > 0 && dropRowToNextPage) { |
2778 | dropDistance = nextPageTop - td->rowPositions.at(i: r); |
2779 | td->rowPositions[r] = nextPageTop; |
2780 | td->heights[r] = 0; |
2781 | dropRowToNextPage = false; |
2782 | cellHeights.resize(size: cellCountBeforeRow); |
2783 | if (r > headerRowCount) |
2784 | td->heights[r - 1] = pageBottom - td->rowPositions.at(i: r - 1); |
2785 | goto relayout; |
2786 | } |
2787 | |
2788 | if (haveRowSpannedCells) { |
2789 | const QFixed effectiveHeight = td->heights.at(i: r) + td->borderCell + cellSpacing + td->borderCell; |
2790 | for (int c = 0; c < columns; ++c) |
2791 | heightToDistribute[c] = qMax(a: heightToDistribute.at(i: c) - effectiveHeight - dropDistance, b: QFixed(0)); |
2792 | } |
2793 | |
2794 | if (r == headerRowCount - 1) { |
2795 | td->headerHeight = td->rowPositions.at(i: r) + td->heights.at(i: r) - td->rowPositions.at(i: 0) + td->cellSpacing + 2 * td->borderCell; |
2796 | td->headerHeight -= td->headerHeight * (td->headerHeight / pageHeight).truncate(); |
2797 | td->effectiveTopMargin += td->headerHeight; |
2798 | } |
2799 | } |
2800 | |
2801 | td->effectiveTopMargin = originalTopMargin; |
2802 | |
2803 | // now that all cells have been properly laid out, we can compute the |
2804 | // vertical offsets for vertical alignment |
2805 | td->cellVerticalOffsets.resize(size: rows * columns); |
2806 | int cellIndex = 0; |
2807 | for (int r = 0; r < rows; ++r) { |
2808 | for (int c = 0; c < columns; ++c) { |
2809 | QTextTableCell cell = table->cellAt(row: r, col: c); |
2810 | if (cell.row() != r || cell.column() != c) |
2811 | continue; |
2812 | |
2813 | const int rowSpan = cell.rowSpan(); |
2814 | const QFixed availableHeight = td->rowPositions.at(i: r + rowSpan - 1) + td->heights.at(i: r + rowSpan - 1) - td->rowPositions.at(i: r); |
2815 | |
2816 | const QTextCharFormat cellFormat = cell.format(); |
2817 | const QFixed cellHeight = cellHeights.at(i: cellIndex++) + td->topPadding(table, cell) + td->bottomPadding(table, cell); |
2818 | |
2819 | QFixed offset = 0; |
2820 | switch (cellFormat.verticalAlignment()) { |
2821 | case QTextCharFormat::AlignMiddle: |
2822 | offset = (availableHeight - cellHeight) / 2; |
2823 | break; |
2824 | case QTextCharFormat::AlignBottom: |
2825 | offset = availableHeight - cellHeight; |
2826 | break; |
2827 | default: |
2828 | break; |
2829 | }; |
2830 | |
2831 | for (int rd = 0; rd < cell.rowSpan(); ++rd) { |
2832 | for (int cd = 0; cd < cell.columnSpan(); ++cd) { |
2833 | const int index = (c + cd) + (r + rd) * columns; |
2834 | td->cellVerticalOffsets[index] = offset; |
2835 | } |
2836 | } |
2837 | } |
2838 | } |
2839 | |
2840 | td->minimumWidth = td->columnPositions.at(i: 0); |
2841 | for (int i = 0; i < columns; ++i) { |
2842 | td->minimumWidth += td->minWidths.at(i) + 2 * td->borderCell + cellSpacing; |
2843 | } |
2844 | td->minimumWidth += rightMargin - td->border; |
2845 | |
2846 | td->maximumWidth = td->columnPositions.at(i: 0); |
2847 | for (int i = 0; i < columns; ++i) { |
2848 | if (td->maxWidths.at(i) != QFIXED_MAX) |
2849 | td->maximumWidth += td->maxWidths.at(i) + 2 * td->borderCell + cellSpacing; |
2850 | qCDebug(lcTable) << "column" << i << "has final width" << td->widths.at(i).toReal() |
2851 | << "min" << td->minWidths.at(i).toReal() << "max" << td->maxWidths.at(i).toReal(); |
2852 | } |
2853 | td->maximumWidth += rightMargin - td->border; |
2854 | |
2855 | td->updateTableSize(); |
2856 | td->sizeDirty = false; |
2857 | return QRectF(); // invalid rect -> update everything |
2858 | } |
2859 | |
2860 | void QTextDocumentLayoutPrivate::positionFloat(QTextFrame *frame, QTextLine *currentLine) |
2861 | { |
2862 | QTextFrameData *fd = data(f: frame); |
2863 | |
2864 | QTextFrame *parent = frame->parentFrame(); |
2865 | Q_ASSERT(parent); |
2866 | QTextFrameData *pd = data(f: parent); |
2867 | Q_ASSERT(pd && pd->currentLayoutStruct); |
2868 | |
2869 | QTextLayoutStruct *layoutStruct = pd->currentLayoutStruct; |
2870 | |
2871 | if (!pd->floats.contains(t: frame)) |
2872 | pd->floats.append(t: frame); |
2873 | fd->layoutDirty = true; |
2874 | Q_ASSERT(!fd->sizeDirty); |
2875 | |
2876 | // qDebug() << "positionFloat:" << frame << "width=" << fd->size.width; |
2877 | QFixed y = layoutStruct->y; |
2878 | if (currentLine) { |
2879 | QFixed left, right; |
2880 | floatMargins(y, layoutStruct, left: &left, right: &right); |
2881 | // qDebug() << "have line: right=" << right << "left=" << left << "textWidth=" << currentLine->width(); |
2882 | if (right - left < QFixed::fromReal(r: currentLine->naturalTextWidth()) + fd->size.width) { |
2883 | layoutStruct->pendingFloats.append(t: frame); |
2884 | // qDebug(" adding to pending list"); |
2885 | return; |
2886 | } |
2887 | } |
2888 | |
2889 | bool frameSpansIntoNextPage = (y + layoutStruct->frameY + fd->size.height > layoutStruct->pageBottom); |
2890 | if (frameSpansIntoNextPage && fd->size.height <= layoutStruct->pageHeight) { |
2891 | layoutStruct->newPage(); |
2892 | y = layoutStruct->y; |
2893 | |
2894 | frameSpansIntoNextPage = false; |
2895 | } |
2896 | |
2897 | y = findY(yFrom: y, layoutStruct, requiredWidth: fd->size.width); |
2898 | |
2899 | QFixed left, right; |
2900 | floatMargins(y, layoutStruct, left: &left, right: &right); |
2901 | |
2902 | if (frame->frameFormat().position() == QTextFrameFormat::FloatLeft) { |
2903 | fd->position.x = left; |
2904 | fd->position.y = y; |
2905 | } else { |
2906 | fd->position.x = right - fd->size.width; |
2907 | fd->position.y = y; |
2908 | } |
2909 | |
2910 | layoutStruct->minimumWidth = qMax(a: layoutStruct->minimumWidth, b: fd->minimumWidth); |
2911 | layoutStruct->maximumWidth = qMin(a: layoutStruct->maximumWidth, b: fd->maximumWidth); |
2912 | |
2913 | // qDebug()<< "float positioned at " << fd->position.x << fd->position.y; |
2914 | fd->layoutDirty = false; |
2915 | |
2916 | // If the frame is a table, then positioning it will affect the size if it covers more than |
2917 | // one page, because of page breaks and repeating the header. |
2918 | if (qobject_cast<QTextTable *>(object: frame) != 0) |
2919 | fd->sizeDirty = frameSpansIntoNextPage; |
2920 | } |
2921 | |
2922 | QRectF QTextDocumentLayoutPrivate::layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed parentY) |
2923 | { |
2924 | qCDebug(lcLayout, "layoutFrame (%d--%d), parent=%p" , f->firstPosition(), f->lastPosition(), f->parentFrame()); |
2925 | Q_ASSERT(data(f)->sizeDirty); |
2926 | |
2927 | QTextFrameFormat fformat = f->frameFormat(); |
2928 | |
2929 | QTextFrame *parent = f->parentFrame(); |
2930 | const QTextFrameData *pd = parent ? data(f: parent) : nullptr; |
2931 | |
2932 | const qreal maximumWidth = qMax(a: qreal(0), b: pd ? pd->contentsWidth.toReal() : document->pageSize().width()); |
2933 | QFixed width = QFixed::fromReal(r: fformat.width().value(maximumLength: maximumWidth)); |
2934 | if (fformat.width().type() == QTextLength::FixedLength) |
2935 | width = scaleToDevice(value: width); |
2936 | |
2937 | const QFixed maximumHeight = pd ? pd->contentsHeight : -1; |
2938 | const QFixed height = (maximumHeight != -1 || fformat.height().type() != QTextLength::PercentageLength) |
2939 | ? QFixed::fromReal(r: fformat.height().value(maximumLength: maximumHeight.toReal())) |
2940 | : -1; |
2941 | |
2942 | return layoutFrame(f, layoutFrom, layoutTo, frameWidth: width, frameHeight: height, parentY); |
2943 | } |
2944 | |
2945 | QRectF QTextDocumentLayoutPrivate::layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed frameWidth, QFixed frameHeight, QFixed parentY) |
2946 | { |
2947 | qCDebug(lcLayout, "layoutFrame (%d--%d), parent=%p" , f->firstPosition(), f->lastPosition(), f->parentFrame()); |
2948 | Q_ASSERT(data(f)->sizeDirty); |
2949 | |
2950 | QTextFrameData *fd = data(f); |
2951 | QFixed newContentsWidth; |
2952 | |
2953 | bool fullLayout = false; |
2954 | { |
2955 | QTextFrameFormat fformat = f->frameFormat(); |
2956 | // set sizes of this frame from the format |
2957 | QFixed tm = QFixed::fromReal(r: scaleToDevice(value: fformat.topMargin())).round(); |
2958 | if (tm != fd->topMargin) { |
2959 | fd->topMargin = tm; |
2960 | fullLayout = true; |
2961 | } |
2962 | QFixed bm = QFixed::fromReal(r: scaleToDevice(value: fformat.bottomMargin())).round(); |
2963 | if (bm != fd->bottomMargin) { |
2964 | fd->bottomMargin = bm; |
2965 | fullLayout = true; |
2966 | } |
2967 | fd->leftMargin = QFixed::fromReal(r: scaleToDevice(value: fformat.leftMargin())).round(); |
2968 | fd->rightMargin = QFixed::fromReal(r: scaleToDevice(value: fformat.rightMargin())).round(); |
2969 | QFixed b = QFixed::fromReal(r: scaleToDevice(value: fformat.border())).round(); |
2970 | if (b != fd->border) { |
2971 | fd->border = b; |
2972 | fullLayout = true; |
2973 | } |
2974 | QFixed p = QFixed::fromReal(r: scaleToDevice(value: fformat.padding())).round(); |
2975 | if (p != fd->padding) { |
2976 | fd->padding = p; |
2977 | fullLayout = true; |
2978 | } |
2979 | |
2980 | QTextFrame *parent = f->parentFrame(); |
2981 | const QTextFrameData *pd = parent ? data(f: parent) : nullptr; |
2982 | |
2983 | // accumulate top and bottom margins |
2984 | if (parent) { |
2985 | fd->effectiveTopMargin = pd->effectiveTopMargin + fd->topMargin + fd->border + fd->padding; |
2986 | fd->effectiveBottomMargin = pd->effectiveBottomMargin + fd->topMargin + fd->border + fd->padding; |
2987 | |
2988 | if (qobject_cast<QTextTable *>(object: parent)) { |
2989 | const QTextTableData *td = static_cast<const QTextTableData *>(pd); |
2990 | fd->effectiveTopMargin += td->cellSpacing + td->border + td->cellPadding; |
2991 | fd->effectiveBottomMargin += td->cellSpacing + td->border + td->cellPadding; |
2992 | } |
2993 | } else { |
2994 | fd->effectiveTopMargin = fd->topMargin + fd->border + fd->padding; |
2995 | fd->effectiveBottomMargin = fd->bottomMargin + fd->border + fd->padding; |
2996 | } |
2997 | |
2998 | newContentsWidth = frameWidth - 2*(fd->border + fd->padding) |
2999 | - fd->leftMargin - fd->rightMargin; |
3000 | |
3001 | if (frameHeight != -1) { |
3002 | fd->contentsHeight = frameHeight - 2*(fd->border + fd->padding) |
3003 | - fd->topMargin - fd->bottomMargin; |
3004 | } else { |
3005 | fd->contentsHeight = frameHeight; |
3006 | } |
3007 | } |
3008 | |
3009 | if (isFrameFromInlineObject(f)) { |
3010 | // never reached, handled in resizeInlineObject/positionFloat instead |
3011 | return QRectF(); |
3012 | } |
3013 | |
3014 | if (QTextTable *table = qobject_cast<QTextTable *>(object: f)) { |
3015 | fd->contentsWidth = newContentsWidth; |
3016 | return layoutTable(table, layoutFrom, layoutTo, parentY); |
3017 | } |
3018 | |
3019 | // set fd->contentsWidth temporarily, so that layoutFrame for the children |
3020 | // picks the right width. We'll initialize it properly at the end of this |
3021 | // function. |
3022 | fd->contentsWidth = newContentsWidth; |
3023 | |
3024 | QTextLayoutStruct layoutStruct; |
3025 | layoutStruct.frame = f; |
3026 | layoutStruct.x_left = fd->leftMargin + fd->border + fd->padding; |
3027 | layoutStruct.x_right = layoutStruct.x_left + newContentsWidth; |
3028 | layoutStruct.y = fd->topMargin + fd->border + fd->padding; |
3029 | layoutStruct.frameY = parentY + fd->position.y; |
3030 | layoutStruct.contentsWidth = 0; |
3031 | layoutStruct.minimumWidth = 0; |
3032 | layoutStruct.maximumWidth = QFIXED_MAX; |
3033 | layoutStruct.fullLayout = fullLayout || (fd->oldContentsWidth != newContentsWidth); |
3034 | layoutStruct.updateRect = QRectF(QPointF(0, 0), QSizeF(qreal(INT_MAX), qreal(INT_MAX))); |
3035 | qCDebug(lcLayout) << "layoutStruct: x_left" << layoutStruct.x_left << "x_right" << layoutStruct.x_right |
3036 | << "fullLayout" << layoutStruct.fullLayout; |
3037 | fd->oldContentsWidth = newContentsWidth; |
3038 | |
3039 | layoutStruct.pageHeight = QFixed::fromReal(r: document->pageSize().height()); |
3040 | if (layoutStruct.pageHeight < 0) |
3041 | layoutStruct.pageHeight = QFIXED_MAX; |
3042 | |
3043 | const int currentPage = layoutStruct.pageHeight == 0 ? 0 : (layoutStruct.frameY / layoutStruct.pageHeight).truncate(); |
3044 | layoutStruct.pageTopMargin = fd->effectiveTopMargin; |
3045 | layoutStruct.pageBottomMargin = fd->effectiveBottomMargin; |
3046 | layoutStruct.pageBottom = (currentPage + 1) * layoutStruct.pageHeight - layoutStruct.pageBottomMargin; |
3047 | |
3048 | if (!f->parentFrame()) |
3049 | idealWidth = 0; // reset |
3050 | |
3051 | QTextFrame::Iterator it = f->begin(); |
3052 | layoutFlow(it, layoutStruct: &layoutStruct, layoutFrom, layoutTo); |
3053 | |
3054 | QFixed maxChildFrameWidth = 0; |
3055 | QList<QTextFrame *> children = f->childFrames(); |
3056 | for (int i = 0; i < children.size(); ++i) { |
3057 | QTextFrame *c = children.at(i); |
3058 | QTextFrameData *cd = data(f: c); |
3059 | maxChildFrameWidth = qMax(a: maxChildFrameWidth, b: cd->size.width); |
3060 | } |
3061 | |
3062 | const QFixed marginWidth = 2*(fd->border + fd->padding) + fd->leftMargin + fd->rightMargin; |
3063 | if (!f->parentFrame()) { |
3064 | idealWidth = qMax(a: maxChildFrameWidth, b: layoutStruct.contentsWidth).toReal(); |
3065 | idealWidth += marginWidth.toReal(); |
3066 | } |
3067 | |
3068 | QFixed actualWidth = qMax(a: newContentsWidth, b: qMax(a: maxChildFrameWidth, b: layoutStruct.contentsWidth)); |
3069 | fd->contentsWidth = actualWidth; |
3070 | if (newContentsWidth <= 0) { // nowrap layout? |
3071 | fd->contentsWidth = newContentsWidth; |
3072 | } |
3073 | |
3074 | fd->minimumWidth = layoutStruct.minimumWidth; |
3075 | fd->maximumWidth = layoutStruct.maximumWidth; |
3076 | |
3077 | fd->size.height = fd->contentsHeight == -1 |
3078 | ? layoutStruct.y + fd->border + fd->padding + fd->bottomMargin |
3079 | : fd->contentsHeight + 2*(fd->border + fd->padding) + fd->topMargin + fd->bottomMargin; |
3080 | fd->size.width = actualWidth + marginWidth; |
3081 | fd->sizeDirty = false; |
3082 | if (layoutStruct.updateRectForFloats.isValid()) |
3083 | layoutStruct.updateRect |= layoutStruct.updateRectForFloats; |
3084 | return layoutStruct.updateRect; |
3085 | } |
3086 | |
3087 | void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QTextLayoutStruct *layoutStruct, |
3088 | int layoutFrom, int layoutTo, QFixed width) |
3089 | { |
3090 | qCDebug(lcLayout) << "layoutFlow from=" << layoutFrom << "to=" << layoutTo; |
3091 | QTextFrameData *fd = data(f: layoutStruct->frame); |
3092 | |
3093 | fd->currentLayoutStruct = layoutStruct; |
3094 | |
3095 | QTextFrame::Iterator previousIt; |
3096 | |
3097 | const bool inRootFrame = (it.parentFrame() == document->rootFrame()); |
3098 | if (inRootFrame) { |
3099 | bool redoCheckPoints = layoutStruct->fullLayout || checkPoints.isEmpty(); |
3100 | |
3101 | if (!redoCheckPoints) { |
3102 | QVector<QCheckPoint>::Iterator checkPoint = std::lower_bound(checkPoints.begin(), checkPoints.end(), layoutFrom); |
3103 | if (checkPoint != checkPoints.end()) { |
3104 | if (checkPoint != checkPoints.begin()) |
3105 | --checkPoint; |
3106 | |
3107 | layoutStruct->y = checkPoint->y; |
3108 | layoutStruct->frameY = checkPoint->frameY; |
3109 | layoutStruct->minimumWidth = checkPoint->minimumWidth; |
3110 | layoutStruct->maximumWidth = checkPoint->maximumWidth; |
3111 | layoutStruct->contentsWidth = checkPoint->contentsWidth; |
3112 | |
3113 | if (layoutStruct->pageHeight > 0) { |
3114 | int page = layoutStruct->currentPage(); |
3115 | layoutStruct->pageBottom = (page + 1) * layoutStruct->pageHeight - layoutStruct->pageBottomMargin; |
3116 | } |
3117 | |
3118 | it = frameIteratorForTextPosition(position: checkPoint->positionInFrame); |
3119 | checkPoints.resize(size: checkPoint - checkPoints.begin() + 1); |
3120 | |
3121 | if (checkPoint != checkPoints.begin()) { |
3122 | previousIt = it; |
3123 | --previousIt; |
3124 | } |
3125 | } else { |
3126 | redoCheckPoints = true; |
3127 | } |
3128 | } |
3129 | |
3130 | if (redoCheckPoints) { |
3131 | checkPoints.clear(); |
3132 | QCheckPoint cp; |
3133 | cp.y = layoutStruct->y; |
3134 | cp.frameY = layoutStruct->frameY; |
3135 | cp.positionInFrame = 0; |
3136 | cp.minimumWidth = layoutStruct->minimumWidth; |
3137 | cp.maximumWidth = layoutStruct->maximumWidth; |
3138 | cp.contentsWidth = layoutStruct->contentsWidth; |
3139 | checkPoints.append(t: cp); |
3140 | } |
3141 | } |
3142 | |
3143 | QTextBlockFormat previousBlockFormat = previousIt.currentBlock().blockFormat(); |
3144 | |
3145 | QFixed maximumBlockWidth = 0; |
3146 | while (!it.atEnd()) { |
3147 | QTextFrame *c = it.currentFrame(); |
3148 | |
3149 | int docPos; |
3150 | if (it.currentFrame()) |
3151 | docPos = it.currentFrame()->firstPosition(); |
3152 | else |
3153 | docPos = it.currentBlock().position(); |
3154 | |
3155 | if (inRootFrame) { |
3156 | if (qAbs(t: layoutStruct->y - checkPoints.constLast().y) > 2000) { |
3157 | QFixed left, right; |
3158 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3159 | if (left == layoutStruct->x_left && right == layoutStruct->x_right) { |
3160 | QCheckPoint p; |
3161 | p.y = layoutStruct->y; |
3162 | p.frameY = layoutStruct->frameY; |
3163 | p.positionInFrame = docPos; |
3164 | p.minimumWidth = layoutStruct->minimumWidth; |
3165 | p.maximumWidth = layoutStruct->maximumWidth; |
3166 | p.contentsWidth = layoutStruct->contentsWidth; |
3167 | checkPoints.append(t: p); |
3168 | |
3169 | if (currentLazyLayoutPosition != -1 |
3170 | && docPos > currentLazyLayoutPosition + lazyLayoutStepSize) |
3171 | break; |
3172 | |
3173 | } |
3174 | } |
3175 | } |
3176 | |
3177 | if (c) { |
3178 | // position child frame |
3179 | QTextFrameData *cd = data(f: c); |
3180 | |
3181 | QTextFrameFormat fformat = c->frameFormat(); |
3182 | |
3183 | if (fformat.position() == QTextFrameFormat::InFlow) { |
3184 | if (fformat.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysBefore) |
3185 | layoutStruct->newPage(); |
3186 | |
3187 | QFixed left, right; |
3188 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3189 | left = qMax(a: left, b: layoutStruct->x_left); |
3190 | right = qMin(a: right, b: layoutStruct->x_right); |
3191 | |
3192 | if (right - left < cd->size.width) { |
3193 | layoutStruct->y = findY(yFrom: layoutStruct->y, layoutStruct, requiredWidth: cd->size.width); |
3194 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3195 | } |
3196 | |
3197 | QFixedPoint pos(left, layoutStruct->y); |
3198 | |
3199 | Qt::Alignment align = Qt::AlignLeft; |
3200 | |
3201 | QTextTable *table = qobject_cast<QTextTable *>(object: c); |
3202 | |
3203 | if (table) |
3204 | align = table->format().alignment() & Qt::AlignHorizontal_Mask; |
3205 | |
3206 | // detect whether we have any alignment in the document that disallows optimizations, |
3207 | // such as not laying out the document again in a textedit with wrapping disabled. |
3208 | if (inRootFrame && !(align & Qt::AlignLeft)) |
3209 | contentHasAlignment = true; |
3210 | |
3211 | cd->position = pos; |
3212 | |
3213 | if (document->pageSize().height() > 0.0f) |
3214 | cd->sizeDirty = true; |
3215 | |
3216 | if (cd->sizeDirty) { |
3217 | if (width != 0) |
3218 | layoutFrame(f: c, layoutFrom, layoutTo, frameWidth: width, frameHeight: -1, parentY: layoutStruct->frameY); |
3219 | else |
3220 | layoutFrame(f: c, layoutFrom, layoutTo, parentY: layoutStruct->frameY); |
3221 | |
3222 | QFixed absoluteChildPos = table ? pos.y + static_cast<QTextTableData *>(data(f: table))->rowPositions.at(i: 0) : pos.y + firstChildPos(f: c); |
3223 | absoluteChildPos += layoutStruct->frameY; |
3224 | |
3225 | // drop entire frame to next page if first child of frame is on next page |
3226 | if (absoluteChildPos > layoutStruct->pageBottom) { |
3227 | layoutStruct->newPage(); |
3228 | pos.y = layoutStruct->y; |
3229 | |
3230 | cd->position = pos; |
3231 | cd->sizeDirty = true; |
3232 | |
3233 | if (width != 0) |
3234 | layoutFrame(f: c, layoutFrom, layoutTo, frameWidth: width, frameHeight: -1, parentY: layoutStruct->frameY); |
3235 | else |
3236 | layoutFrame(f: c, layoutFrom, layoutTo, parentY: layoutStruct->frameY); |
3237 | } |
3238 | } |
3239 | |
3240 | // align only if there is space for alignment |
3241 | if (right - left > cd->size.width) { |
3242 | if (align & Qt::AlignRight) |
3243 | pos.x += layoutStruct->x_right - cd->size.width; |
3244 | else if (align & Qt::AlignHCenter) |
3245 | pos.x += (layoutStruct->x_right - cd->size.width) / 2; |
3246 | } |
3247 | |
3248 | cd->position = pos; |
3249 | |
3250 | layoutStruct->y += cd->size.height; |
3251 | const int page = layoutStruct->currentPage(); |
3252 | layoutStruct->pageBottom = (page + 1) * layoutStruct->pageHeight - layoutStruct->pageBottomMargin; |
3253 | |
3254 | cd->layoutDirty = false; |
3255 | |
3256 | if (c->frameFormat().pageBreakPolicy() & QTextFormat::PageBreak_AlwaysAfter) |
3257 | layoutStruct->newPage(); |
3258 | } else { |
3259 | QRectF oldFrameRect(cd->position.toPointF(), cd->size.toSizeF()); |
3260 | QRectF updateRect; |
3261 | |
3262 | if (cd->sizeDirty) |
3263 | updateRect = layoutFrame(f: c, layoutFrom, layoutTo); |
3264 | |
3265 | positionFloat(frame: c); |
3266 | |
3267 | // If the size was made dirty when the position was set, layout again |
3268 | if (cd->sizeDirty) |
3269 | updateRect = layoutFrame(f: c, layoutFrom, layoutTo); |
3270 | |
3271 | QRectF frameRect(cd->position.toPointF(), cd->size.toSizeF()); |
3272 | |
3273 | if (frameRect == oldFrameRect && updateRect.isValid()) |
3274 | updateRect.translate(p: cd->position.toPointF()); |
3275 | else |
3276 | updateRect = frameRect; |
3277 | |
3278 | layoutStruct->addUpdateRectForFloat(rect: updateRect); |
3279 | if (oldFrameRect.isValid()) |
3280 | layoutStruct->addUpdateRectForFloat(rect: oldFrameRect); |
3281 | } |
3282 | |
3283 | layoutStruct->minimumWidth = qMax(a: layoutStruct->minimumWidth, b: cd->minimumWidth); |
3284 | layoutStruct->maximumWidth = qMin(a: layoutStruct->maximumWidth, b: cd->maximumWidth); |
3285 | |
3286 | previousIt = it; |
3287 | ++it; |
3288 | } else { |
3289 | QTextFrame::Iterator lastIt; |
3290 | if (!previousIt.atEnd() && previousIt != it) |
3291 | lastIt = previousIt; |
3292 | previousIt = it; |
3293 | QTextBlock block = it.currentBlock(); |
3294 | ++it; |
3295 | |
3296 | const QTextBlockFormat blockFormat = block.blockFormat(); |
3297 | |
3298 | if (blockFormat.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysBefore) |
3299 | layoutStruct->newPage(); |
3300 | |
3301 | const QFixed origY = layoutStruct->y; |
3302 | const QFixed origPageBottom = layoutStruct->pageBottom; |
3303 | const QFixed origMaximumWidth = layoutStruct->maximumWidth; |
3304 | layoutStruct->maximumWidth = 0; |
3305 | |
3306 | const QTextBlockFormat *previousBlockFormatPtr = nullptr; |
3307 | if (lastIt.currentBlock().isValid()) |
3308 | previousBlockFormatPtr = &previousBlockFormat; |
3309 | |
3310 | // layout and position child block |
3311 | layoutBlock(bl: block, blockPosition: docPos, blockFormat, layoutStruct, layoutFrom, layoutTo, previousBlockFormat: previousBlockFormatPtr); |
3312 | |
3313 | // detect whether we have any alignment in the document that disallows optimizations, |
3314 | // such as not laying out the document again in a textedit with wrapping disabled. |
3315 | if (inRootFrame && !(block.layout()->textOption().alignment() & Qt::AlignLeft)) |
3316 | contentHasAlignment = true; |
3317 | |
3318 | // if the block right before a table is empty 'hide' it by |
3319 | // positioning it into the table border |
3320 | if (isEmptyBlockBeforeTable(block, format: blockFormat, nextIt: it)) { |
3321 | const QTextBlock lastBlock = lastIt.currentBlock(); |
3322 | const qreal lastBlockBottomMargin = lastBlock.isValid() ? lastBlock.blockFormat().bottomMargin() : 0.0f; |
3323 | layoutStruct->y = origY + QFixed::fromReal(r: qMax(a: lastBlockBottomMargin, b: block.blockFormat().topMargin())); |
3324 | layoutStruct->pageBottom = origPageBottom; |
3325 | } else { |
3326 | // if the block right after a table is empty then 'hide' it, too |
3327 | if (isEmptyBlockAfterTable(block, previousFrame: lastIt.currentFrame())) { |
3328 | QTextTableData *td = static_cast<QTextTableData *>(data(f: lastIt.currentFrame())); |
3329 | QTextLayout *layout = block.layout(); |
3330 | |
3331 | QPointF pos((td->position.x + td->size.width).toReal(), |
3332 | (td->position.y + td->size.height).toReal() - layout->boundingRect().height()); |
3333 | |
3334 | layout->setPosition(pos); |
3335 | layoutStruct->y = origY; |
3336 | layoutStruct->pageBottom = origPageBottom; |
3337 | } |
3338 | |
3339 | // if the block right after a table starts with a line separator, shift it up by one line |
3340 | if (isLineSeparatorBlockAfterTable(block, previousFrame: lastIt.currentFrame())) { |
3341 | QTextTableData *td = static_cast<QTextTableData *>(data(f: lastIt.currentFrame())); |
3342 | QTextLayout *layout = block.layout(); |
3343 | |
3344 | QFixed height = layout->lineCount() > 0 ? QFixed::fromReal(r: layout->lineAt(i: 0).height()) : QFixed(); |
3345 | |
3346 | if (layoutStruct->pageBottom == origPageBottom) { |
3347 | layoutStruct->y -= height; |
3348 | layout->setPosition(layout->position() - QPointF(0, height.toReal())); |
3349 | } else { |
3350 | // relayout block to correctly handle page breaks |
3351 | layoutStruct->y = origY - height; |
3352 | layoutStruct->pageBottom = origPageBottom; |
3353 | layoutBlock(bl: block, blockPosition: docPos, blockFormat, layoutStruct, layoutFrom, layoutTo, previousBlockFormat: previousBlockFormatPtr); |
3354 | } |
3355 | |
3356 | if (layout->lineCount() > 0) { |
3357 | QPointF linePos((td->position.x + td->size.width).toReal(), |
3358 | (td->position.y + td->size.height - height).toReal()); |
3359 | |
3360 | layout->lineAt(i: 0).setPosition(linePos - layout->position()); |
3361 | } |
3362 | } |
3363 | |
3364 | if (blockFormat.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysAfter) |
3365 | layoutStruct->newPage(); |
3366 | } |
3367 | |
3368 | maximumBlockWidth = qMax(a: maximumBlockWidth, b: layoutStruct->maximumWidth); |
3369 | layoutStruct->maximumWidth = origMaximumWidth; |
3370 | previousBlockFormat = blockFormat; |
3371 | } |
3372 | } |
3373 | if (layoutStruct->maximumWidth == QFIXED_MAX && maximumBlockWidth > 0) |
3374 | layoutStruct->maximumWidth = maximumBlockWidth; |
3375 | else |
3376 | layoutStruct->maximumWidth = qMax(a: layoutStruct->maximumWidth, b: maximumBlockWidth); |
3377 | |
3378 | // a float at the bottom of a frame may make it taller, hence the qMax() for layoutStruct->y. |
3379 | // we don't need to do it for tables though because floats in tables are per table |
3380 | // and not per cell and layoutCell already takes care of doing the same as we do here |
3381 | if (!qobject_cast<QTextTable *>(object: layoutStruct->frame)) { |
3382 | QList<QTextFrame *> children = layoutStruct->frame->childFrames(); |
3383 | for (int i = 0; i < children.count(); ++i) { |
3384 | QTextFrameData *fd = data(f: children.at(i)); |
3385 | if (!fd->layoutDirty && children.at(i)->frameFormat().position() != QTextFrameFormat::InFlow) |
3386 | layoutStruct->y = qMax(a: layoutStruct->y, b: fd->position.y + fd->size.height); |
3387 | } |
3388 | } |
3389 | |
3390 | if (inRootFrame) { |
3391 | // we assume that any float is aligned in a way that disallows the optimizations that rely |
3392 | // on unaligned content. |
3393 | if (!fd->floats.isEmpty()) |
3394 | contentHasAlignment = true; |
3395 | |
3396 | if (it.atEnd()) { |
3397 | //qDebug("layout done!"); |
3398 | currentLazyLayoutPosition = -1; |
3399 | QCheckPoint cp; |
3400 | cp.y = layoutStruct->y; |
3401 | cp.positionInFrame = docPrivate->length(); |
3402 | cp.minimumWidth = layoutStruct->minimumWidth; |
3403 | cp.maximumWidth = layoutStruct->maximumWidth; |
3404 | cp.contentsWidth = layoutStruct->contentsWidth; |
3405 | checkPoints.append(t: cp); |
3406 | checkPoints.reserve(size: checkPoints.size()); |
3407 | } else { |
3408 | currentLazyLayoutPosition = checkPoints.constLast().positionInFrame; |
3409 | // ####### |
3410 | //checkPoints.last().positionInFrame = q->document()->docHandle()->length(); |
3411 | } |
3412 | } |
3413 | |
3414 | |
3415 | fd->currentLayoutStruct = nullptr; |
3416 | } |
3417 | |
3418 | static inline void getLineHeightParams(const QTextBlockFormat &blockFormat, const QTextLine &line, qreal scaling, |
3419 | QFixed *lineAdjustment, QFixed *lineBreakHeight, QFixed *lineHeight, QFixed *lineBottom) |
3420 | { |
3421 | qreal rawHeight = qCeil(v: line.ascent() + line.descent() + line.leading()); |
3422 | *lineHeight = QFixed::fromReal(r: blockFormat.lineHeight(scriptLineHeight: rawHeight, scaling)); |
3423 | *lineBottom = QFixed::fromReal(r: blockFormat.lineHeight(scriptLineHeight: line.height(), scaling)); |
3424 | |
3425 | if (blockFormat.lineHeightType() == QTextBlockFormat::FixedHeight || blockFormat.lineHeightType() == QTextBlockFormat::MinimumHeight) { |
3426 | *lineBreakHeight = *lineBottom; |
3427 | if (blockFormat.lineHeightType() == QTextBlockFormat::FixedHeight) |
3428 | *lineAdjustment = QFixed::fromReal(r: line.ascent() + qMax(a: line.leading(), b: qreal(0.0))) - ((*lineHeight * 4) / 5); |
3429 | else |
3430 | *lineAdjustment = QFixed::fromReal(r: line.height()) - *lineHeight; |
3431 | } |
3432 | else { |
3433 | *lineBreakHeight = QFixed::fromReal(r: line.height()); |
3434 | *lineAdjustment = 0; |
3435 | } |
3436 | } |
3437 | |
3438 | void QTextDocumentLayoutPrivate::layoutBlock(const QTextBlock &bl, int blockPosition, const QTextBlockFormat &blockFormat, |
3439 | QTextLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat) |
3440 | { |
3441 | Q_Q(QTextDocumentLayout); |
3442 | if (!bl.isVisible()) |
3443 | return; |
3444 | |
3445 | QTextLayout *tl = bl.layout(); |
3446 | const int blockLength = bl.length(); |
3447 | |
3448 | qCDebug(lcLayout) << "layoutBlock from=" << layoutFrom << "to=" << layoutTo |
3449 | << "; width" << layoutStruct->x_right - layoutStruct->x_left << "(maxWidth is btw" << tl->maximumWidth() << ')'; |
3450 | |
3451 | if (previousBlockFormat) { |
3452 | qreal margin = qMax(a: blockFormat.topMargin(), b: previousBlockFormat->bottomMargin()); |
3453 | if (margin > 0 && q->paintDevice()) { |
3454 | margin *= qreal(q->paintDevice()->logicalDpiY()) / qreal(qt_defaultDpi()); |
3455 | } |
3456 | layoutStruct->y += QFixed::fromReal(r: margin); |
3457 | } |
3458 | |
3459 | //QTextFrameData *fd = data(layoutStruct->frame); |
3460 | |
3461 | Qt::LayoutDirection dir = bl.textDirection(); |
3462 | |
3463 | QFixed ; |
3464 | if (docPrivate->defaultTextOption.flags() & QTextOption::AddSpaceForLineAndParagraphSeparators) { |
3465 | QFontMetricsF fm(bl.charFormat().font()); |
3466 | extraMargin = QFixed::fromReal(r: fm.horizontalAdvance(QChar(QChar(0x21B5)))); |
3467 | } |
3468 | |
3469 | const QFixed indent = this->blockIndent(blockFormat); |
3470 | const QFixed totalLeftMargin = QFixed::fromReal(r: blockFormat.leftMargin()) + (dir == Qt::RightToLeft ? extraMargin : indent); |
3471 | const QFixed totalRightMargin = QFixed::fromReal(r: blockFormat.rightMargin()) + (dir == Qt::RightToLeft ? indent : extraMargin); |
3472 | |
3473 | const QPointF oldPosition = tl->position(); |
3474 | tl->setPosition(QPointF(layoutStruct->x_left.toReal(), layoutStruct->y.toReal())); |
3475 | |
3476 | if (layoutStruct->fullLayout |
3477 | || (blockPosition + blockLength > layoutFrom && blockPosition <= layoutTo) |
3478 | // force relayout if we cross a page boundary |
3479 | || (layoutStruct->pageHeight != QFIXED_MAX && layoutStruct->absoluteY() + QFixed::fromReal(r: tl->boundingRect().height()) > layoutStruct->pageBottom)) { |
3480 | |
3481 | qCDebug(lcLayout) << "do layout" ; |
3482 | QTextOption option = docPrivate->defaultTextOption; |
3483 | option.setTextDirection(dir); |
3484 | option.setTabs( blockFormat.tabPositions() ); |
3485 | |
3486 | Qt::Alignment align = docPrivate->defaultTextOption.alignment(); |
3487 | if (blockFormat.hasProperty(propertyId: QTextFormat::BlockAlignment)) |
3488 | align = blockFormat.alignment(); |
3489 | option.setAlignment(QGuiApplicationPrivate::visualAlignment(direction: dir, alignment: align)); // for paragraph that are RTL, alignment is auto-reversed; |
3490 | |
3491 | if (blockFormat.nonBreakableLines() || document->pageSize().width() < 0) { |
3492 | option.setWrapMode(QTextOption::ManualWrap); |
3493 | } |
3494 | |
3495 | tl->setTextOption(option); |
3496 | |
3497 | const bool haveWordOrAnyWrapMode = (option.wrapMode() == QTextOption::WrapAtWordBoundaryOrAnywhere); |
3498 | |
3499 | // qDebug() << " layouting block at" << bl.position(); |
3500 | const QFixed cy = layoutStruct->y; |
3501 | const QFixed l = layoutStruct->x_left + totalLeftMargin; |
3502 | const QFixed r = layoutStruct->x_right - totalRightMargin; |
3503 | QFixed bottom; |
3504 | |
3505 | tl->beginLayout(); |
3506 | bool firstLine = true; |
3507 | while (1) { |
3508 | QTextLine line = tl->createLine(); |
3509 | if (!line.isValid()) |
3510 | break; |
3511 | line.setLeadingIncluded(true); |
3512 | |
3513 | QFixed left, right; |
3514 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3515 | left = qMax(a: left, b: l); |
3516 | right = qMin(a: right, b: r); |
3517 | QFixed text_indent; |
3518 | if (firstLine) { |
3519 | text_indent = QFixed::fromReal(r: blockFormat.textIndent()); |
3520 | if (dir == Qt::LeftToRight) |
3521 | left += text_indent; |
3522 | else |
3523 | right -= text_indent; |
3524 | firstLine = false; |
3525 | } |
3526 | // qDebug() << "layout line y=" << currentYPos << "left=" << left << "right=" <<right; |
3527 | |
3528 | if (fixedColumnWidth != -1) |
3529 | line.setNumColumns(columns: fixedColumnWidth, alignmentWidth: (right - left).toReal()); |
3530 | else |
3531 | line.setLineWidth((right - left).toReal()); |
3532 | |
3533 | // qDebug() << "layoutBlock; layouting line with width" << right - left << "->textWidth" << line.textWidth(); |
3534 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3535 | left = qMax(a: left, b: l); |
3536 | right = qMin(a: right, b: r); |
3537 | if (dir == Qt::LeftToRight) |
3538 | left += text_indent; |
3539 | else |
3540 | right -= text_indent; |
3541 | |
3542 | if (fixedColumnWidth == -1 && QFixed::fromReal(r: line.naturalTextWidth()) > right-left) { |
3543 | // float has been added in the meantime, redo |
3544 | layoutStruct->pendingFloats.clear(); |
3545 | |
3546 | line.setLineWidth((right-left).toReal()); |
3547 | if (QFixed::fromReal(r: line.naturalTextWidth()) > right-left) { |
3548 | if (haveWordOrAnyWrapMode) { |
3549 | option.setWrapMode(QTextOption::WrapAnywhere); |
3550 | tl->setTextOption(option); |
3551 | } |
3552 | |
3553 | layoutStruct->pendingFloats.clear(); |
3554 | // lines min width more than what we have |
3555 | layoutStruct->y = findY(yFrom: layoutStruct->y, layoutStruct, requiredWidth: QFixed::fromReal(r: line.naturalTextWidth())); |
3556 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3557 | left = qMax(a: left, b: l); |
3558 | right = qMin(a: right, b: r); |
3559 | if (dir == Qt::LeftToRight) |
3560 | left += text_indent; |
3561 | else |
3562 | right -= text_indent; |
3563 | line.setLineWidth(qMax<qreal>(a: line.naturalTextWidth(), b: (right-left).toReal())); |
3564 | |
3565 | if (haveWordOrAnyWrapMode) { |
3566 | option.setWrapMode(QTextOption::WordWrap); |
3567 | tl->setTextOption(option); |
3568 | } |
3569 | } |
3570 | |
3571 | } |
3572 | |
3573 | QFixed lineBreakHeight, lineHeight, lineAdjustment, lineBottom; |
3574 | qreal scaling = (q->paintDevice() && q->paintDevice()->logicalDpiY() != qt_defaultDpi()) ? |
3575 | qreal(q->paintDevice()->logicalDpiY()) / qreal(qt_defaultDpi()) : 1; |
3576 | getLineHeightParams(blockFormat, line, scaling, lineAdjustment: &lineAdjustment, lineBreakHeight: &lineBreakHeight, lineHeight: &lineHeight, lineBottom: &lineBottom); |
3577 | |
3578 | while (layoutStruct->pageHeight > 0 && layoutStruct->absoluteY() + lineBreakHeight > layoutStruct->pageBottom && |
3579 | layoutStruct->contentHeight() >= lineBreakHeight) { |
3580 | layoutStruct->newPage(); |
3581 | |
3582 | floatMargins(y: layoutStruct->y, layoutStruct, left: &left, right: &right); |
3583 | left = qMax(a: left, b: l); |
3584 | right = qMin(a: right, b: r); |
3585 | if (dir == Qt::LeftToRight) |
3586 | left += text_indent; |
3587 | else |
3588 | right -= text_indent; |
3589 | } |
3590 | |
3591 | line.setPosition(QPointF((left - layoutStruct->x_left).toReal(), (layoutStruct->y - cy - lineAdjustment).toReal())); |
3592 | bottom = layoutStruct->y + lineBottom; |
3593 | layoutStruct->y += lineHeight; |
3594 | layoutStruct->contentsWidth |
3595 | = qMax<QFixed>(a: layoutStruct->contentsWidth, b: QFixed::fromReal(r: line.x() + line.naturalTextWidth()) + totalRightMargin); |
3596 | |
3597 | // position floats |
3598 | for (int i = 0; i < layoutStruct->pendingFloats.size(); ++i) { |
3599 | QTextFrame *f = layoutStruct->pendingFloats.at(i); |
3600 | positionFloat(frame: f); |
3601 | } |
3602 | layoutStruct->pendingFloats.clear(); |
3603 | } |
3604 | layoutStruct->y = qMax(a: layoutStruct->y, b: bottom); |
3605 | tl->endLayout(); |
3606 | } else { |
3607 | const int cnt = tl->lineCount(); |
3608 | QFixed bottom; |
3609 | for (int i = 0; i < cnt; ++i) { |
3610 | qCDebug(lcLayout) << "going to move text line" << i; |
3611 | QTextLine line = tl->lineAt(i); |
3612 | layoutStruct->contentsWidth |
3613 | = qMax(a: layoutStruct->contentsWidth, b: QFixed::fromReal(r: line.x() + tl->lineAt(i).naturalTextWidth()) + totalRightMargin); |
3614 | |
3615 | QFixed lineBreakHeight, lineHeight, lineAdjustment, lineBottom; |
3616 | qreal scaling = (q->paintDevice() && q->paintDevice()->logicalDpiY() != qt_defaultDpi()) ? |
3617 | qreal(q->paintDevice()->logicalDpiY()) / qreal(qt_defaultDpi()) : 1; |
3618 | getLineHeightParams(blockFormat, line, scaling, lineAdjustment: &lineAdjustment, lineBreakHeight: &lineBreakHeight, lineHeight: &lineHeight, lineBottom: &lineBottom); |
3619 | |
3620 | if (layoutStruct->pageHeight != QFIXED_MAX) { |
3621 | if (layoutStruct->absoluteY() + lineBreakHeight > layoutStruct->pageBottom) |
3622 | layoutStruct->newPage(); |
3623 | line.setPosition(QPointF(line.position().x(), (layoutStruct->y - lineAdjustment).toReal() - tl->position().y())); |
3624 | } |
3625 | bottom = layoutStruct->y + lineBottom; |
3626 | layoutStruct->y += lineHeight; |
3627 | } |
3628 | layoutStruct->y = qMax(a: layoutStruct->y, b: bottom); |
3629 | if (layoutStruct->updateRect.isValid() |
3630 | && blockLength > 1) { |
3631 | if (layoutFrom >= blockPosition + blockLength) { |
3632 | // if our height didn't change and the change in the document is |
3633 | // in one of the later paragraphs, then we don't need to repaint |
3634 | // this one |
3635 | layoutStruct->updateRect.setTop(qMax(a: layoutStruct->updateRect.top(), b: layoutStruct->y.toReal())); |
3636 | } else if (layoutTo < blockPosition) { |
3637 | if (oldPosition == tl->position()) |
3638 | // if the change in the document happened earlier in the document |
3639 | // and our position did /not/ change because none of the earlier paragraphs |
3640 | // or frames changed their height, then we don't need to repaint |
3641 | // this one |
3642 | layoutStruct->updateRect.setBottom(qMin(a: layoutStruct->updateRect.bottom(), b: tl->position().y())); |
3643 | else |
3644 | layoutStruct->updateRect.setBottom(qreal(INT_MAX)); // reset |
3645 | } |
3646 | } |
3647 | } |
3648 | |
3649 | // ### doesn't take floats into account. would need to do it per line. but how to retrieve then? (Simon) |
3650 | const QFixed margins = totalLeftMargin + totalRightMargin; |
3651 | layoutStruct->minimumWidth = qMax(a: layoutStruct->minimumWidth, b: QFixed::fromReal(r: tl->minimumWidth()) + margins); |
3652 | |
3653 | const QFixed maxW = QFixed::fromReal(r: tl->maximumWidth()) + margins; |
3654 | |
3655 | if (maxW > 0) { |
3656 | if (layoutStruct->maximumWidth == QFIXED_MAX) |
3657 | layoutStruct->maximumWidth = maxW; |
3658 | else |
3659 | layoutStruct->maximumWidth = qMax(a: layoutStruct->maximumWidth, b: maxW); |
3660 | } |
3661 | } |
3662 | |
3663 | void QTextDocumentLayoutPrivate::floatMargins(const QFixed &y, const QTextLayoutStruct *layoutStruct, |
3664 | QFixed *left, QFixed *right) const |
3665 | { |
3666 | // qDebug() << "floatMargins y=" << y; |
3667 | *left = layoutStruct->x_left; |
3668 | *right = layoutStruct->x_right; |
3669 | QTextFrameData *lfd = data(f: layoutStruct->frame); |
3670 | for (int i = 0; i < lfd->floats.size(); ++i) { |
3671 | QTextFrameData *fd = data(f: lfd->floats.at(i)); |
3672 | if (!fd->layoutDirty) { |
3673 | if (fd->position.y <= y && fd->position.y + fd->size.height > y) { |
3674 | // qDebug() << "adjusting with float" << f << fd->position.x()<< fd->size.width(); |
3675 | if (lfd->floats.at(i)->frameFormat().position() == QTextFrameFormat::FloatLeft) |
3676 | *left = qMax(a: *left, b: fd->position.x + fd->size.width); |
3677 | else |
3678 | *right = qMin(a: *right, b: fd->position.x); |
3679 | } |
3680 | } |
3681 | } |
3682 | // qDebug() << "floatMargins: left="<<*left<<"right="<<*right<<"y="<<y; |
3683 | } |
3684 | |
3685 | QFixed QTextDocumentLayoutPrivate::findY(QFixed yFrom, const QTextLayoutStruct *layoutStruct, QFixed requiredWidth) const |
3686 | { |
3687 | QFixed right, left; |
3688 | requiredWidth = qMin(a: requiredWidth, b: layoutStruct->x_right - layoutStruct->x_left); |
3689 | |
3690 | // qDebug() << "findY:" << yFrom; |
3691 | while (1) { |
3692 | floatMargins(y: yFrom, layoutStruct, left: &left, right: &right); |
3693 | // qDebug() << " yFrom=" << yFrom<<"right=" << right << "left=" << left << "requiredWidth=" << requiredWidth; |
3694 | if (right-left >= requiredWidth) |
3695 | break; |
3696 | |
3697 | // move float down until we find enough space |
3698 | QFixed newY = QFIXED_MAX; |
3699 | QTextFrameData *lfd = data(f: layoutStruct->frame); |
3700 | for (int i = 0; i < lfd->floats.size(); ++i) { |
3701 | QTextFrameData *fd = data(f: lfd->floats.at(i)); |
3702 | if (!fd->layoutDirty) { |
3703 | if (fd->position.y <= yFrom && fd->position.y + fd->size.height > yFrom) |
3704 | newY = qMin(a: newY, b: fd->position.y + fd->size.height); |
3705 | } |
3706 | } |
3707 | if (newY == QFIXED_MAX) |
3708 | break; |
3709 | yFrom = newY; |
3710 | } |
3711 | return yFrom; |
3712 | } |
3713 | |
3714 | QTextDocumentLayout::QTextDocumentLayout(QTextDocument *doc) |
3715 | : QAbstractTextDocumentLayout(*new QTextDocumentLayoutPrivate, doc) |
3716 | { |
3717 | registerHandler(objectType: QTextFormat::ImageObject, component: new QTextImageHandler(this)); |
3718 | } |
3719 | |
3720 | |
3721 | void QTextDocumentLayout::draw(QPainter *painter, const PaintContext &context) |
3722 | { |
3723 | Q_D(QTextDocumentLayout); |
3724 | QTextFrame *frame = d->document->rootFrame(); |
3725 | QTextFrameData *fd = data(f: frame); |
3726 | |
3727 | if(fd->sizeDirty) |
3728 | return; |
3729 | |
3730 | if (context.clip.isValid()) { |
3731 | d->ensureLayouted(y: QFixed::fromReal(r: context.clip.bottom())); |
3732 | } else { |
3733 | d->ensureLayoutFinished(); |
3734 | } |
3735 | |
3736 | QFixed width = fd->size.width; |
3737 | if (d->document->pageSize().width() == 0 && d->viewportRect.isValid()) { |
3738 | // we're in NoWrap mode, meaning the frame should expand to the viewport |
3739 | // so that backgrounds are drawn correctly |
3740 | fd->size.width = qMax(a: width, b: QFixed::fromReal(r: d->viewportRect.right())); |
3741 | } |
3742 | |
3743 | // Make sure we conform to the root frames bounds when drawing. |
3744 | d->clipRect = QRectF(fd->position.toPointF(), fd->size.toSizeF()).adjusted(xp1: fd->leftMargin.toReal(), yp1: 0, xp2: -fd->rightMargin.toReal(), yp2: 0); |
3745 | d->drawFrame(offset: QPointF(), painter, context, frame); |
3746 | fd->size.width = width; |
3747 | } |
3748 | |
3749 | void QTextDocumentLayout::setViewport(const QRectF &viewport) |
3750 | { |
3751 | Q_D(QTextDocumentLayout); |
3752 | d->viewportRect = viewport; |
3753 | } |
3754 | |
3755 | static void markFrames(QTextFrame *current, int from, int oldLength, int length) |
3756 | { |
3757 | int end = qMax(a: oldLength, b: length) + from; |
3758 | |
3759 | if (current->firstPosition() >= end || current->lastPosition() < from) |
3760 | return; |
3761 | |
3762 | QTextFrameData *fd = data(f: current); |
3763 | // float got removed in editing operation |
3764 | QTextFrame *null = nullptr; // work-around for (at least) MSVC 2012 emitting |
3765 | // warning C4100 for its own header <algorithm> |
3766 | // when passing nullptr directly to std::remove |
3767 | fd->floats.erase(begin: std::remove(first: fd->floats.begin(), last: fd->floats.end(), value: null), |
3768 | end: fd->floats.end()); |
3769 | |
3770 | fd->layoutDirty = true; |
3771 | fd->sizeDirty = true; |
3772 | |
3773 | // qDebug(" marking frame (%d--%d) as dirty", current->firstPosition(), current->lastPosition()); |
3774 | QList<QTextFrame *> children = current->childFrames(); |
3775 | for (int i = 0; i < children.size(); ++i) |
3776 | markFrames(current: children.at(i), from, oldLength, length); |
3777 | } |
3778 | |
3779 | void QTextDocumentLayout::documentChanged(int from, int oldLength, int length) |
3780 | { |
3781 | Q_D(QTextDocumentLayout); |
3782 | |
3783 | QTextBlock blockIt = document()->findBlock(pos: from); |
3784 | QTextBlock endIt = document()->findBlock(pos: qMax(a: 0, b: from + length - 1)); |
3785 | if (endIt.isValid()) |
3786 | endIt = endIt.next(); |
3787 | for (; blockIt.isValid() && blockIt != endIt; blockIt = blockIt.next()) |
3788 | blockIt.clearLayout(); |
3789 | |
3790 | if (d->docPrivate->pageSize.isNull()) |
3791 | return; |
3792 | |
3793 | QRectF updateRect; |
3794 | |
3795 | d->lazyLayoutStepSize = 1000; |
3796 | d->sizeChangedTimer.stop(); |
3797 | d->insideDocumentChange = true; |
3798 | |
3799 | const int documentLength = d->docPrivate->length(); |
3800 | const bool fullLayout = (oldLength == 0 && length == documentLength); |
3801 | const bool smallChange = documentLength > 0 |
3802 | && (qMax(a: length, b: oldLength) * 100 / documentLength) < 5; |
3803 | |
3804 | // don't show incremental layout progress (avoid scroll bar flicker) |
3805 | // if we see only a small change in the document and we're either starting |
3806 | // a layout run or we're already in progress for that and we haven't seen |
3807 | // any bigger change previously (showLayoutProgress already false) |
3808 | if (smallChange |
3809 | && (d->currentLazyLayoutPosition == -1 || d->showLayoutProgress == false)) |
3810 | d->showLayoutProgress = false; |
3811 | else |
3812 | d->showLayoutProgress = true; |
3813 | |
3814 | if (fullLayout) { |
3815 | d->contentHasAlignment = false; |
3816 | d->currentLazyLayoutPosition = 0; |
3817 | d->checkPoints.clear(); |
3818 | d->layoutStep(); |
3819 | } else { |
3820 | d->ensureLayoutedByPosition(position: from); |
3821 | updateRect = doLayout(from, oldLength, length); |
3822 | } |
3823 | |
3824 | if (!d->layoutTimer.isActive() && d->currentLazyLayoutPosition != -1) |
3825 | d->layoutTimer.start(msec: 10, obj: this); |
3826 | |
3827 | d->insideDocumentChange = false; |
3828 | |
3829 | if (d->showLayoutProgress) { |
3830 | const QSizeF newSize = dynamicDocumentSize(); |
3831 | if (newSize != d->lastReportedSize) { |
3832 | d->lastReportedSize = newSize; |
3833 | emit documentSizeChanged(newSize); |
3834 | } |
3835 | } |
3836 | |
3837 | if (!updateRect.isValid()) { |
3838 | // don't use the frame size, it might have shrunken |
3839 | updateRect = QRectF(QPointF(0, 0), QSizeF(qreal(INT_MAX), qreal(INT_MAX))); |
3840 | } |
3841 | |
3842 | emit update(updateRect); |
3843 | } |
3844 | |
3845 | QRectF QTextDocumentLayout::doLayout(int from, int oldLength, int length) |
3846 | { |
3847 | Q_D(QTextDocumentLayout); |
3848 | |
3849 | // qDebug("documentChange: from=%d, oldLength=%d, length=%d", from, oldLength, length); |
3850 | |
3851 | // mark all frames between f_start and f_end as dirty |
3852 | markFrames(current: d->docPrivate->rootFrame(), from, oldLength, length); |
3853 | |
3854 | QRectF updateRect; |
3855 | |
3856 | QTextFrame *root = d->docPrivate->rootFrame(); |
3857 | if(data(f: root)->sizeDirty) |
3858 | updateRect = d->layoutFrame(f: root, layoutFrom: from, layoutTo: from + length); |
3859 | data(f: root)->layoutDirty = false; |
3860 | |
3861 | if (d->currentLazyLayoutPosition == -1) |
3862 | layoutFinished(); |
3863 | else if (d->showLayoutProgress) |
3864 | d->sizeChangedTimer.start(msec: 0, obj: this); |
3865 | |
3866 | return updateRect; |
3867 | } |
3868 | |
3869 | int QTextDocumentLayout::hitTest(const QPointF &point, Qt::HitTestAccuracy accuracy) const |
3870 | { |
3871 | Q_D(const QTextDocumentLayout); |
3872 | d->ensureLayouted(y: QFixed::fromReal(r: point.y())); |
3873 | QTextFrame *f = d->docPrivate->rootFrame(); |
3874 | int position = 0; |
3875 | QTextLayout *l = nullptr; |
3876 | QFixedPoint pointf; |
3877 | pointf.x = QFixed::fromReal(r: point.x()); |
3878 | pointf.y = QFixed::fromReal(r: point.y()); |
3879 | QTextDocumentLayoutPrivate::HitPoint p = d->hitTest(frame: f, point: pointf, position: &position, l: &l, accuracy); |
3880 | if (accuracy == Qt::ExactHit && p < QTextDocumentLayoutPrivate::PointExact) |
3881 | return -1; |
3882 | |
3883 | // ensure we stay within document bounds |
3884 | int lastPos = f->lastPosition(); |
3885 | if (l && !l->preeditAreaText().isEmpty()) |
3886 | lastPos += l->preeditAreaText().length(); |
3887 | if (position > lastPos) |
3888 | position = lastPos; |
3889 | else if (position < 0) |
3890 | position = 0; |
3891 | |
3892 | return position; |
3893 | } |
3894 | |
3895 | void QTextDocumentLayout::resizeInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat &format) |
3896 | { |
3897 | Q_D(QTextDocumentLayout); |
3898 | QTextCharFormat f = format.toCharFormat(); |
3899 | Q_ASSERT(f.isValid()); |
3900 | QTextObjectHandler handler = d->handlers.value(key: f.objectType()); |
3901 | if (!handler.component) |
3902 | return; |
3903 | |
3904 | QSizeF intrinsic = handler.iface->intrinsicSize(doc: d->document, posInDocument, format); |
3905 | |
3906 | QTextFrameFormat::Position pos = QTextFrameFormat::InFlow; |
3907 | QTextFrame *frame = qobject_cast<QTextFrame *>(object: d->document->objectForFormat(f)); |
3908 | if (frame) { |
3909 | pos = frame->frameFormat().position(); |
3910 | QTextFrameData *fd = data(f: frame); |
3911 | fd->sizeDirty = false; |
3912 | fd->size = QFixedSize::fromSizeF(s: intrinsic); |
3913 | fd->minimumWidth = fd->maximumWidth = fd->size.width; |
3914 | } |
3915 | |
3916 | QSizeF inlineSize = (pos == QTextFrameFormat::InFlow ? intrinsic : QSizeF(0, 0)); |
3917 | item.setWidth(inlineSize.width()); |
3918 | |
3919 | if (f.verticalAlignment() == QTextCharFormat::AlignMiddle) { |
3920 | QFontMetrics m(f.font()); |
3921 | qreal halfX = m.xHeight()/2.; |
3922 | item.setAscent((inlineSize.height() + halfX) / 2.); |
3923 | item.setDescent((inlineSize.height() - halfX) / 2.); |
3924 | } else { |
3925 | item.setDescent(0); |
3926 | item.setAscent(inlineSize.height()); |
3927 | } |
3928 | } |
3929 | |
3930 | void QTextDocumentLayout::positionInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat &format) |
3931 | { |
3932 | Q_D(QTextDocumentLayout); |
3933 | Q_UNUSED(posInDocument); |
3934 | if (item.width() != 0) |
3935 | // inline |
3936 | return; |
3937 | |
3938 | QTextCharFormat f = format.toCharFormat(); |
3939 | Q_ASSERT(f.isValid()); |
3940 | QTextObjectHandler handler = d->handlers.value(key: f.objectType()); |
3941 | if (!handler.component) |
3942 | return; |
3943 | |
3944 | QTextFrame *frame = qobject_cast<QTextFrame *>(object: d->document->objectForFormat(f)); |
3945 | if (!frame) |
3946 | return; |
3947 | |
3948 | QTextBlock b = d->document->findBlock(pos: frame->firstPosition()); |
3949 | QTextLine line; |
3950 | if (b.position() <= frame->firstPosition() && b.position() + b.length() > frame->lastPosition()) |
3951 | line = b.layout()->lineAt(i: b.layout()->lineCount()-1); |
3952 | // qDebug() << "layoutObject: line.isValid" << line.isValid() << b.position() << b.length() << |
3953 | // frame->firstPosition() << frame->lastPosition(); |
3954 | d->positionFloat(frame, currentLine: line.isValid() ? &line : nullptr); |
3955 | } |
3956 | |
3957 | void QTextDocumentLayout::drawInlineObject(QPainter *p, const QRectF &rect, QTextInlineObject item, |
3958 | int posInDocument, const QTextFormat &format) |
3959 | { |
3960 | Q_D(QTextDocumentLayout); |
3961 | QTextCharFormat f = format.toCharFormat(); |
3962 | Q_ASSERT(f.isValid()); |
3963 | QTextFrame *frame = qobject_cast<QTextFrame *>(object: d->document->objectForFormat(f)); |
3964 | if (frame && frame->frameFormat().position() != QTextFrameFormat::InFlow) |
3965 | return; // don't draw floating frames from inline objects here but in drawFlow instead |
3966 | |
3967 | // qDebug() << "drawObject at" << r; |
3968 | QAbstractTextDocumentLayout::drawInlineObject(painter: p, rect, object: item, posInDocument, format); |
3969 | } |
3970 | |
3971 | int QTextDocumentLayout::dynamicPageCount() const |
3972 | { |
3973 | Q_D(const QTextDocumentLayout); |
3974 | const QSizeF pgSize = d->document->pageSize(); |
3975 | if (pgSize.height() < 0) |
3976 | return 1; |
3977 | return qCeil(v: dynamicDocumentSize().height() / pgSize.height()); |
3978 | } |
3979 | |
3980 | QSizeF QTextDocumentLayout::dynamicDocumentSize() const |
3981 | { |
3982 | Q_D(const QTextDocumentLayout); |
3983 | return data(f: d->docPrivate->rootFrame())->size.toSizeF(); |
3984 | } |
3985 | |
3986 | int QTextDocumentLayout::pageCount() const |
3987 | { |
3988 | Q_D(const QTextDocumentLayout); |
3989 | d->ensureLayoutFinished(); |
3990 | return dynamicPageCount(); |
3991 | } |
3992 | |
3993 | QSizeF QTextDocumentLayout::documentSize() const |
3994 | { |
3995 | Q_D(const QTextDocumentLayout); |
3996 | d->ensureLayoutFinished(); |
3997 | return dynamicDocumentSize(); |
3998 | } |
3999 | |
4000 | void QTextDocumentLayoutPrivate::ensureLayouted(QFixed y) const |
4001 | { |
4002 | Q_Q(const QTextDocumentLayout); |
4003 | if (currentLazyLayoutPosition == -1) |
4004 | return; |
4005 | const QSizeF oldSize = q->dynamicDocumentSize(); |
4006 | Q_UNUSED(oldSize); |
4007 | |
4008 | if (checkPoints.isEmpty()) |
4009 | layoutStep(); |
4010 | |
4011 | while (currentLazyLayoutPosition != -1 |
4012 | && checkPoints.last().y < y) |
4013 | layoutStep(); |
4014 | } |
4015 | |
4016 | void QTextDocumentLayoutPrivate::ensureLayoutedByPosition(int position) const |
4017 | { |
4018 | if (currentLazyLayoutPosition == -1) |
4019 | return; |
4020 | if (position < currentLazyLayoutPosition) |
4021 | return; |
4022 | while (currentLazyLayoutPosition != -1 |
4023 | && currentLazyLayoutPosition < position) { |
4024 | const_cast<QTextDocumentLayout *>(q_func())->doLayout(from: currentLazyLayoutPosition, oldLength: 0, INT_MAX - currentLazyLayoutPosition); |
4025 | } |
4026 | } |
4027 | |
4028 | void QTextDocumentLayoutPrivate::layoutStep() const |
4029 | { |
4030 | ensureLayoutedByPosition(position: currentLazyLayoutPosition + lazyLayoutStepSize); |
4031 | lazyLayoutStepSize = qMin(a: 200000, b: lazyLayoutStepSize * 2); |
4032 | } |
4033 | |
4034 | void QTextDocumentLayout::setCursorWidth(int width) |
4035 | { |
4036 | Q_D(QTextDocumentLayout); |
4037 | d->cursorWidth = width; |
4038 | } |
4039 | |
4040 | int QTextDocumentLayout::cursorWidth() const |
4041 | { |
4042 | Q_D(const QTextDocumentLayout); |
4043 | return d->cursorWidth; |
4044 | } |
4045 | |
4046 | void QTextDocumentLayout::setFixedColumnWidth(int width) |
4047 | { |
4048 | Q_D(QTextDocumentLayout); |
4049 | d->fixedColumnWidth = width; |
4050 | } |
4051 | |
4052 | QRectF QTextDocumentLayout::tableCellBoundingRect(QTextTable *table, const QTextTableCell &cell) const |
4053 | { |
4054 | if (!cell.isValid()) |
4055 | return QRectF(); |
4056 | |
4057 | QTextTableData *td = static_cast<QTextTableData *>(data(f: table)); |
4058 | |
4059 | QRectF tableRect = tableBoundingRect(table); |
4060 | QRectF cellRect = td->cellRect(cell); |
4061 | |
4062 | return cellRect.translated(p: tableRect.topLeft()); |
4063 | } |
4064 | |
4065 | QRectF QTextDocumentLayout::tableBoundingRect(QTextTable *table) const |
4066 | { |
4067 | Q_D(const QTextDocumentLayout); |
4068 | if (d->docPrivate->pageSize.isNull()) |
4069 | return QRectF(); |
4070 | d->ensureLayoutFinished(); |
4071 | |
4072 | QPointF pos; |
4073 | const int framePos = table->firstPosition(); |
4074 | QTextFrame *f = table; |
4075 | while (f) { |
4076 | QTextFrameData *fd = data(f); |
4077 | pos += fd->position.toPointF(); |
4078 | |
4079 | if (f != table) { |
4080 | if (QTextTable *table = qobject_cast<QTextTable *>(object: f)) { |
4081 | QTextTableCell cell = table->cellAt(position: framePos); |
4082 | if (cell.isValid()) |
4083 | pos += static_cast<QTextTableData *>(fd)->cellPosition(table, cell).toPointF(); |
4084 | } |
4085 | } |
4086 | |
4087 | f = f->parentFrame(); |
4088 | } |
4089 | return QRectF(pos, data(f: table)->size.toSizeF()); |
4090 | } |
4091 | |
4092 | QRectF QTextDocumentLayout::frameBoundingRect(QTextFrame *frame) const |
4093 | { |
4094 | Q_D(const QTextDocumentLayout); |
4095 | if (d->docPrivate->pageSize.isNull()) |
4096 | return QRectF(); |
4097 | d->ensureLayoutFinished(); |
4098 | return d->frameBoundingRectInternal(frame); |
4099 | } |
4100 | |
4101 | QRectF QTextDocumentLayoutPrivate::frameBoundingRectInternal(QTextFrame *frame) const |
4102 | { |
4103 | QPointF pos; |
4104 | const int framePos = frame->firstPosition(); |
4105 | QTextFrame *f = frame; |
4106 | while (f) { |
4107 | QTextFrameData *fd = data(f); |
4108 | pos += fd->position.toPointF(); |
4109 | |
4110 | if (QTextTable *table = qobject_cast<QTextTable *>(object: f)) { |
4111 | QTextTableCell cell = table->cellAt(position: framePos); |
4112 | if (cell.isValid()) |
4113 | pos += static_cast<QTextTableData *>(fd)->cellPosition(table, cell).toPointF(); |
4114 | } |
4115 | |
4116 | f = f->parentFrame(); |
4117 | } |
4118 | return QRectF(pos, data(f: frame)->size.toSizeF()); |
4119 | } |
4120 | |
4121 | QRectF QTextDocumentLayout::blockBoundingRect(const QTextBlock &block) const |
4122 | { |
4123 | Q_D(const QTextDocumentLayout); |
4124 | if (d->docPrivate->pageSize.isNull() || !block.isValid() || !block.isVisible()) |
4125 | return QRectF(); |
4126 | d->ensureLayoutedByPosition(position: block.position() + block.length()); |
4127 | QTextFrame *frame = d->document->frameAt(pos: block.position()); |
4128 | QPointF offset; |
4129 | const int blockPos = block.position(); |
4130 | |
4131 | while (frame) { |
4132 | QTextFrameData *fd = data(f: frame); |
4133 | offset += fd->position.toPointF(); |
4134 | |
4135 | if (QTextTable *table = qobject_cast<QTextTable *>(object: frame)) { |
4136 | QTextTableCell cell = table->cellAt(position: blockPos); |
4137 | if (cell.isValid()) |
4138 | offset += static_cast<QTextTableData *>(fd)->cellPosition(table, cell).toPointF(); |
4139 | } |
4140 | |
4141 | frame = frame->parentFrame(); |
4142 | } |
4143 | |
4144 | const QTextLayout *layout = block.layout(); |
4145 | QRectF rect = layout->boundingRect(); |
4146 | rect.moveTopLeft(p: layout->position() + offset); |
4147 | return rect; |
4148 | } |
4149 | |
4150 | int QTextDocumentLayout::layoutStatus() const |
4151 | { |
4152 | Q_D(const QTextDocumentLayout); |
4153 | int pos = d->currentLazyLayoutPosition; |
4154 | if (pos == -1) |
4155 | return 100; |
4156 | return pos * 100 / d->document->docHandle()->length(); |
4157 | } |
4158 | |
4159 | void QTextDocumentLayout::timerEvent(QTimerEvent *e) |
4160 | { |
4161 | Q_D(QTextDocumentLayout); |
4162 | if (e->timerId() == d->layoutTimer.timerId()) { |
4163 | if (d->currentLazyLayoutPosition != -1) |
4164 | d->layoutStep(); |
4165 | } else if (e->timerId() == d->sizeChangedTimer.timerId()) { |
4166 | d->lastReportedSize = dynamicDocumentSize(); |
4167 | emit documentSizeChanged(newSize: d->lastReportedSize); |
4168 | d->sizeChangedTimer.stop(); |
4169 | |
4170 | if (d->currentLazyLayoutPosition == -1) { |
4171 | const int newCount = dynamicPageCount(); |
4172 | if (newCount != d->lastPageCount) { |
4173 | d->lastPageCount = newCount; |
4174 | emit pageCountChanged(newPages: newCount); |
4175 | } |
4176 | } |
4177 | } else { |
4178 | QAbstractTextDocumentLayout::timerEvent(event: e); |
4179 | } |
4180 | } |
4181 | |
4182 | void QTextDocumentLayout::layoutFinished() |
4183 | { |
4184 | Q_D(QTextDocumentLayout); |
4185 | d->layoutTimer.stop(); |
4186 | if (!d->insideDocumentChange) |
4187 | d->sizeChangedTimer.start(msec: 0, obj: this); |
4188 | // reset |
4189 | d->showLayoutProgress = true; |
4190 | } |
4191 | |
4192 | void QTextDocumentLayout::ensureLayouted(qreal y) |
4193 | { |
4194 | d_func()->ensureLayouted(y: QFixed::fromReal(r: y)); |
4195 | } |
4196 | |
4197 | qreal QTextDocumentLayout::idealWidth() const |
4198 | { |
4199 | Q_D(const QTextDocumentLayout); |
4200 | d->ensureLayoutFinished(); |
4201 | return d->idealWidth; |
4202 | } |
4203 | |
4204 | bool QTextDocumentLayout::contentHasAlignment() const |
4205 | { |
4206 | Q_D(const QTextDocumentLayout); |
4207 | return d->contentHasAlignment; |
4208 | } |
4209 | |
4210 | qreal QTextDocumentLayoutPrivate::scaleToDevice(qreal value) const |
4211 | { |
4212 | if (!paintDevice) |
4213 | return value; |
4214 | return value * paintDevice->logicalDpiY() / qreal(qt_defaultDpi()); |
4215 | } |
4216 | |
4217 | QFixed QTextDocumentLayoutPrivate::scaleToDevice(QFixed value) const |
4218 | { |
4219 | if (!paintDevice) |
4220 | return value; |
4221 | return value * QFixed(paintDevice->logicalDpiY()) / QFixed(qt_defaultDpi()); |
4222 | } |
4223 | |
4224 | QT_END_NAMESPACE |
4225 | |
4226 | #include "moc_qtextdocumentlayout_p.cpp" |
4227 | |