Merge remote branch 'origin/4.8' into 4.8-from-4.7
[qt:qt.git] / src / gui / text / qtextengine_p.h
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the QtGui module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 **
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 **
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
29 **
30 ** Other Usage
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
33 **
34 **
35 **
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #ifndef QTEXTENGINE_P_H
43 #define QTEXTENGINE_P_H
44
45 //
46 //  W A R N I N G
47 //  -------------
48 //
49 // This file is not part of the Qt API.  It exists for the convenience
50 // of other Qt classes.  This header file may change from version to
51 // version without notice, or even be removed.
52 //
53 // We mean it.
54 //
55
56 #include "QtCore/qglobal.h"
57 #include "QtCore/qstring.h"
58 #include "QtCore/qvarlengtharray.h"
59 #include "QtCore/qnamespace.h"
60 #include "QtGui/qtextlayout.h"
61 #include "private/qtextformat_p.h"
62 #include "private/qfont_p.h"
63 #include "QtCore/qvector.h"
64 #include "QtGui/qpaintengine.h"
65 #include "QtGui/qtextobject.h"
66 #include "QtGui/qtextoption.h"
67 #include "QtGui/qtextcursor.h"
68 #include "QtCore/qset.h"
69 #include "QtCore/qdebug.h"
70 #ifndef QT_BUILD_COMPAT_LIB
71 #include "private/qtextdocument_p.h"
72 #endif
73 #include "private/qharfbuzz_p.h"
74 #include "private/qfixed_p.h"
75
76 #include <stdlib.h>
77
78 QT_BEGIN_NAMESPACE
79
80 class QFontPrivate;
81 class QFontEngine;
82
83 class QString;
84 class QPainter;
85
86 class QAbstractTextDocumentLayout;
87
88
89 // this uses the same coordinate system as Qt, but a different one to freetype.
90 // * y is usually negative, and is equal to the ascent.
91 // * negative yoff means the following stuff is drawn higher up.
92 // the characters bounding rect is given by QRect(x,y,width,height), its advance by
93 // xoo and yoff
94 struct glyph_metrics_t
95 {
96     inline glyph_metrics_t()
97         : x(100000),  y(100000) {}
98     inline glyph_metrics_t(QFixed _x, QFixed _y, QFixed _width, QFixed _height, QFixed _xoff, QFixed _yoff)
99         : x(_x),
100           y(_y),
101           width(_width),
102           height(_height),
103           xoff(_xoff),
104           yoff(_yoff)
105         {}
106     QFixed x;
107     QFixed y;
108     QFixed width;
109     QFixed height;
110     QFixed xoff;
111     QFixed yoff;
112
113     glyph_metrics_t transformed(const QTransform &xform) const;
114     inline bool isValid() const {return x != 100000 && y != 100000;}
115 };
116 Q_DECLARE_TYPEINFO(glyph_metrics_t, Q_PRIMITIVE_TYPE);
117
118 struct Q_AUTOTEST_EXPORT QScriptAnalysis
119 {
120     enum Flags {
121         None = 0,
122         Lowercase = 1,
123         Uppercase = 2,
124         SmallCaps = 3,
125         LineOrParagraphSeparator = 4,
126         Space = 5,
127         SpaceTabOrObject = Space,
128         Tab = 6,
129         TabOrObject = Tab,
130         Object = 7
131     };
132     unsigned short script    : 7;
133     unsigned short bidiLevel : 6;  // Unicode Bidi algorithm embedding level (0-61)
134     unsigned short flags     : 3;
135     inline bool operator == (const QScriptAnalysis &other) const {
136         return script == other.script && bidiLevel == other.bidiLevel && flags == other.flags;
137     }
138 };
139 Q_DECLARE_TYPEINFO(QScriptAnalysis, Q_PRIMITIVE_TYPE);
140
141 struct QGlyphJustification
142 {
143     inline QGlyphJustification()
144         : type(0), nKashidas(0), space_18d6(0)
145     {}
146
147     enum JustificationType {
148         JustifyNone,
149         JustifySpace,
150         JustifyKashida
151     };
152
153     uint type :2;
154     uint nKashidas : 6; // more do not make sense...
155     uint space_18d6 : 24;
156 };
157 Q_DECLARE_TYPEINFO(QGlyphJustification, Q_PRIMITIVE_TYPE);
158
159 struct QGlyphLayoutInstance
160 {
161     QFixedPoint offset;
162     QFixedPoint advance;
163     HB_Glyph glyph;
164     QGlyphJustification justification;
165     HB_GlyphAttributes attributes;
166 };
167
168 struct QGlyphLayout
169 {
170     // init to 0 not needed, done when shaping
171     QFixedPoint *offsets; // 8 bytes per element
172     HB_Glyph *glyphs; // 4 bytes per element
173     QFixed *advances_x; // 4 bytes per element
174     QFixed *advances_y; // 4 bytes per element
175     QGlyphJustification *justifications; // 4 bytes per element
176     HB_GlyphAttributes *attributes; // 2 bytes per element
177
178     int numGlyphs;
179
180     inline QGlyphLayout() : numGlyphs(0) {}
181
182     inline explicit QGlyphLayout(char *address, int totalGlyphs)
183     {
184         offsets = reinterpret_cast<QFixedPoint *>(address);
185         int offset = totalGlyphs * sizeof(HB_FixedPoint);
186         glyphs = reinterpret_cast<HB_Glyph *>(address + offset);
187         offset += totalGlyphs * sizeof(HB_Glyph);
188         advances_x = reinterpret_cast<QFixed *>(address + offset);
189         offset += totalGlyphs * sizeof(QFixed);
190         advances_y = reinterpret_cast<QFixed *>(address + offset);
191         offset += totalGlyphs * sizeof(QFixed);
192         justifications = reinterpret_cast<QGlyphJustification *>(address + offset);
193         offset += totalGlyphs * sizeof(QGlyphJustification);
194         attributes = reinterpret_cast<HB_GlyphAttributes *>(address + offset);
195         numGlyphs = totalGlyphs;
196     }
197
198     inline QGlyphLayout mid(int position, int n = -1) const {
199         QGlyphLayout copy = *this;
200         copy.glyphs += position;
201         copy.advances_x += position;
202         copy.advances_y += position;
203         copy.offsets += position;
204         copy.justifications += position;
205         copy.attributes += position;
206         if (n == -1)
207             copy.numGlyphs -= position;
208         else
209             copy.numGlyphs = n;
210         return copy;
211     }
212
213     static inline int spaceNeededForGlyphLayout(int totalGlyphs) {
214         return totalGlyphs * (sizeof(HB_Glyph) + sizeof(HB_GlyphAttributes)
215                 + sizeof(QFixed) + sizeof(QFixed) + sizeof(QFixedPoint)
216                 + sizeof(QGlyphJustification));
217     }
218
219     inline QFixed effectiveAdvance(int item) const
220     { return (advances_x[item] + QFixed::fromFixed(justifications[item].space_18d6)) * !attributes[item].dontPrint; }
221
222     inline QGlyphLayoutInstance instance(int position) const {
223         QGlyphLayoutInstance g;
224         g.offset.x = offsets[position].x;
225         g.offset.y = offsets[position].y;
226         g.glyph = glyphs[position];
227         g.advance.x = advances_x[position];
228         g.advance.y = advances_y[position];
229         g.justification = justifications[position];
230         g.attributes = attributes[position];
231         return g;
232     }
233
234     inline void setInstance(int position, const QGlyphLayoutInstance &g) {
235         offsets[position].x = g.offset.x;
236         offsets[position].y = g.offset.y;
237         glyphs[position] = g.glyph;
238         advances_x[position] = g.advance.x;
239         advances_y[position] = g.advance.y;
240         justifications[position] = g.justification;
241         attributes[position] = g.attributes;
242     }
243
244     inline void clear(int first = 0, int last = -1) {
245         if (last == -1)
246             last = numGlyphs;
247         if (first == 0 && last == numGlyphs
248             && reinterpret_cast<char *>(offsets + numGlyphs) == reinterpret_cast<char *>(glyphs)) {
249             memset(offsets, 0, spaceNeededForGlyphLayout(numGlyphs));
250         } else {
251             const int num = last - first;
252             memset(offsets + first, 0, num * sizeof(QFixedPoint));
253             memset(glyphs + first, 0, num * sizeof(HB_Glyph));
254             memset(advances_x + first, 0, num * sizeof(QFixed));
255             memset(advances_y + first, 0, num * sizeof(QFixed));
256             memset(justifications + first, 0, num * sizeof(QGlyphJustification));
257             memset(attributes + first, 0, num * sizeof(HB_GlyphAttributes));
258         }
259     }
260
261     inline char *data() {
262         return reinterpret_cast<char *>(offsets);
263     }
264
265     void grow(char *address, int totalGlyphs);
266 };
267
268 class QVarLengthGlyphLayoutArray : private QVarLengthArray<void *>, public QGlyphLayout
269 {
270 private:
271     typedef QVarLengthArray<void *> Array;
272 public:
273     QVarLengthGlyphLayoutArray(int totalGlyphs)
274         : Array(spaceNeededForGlyphLayout(totalGlyphs) / sizeof(void *) + 1)
275         , QGlyphLayout(reinterpret_cast<char *>(Array::data()), totalGlyphs)
276     {
277         memset(Array::data(), 0, Array::size() * sizeof(void *));
278     }
279
280     void resize(int totalGlyphs)
281     {
282         Array::resize(spaceNeededForGlyphLayout(totalGlyphs) / sizeof(void *) + 1);
283
284         *((QGlyphLayout *)this) = QGlyphLayout(reinterpret_cast<char *>(Array::data()), totalGlyphs);
285         memset(Array::data(), 0, Array::size() * sizeof(void *));
286     }
287 };
288
289 template <int N> struct QGlyphLayoutArray : public QGlyphLayout
290 {
291 public:
292     QGlyphLayoutArray()
293         : QGlyphLayout(reinterpret_cast<char *>(buffer), N)
294     {
295         memset(buffer, 0, sizeof(buffer));
296     }
297
298 private:
299     void *buffer[(N * (sizeof(HB_Glyph) + sizeof(HB_GlyphAttributes)
300                 + sizeof(QFixed) + sizeof(QFixed) + sizeof(QFixedPoint)
301                 + sizeof(QGlyphJustification)))
302                     / sizeof(void *) + 1];
303 };
304
305 struct QScriptItem;
306 /// Internal QTextItem
307 class QTextItemInt : public QTextItem
308 {
309 public:
310     inline QTextItemInt()
311         : justified(false), underlineStyle(QTextCharFormat::NoUnderline), num_chars(0), chars(0),
312           logClusters(0), f(0), fontEngine(0)
313     {}
314     QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFormat &format = QTextCharFormat());
315     QTextItemInt(const QGlyphLayout &g, QFont *font, const QChar *chars, int numChars, QFontEngine *fe,
316                  const QTextCharFormat &format = QTextCharFormat());
317
318     /// copy the structure items, adjusting the glyphs arrays to the right subarrays.
319     /// the width of the returned QTextItemInt is not adjusted, for speed reasons
320     QTextItemInt midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const;
321     void initWithScriptItem(const QScriptItem &si);
322
323     QFixed descent;
324     QFixed ascent;
325     QFixed width;
326
327     RenderFlags flags;
328     bool justified;
329     QTextCharFormat::UnderlineStyle underlineStyle;
330     const QTextCharFormat charFormat;
331     int num_chars;
332     const QChar *chars;
333     const unsigned short *logClusters;
334     const QFont *f;
335
336     QGlyphLayout glyphs;
337     QFontEngine *fontEngine;
338 };
339
340 inline bool qIsControlChar(ushort uc)
341 {
342     return uc >= 0x200b && uc <= 0x206f
343         && (uc <= 0x200f /* ZW Space, ZWNJ, ZWJ, LRM and RLM */
344             || (uc >= 0x2028 && uc <= 0x202f /* LS, PS, LRE, RLE, PDF, LRO, RLO, NNBSP */)
345             || uc >= 0x206a /* ISS, ASS, IAFS, AFS, NADS, NODS */);
346 }
347
348 struct Q_AUTOTEST_EXPORT QScriptItem
349 {
350     inline QScriptItem()
351         : position(0),
352           num_glyphs(0), descent(-1), ascent(-1), leading(-1), width(-1),
353           glyph_data_offset(0) {}
354     inline QScriptItem(int p, const QScriptAnalysis &a)
355         : position(p), analysis(a),
356           num_glyphs(0), descent(-1), ascent(-1), leading(-1), width(-1),
357           glyph_data_offset(0) {}
358
359     int position;
360     QScriptAnalysis analysis;
361     unsigned short num_glyphs;
362     QFixed descent;
363     QFixed ascent;
364     QFixed leading;
365     QFixed width;
366     int glyph_data_offset;
367     QFixed height() const { return ascent + descent + 1; }
368 };
369
370
371 Q_DECLARE_TYPEINFO(QScriptItem, Q_MOVABLE_TYPE);
372
373 typedef QVector<QScriptItem> QScriptItemArray;
374
375 struct Q_AUTOTEST_EXPORT QScriptLine
376 {
377     // created and filled in QTextLine::layout_helper
378     QScriptLine()
379         : from(0), trailingSpaces(0), length(0),
380         justified(0), gridfitted(0),
381         hasTrailingSpaces(0), leadingIncluded(0) {}
382     QFixed descent;
383     QFixed ascent;
384     QFixed leading;
385     QFixed x;
386     QFixed y;
387     QFixed width;
388     QFixed textWidth;
389     QFixed textAdvance;
390     int from;
391     unsigned short trailingSpaces;
392     signed int length : 28;
393     mutable uint justified : 1;
394     mutable uint gridfitted : 1;
395     uint hasTrailingSpaces : 1;
396     uint leadingIncluded : 1;
397     QFixed height() const { return (ascent + descent).ceil() + 1
398                             + (leadingIncluded?  qMax(QFixed(),leading) : QFixed()); }
399     QFixed base() const { return ascent
400                           + (leadingIncluded ? qMax(QFixed(),leading) : QFixed()); }
401     void setDefaultHeight(QTextEngine *eng);
402     void operator+=(const QScriptLine &other);
403 };
404 Q_DECLARE_TYPEINFO(QScriptLine, Q_PRIMITIVE_TYPE);
405
406
407 inline void QScriptLine::operator+=(const QScriptLine &other)
408 {
409     leading= qMax(leading + ascent, other.leading + other.ascent) - qMax(ascent, other.ascent);
410     descent = qMax(descent, other.descent);
411     ascent = qMax(ascent, other.ascent);
412     textWidth += other.textWidth;
413     length += other.length;
414 }
415
416 typedef QVector<QScriptLine> QScriptLineArray;
417
418 class QFontPrivate;
419 class QTextFormatCollection;
420
421 class Q_GUI_EXPORT QTextEngine {
422 public:
423     enum LayoutState {
424         LayoutEmpty,
425         InLayout,
426         LayoutFailed,
427     };
428     struct LayoutData {
429         LayoutData(const QString &str, void **stack_memory, int mem_size);
430         LayoutData();
431         ~LayoutData();
432         mutable QScriptItemArray items;
433         int allocated;
434         int available_glyphs;
435         void **memory;
436         unsigned short *logClustersPtr;
437         QGlyphLayout glyphLayout;
438         mutable int used;
439         uint hasBidi : 1;
440         uint layoutState : 2;
441         uint memory_on_stack : 1;
442         uint haveCharAttributes : 1;
443         QString string;
444         bool reallocate(int totalGlyphs);
445     };
446
447     QTextEngine(LayoutData *data);
448     QTextEngine();
449     QTextEngine(const QString &str, const QFont &f);
450     ~QTextEngine();
451
452     enum Mode {
453         WidthOnly = 0x07
454     };
455
456     // keep in sync with QAbstractFontEngine::TextShapingFlag!!
457     enum ShaperFlag {
458         RightToLeft = 0x0001,
459         DesignMetrics = 0x0002,
460         GlyphIndicesOnly = 0x0004
461     };
462     Q_DECLARE_FLAGS(ShaperFlags, ShaperFlag)
463
464     void invalidate();
465     void clearLineData();
466
467     void validate() const;
468     void itemize() const;
469
470     bool isRightToLeft() const;
471     static void bidiReorder(int numRuns, const quint8 *levels, int *visualOrder);
472
473     const HB_CharAttributes *attributes() const;
474
475     void shape(int item) const;
476
477     void justify(const QScriptLine &si);
478     QFixed alignLine(const QScriptLine &line);
479
480     QFixed width(int charFrom, int numChars) const;
481     glyph_metrics_t boundingBox(int from,  int len) const;
482     glyph_metrics_t tightBoundingBox(int from,  int len) const;
483
484     int length(int item) const {
485         const QScriptItem &si = layoutData->items[item];
486         int from = si.position;
487         item++;
488         return (item < layoutData->items.size() ? layoutData->items[item].position : layoutData->string.length()) - from;
489     }
490     int length(const QScriptItem *si) const {
491         int end;
492         if (si + 1 < layoutData->items.constData()+ layoutData->items.size())
493             end = (si+1)->position;
494         else
495             end = layoutData->string.length();
496         return end - si->position;
497     }
498
499     QFontEngine *fontEngine(const QScriptItem &si, QFixed *ascent = 0, QFixed *descent = 0, QFixed *leading = 0) const;
500     QFont font(const QScriptItem &si) const;
501     inline QFont font() const { return fnt; }
502
503     /**
504      * Returns a pointer to an array of log clusters, offset at the script item.
505      * Each item in the array is a unsigned short.  For each character in the original string there is an entry in the table
506      * so there is a one to one correlation in indexes between the original text and the index in the logcluster.
507      * The value of each item is the position in the glyphs array. Multiple similar pointers in the logclusters array imply
508      * that one glyph is used for more than one character.
509      * \sa glyphs()
510      */
511     inline unsigned short *logClusters(const QScriptItem *si) const
512         { return layoutData->logClustersPtr+si->position; }
513     /**
514      * Returns an array of QGlyphLayout items, offset at the script item.
515      * Each item in the array matches one glyph in the text, storing the advance, position etc.
516      * The returned item's length equals to the number of available glyphs. This may be more
517      * than what was actually shaped.
518      * \sa logClusters()
519      */
520     inline QGlyphLayout availableGlyphs(const QScriptItem *si) const {
521         return layoutData->glyphLayout.mid(si->glyph_data_offset);
522     }
523     /**
524      * Returns an array of QGlyphLayout items, offset at the script item.
525      * Each item in the array matches one glyph in the text, storing the advance, position etc.
526      * The returned item's length equals to the number of shaped glyphs.
527      * \sa logClusters()
528      */
529     inline QGlyphLayout shapedGlyphs(const QScriptItem *si) const {
530         return layoutData->glyphLayout.mid(si->glyph_data_offset, si->num_glyphs);
531     }
532
533     inline bool ensureSpace(int nGlyphs) const {
534         if (layoutData->glyphLayout.numGlyphs - layoutData->used < nGlyphs)
535             return layoutData->reallocate((((layoutData->used + nGlyphs)*3/2 + 15) >> 4) << 4);
536         return true;
537     }
538
539     void freeMemory();
540
541     int findItem(int strPos) const;
542     inline QTextFormatCollection *formats() const {
543 #ifdef QT_BUILD_COMPAT_LIB
544         return 0; // Compat should never reference this symbol
545 #else
546         return block.docHandle()->formatCollection();
547 #endif
548     }
549     QTextCharFormat format(const QScriptItem *si) const;
550     inline QAbstractTextDocumentLayout *docLayout() const {
551 #ifdef QT_BUILD_COMPAT_LIB
552         return 0; // Compat should never reference this symbol
553 #else
554         return block.docHandle()->document()->documentLayout();
555 #endif
556     }
557     int formatIndex(const QScriptItem *si) const;
558
559     /// returns the width of tab at index (in the tabs array) with the tab-start at position x
560     QFixed calculateTabWidth(int index, QFixed x) const;
561
562     mutable QScriptLineArray lines;
563
564     struct FontEngineCache {
565         FontEngineCache();
566         mutable QFontEngine *prevFontEngine;
567         mutable QFontEngine *prevScaledFontEngine;
568         mutable int prevScript;
569         mutable int prevPosition;
570         mutable int prevLength;
571         inline void reset() {
572             prevFontEngine = 0;
573             prevScaledFontEngine = 0;
574             prevScript = -1;
575             prevPosition = -1;
576             prevLength = -1;
577         }
578     };
579     mutable FontEngineCache feCache;
580
581     QString text;
582     QFont fnt;
583     QTextBlock block;
584
585     QTextOption option;
586
587     QFixed minWidth;
588     QFixed maxWidth;
589     QPointF position;
590     uint ignoreBidi : 1;
591     uint cacheGlyphs : 1;
592     uint stackEngine : 1;
593     uint forceJustification : 1;
594     uint visualMovement : 1;
595
596     int *underlinePositions;
597
598     mutable LayoutData *layoutData;
599
600     inline bool hasFormats() const { return (block.docHandle() || specialData); }
601     inline bool visualCursorMovement() const
602     {
603         return (visualMovement ||
604                 (block.docHandle() ? block.docHandle()->defaultCursorMoveStyle == Qt::VisualMoveStyle : false));
605     }
606
607     struct SpecialData {
608         int preeditPosition;
609         QString preeditText;
610         QList<QTextLayout::FormatRange> addFormats;
611         QVector<int> addFormatIndices;
612         QVector<int> resolvedFormatIndices;
613     };
614     SpecialData *specialData;
615
616     bool atWordSeparator(int position) const;
617     bool atSpace(int position) const;
618     void indexAdditionalFormats();
619
620     QString elidedText(Qt::TextElideMode mode, const QFixed &width, int flags = 0) const;
621
622     void shapeLine(const QScriptLine &line);
623     QFixed leadingSpaceWidth(const QScriptLine &line);
624
625     QFixed offsetInLigature(const QScriptItem *si, int pos, int max, int glyph_pos);
626     int positionInLigature(const QScriptItem *si, int end, QFixed x, QFixed edge, int glyph_pos, bool cursorOnCharacter);
627     int previousLogicalPosition(int oldPos) const;
628     int nextLogicalPosition(int oldPos) const;
629     int lineNumberForTextPosition(int pos);
630     int positionAfterVisualMovement(int oldPos, QTextCursor::MoveOperation op);
631     void insertionPointsForLine(int lineNum, QVector<int> &insertionPoints);
632
633     void resetFontEngineCache();
634
635 private:
636     void setBoundary(int strPos) const;
637     void addRequiredBoundaries() const;
638     void shapeText(int item) const;
639     void shapeTextWithHarfbuzz(int item) const;
640 #if defined(Q_WS_WINCE)
641     void shapeTextWithCE(int item) const;
642 #endif
643 #if defined(Q_WS_MAC)
644     void shapeTextMac(int item) const;
645 #endif
646     void splitItem(int item, int pos) const;
647
648     void resolveAdditionalFormats() const;
649     int endOfLine(int lineNum);
650     int beginningOfLine(int lineNum);
651     int getClusterLength(unsigned short *logClusters, const HB_CharAttributes *attributes, int from, int to, int glyph_pos, int *start);
652 };
653
654 class QStackTextEngine : public QTextEngine {
655 public:
656     enum { MemSize = 256*40/sizeof(void *) };
657     QStackTextEngine(const QString &string, const QFont &f);
658     LayoutData _layoutData;
659     void *_memory[MemSize];
660 };
661
662 struct QTextLineItemIterator
663 {
664     QTextLineItemIterator(QTextEngine *eng, int lineNum, const QPointF &pos = QPointF(),
665                           const QTextLayout::FormatRange *_selection = 0);
666
667     inline bool atEnd() const { return logicalItem >= nItems - 1; }
668     inline bool atBeginning() const { return logicalItem <= 0; }
669     QScriptItem &next();
670
671     bool getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const;
672     inline bool isOutsideSelection() const {
673         QFixed tmp1, tmp2;
674         return !getSelectionBounds(&tmp1, &tmp2);
675     }
676
677     QTextEngine *eng;
678
679     QFixed x;
680     QFixed pos_x;
681     const QScriptLine &line;
682     QScriptItem *si;
683
684     int lineNum;
685     int lineEnd;
686     int firstItem;
687     int lastItem;
688     int nItems;
689     int logicalItem;
690     int item;
691     int itemLength;
692
693     int glyphsStart;
694     int glyphsEnd;
695     int itemStart;
696     int itemEnd;
697
698     QFixed itemWidth;
699
700     QVarLengthArray<int> visualOrder;
701     QVarLengthArray<uchar> levels;
702
703     const QTextLayout::FormatRange *selection;
704 };
705
706 Q_DECLARE_OPERATORS_FOR_FLAGS(QTextEngine::ShaperFlags)
707
708 QT_END_NAMESPACE
709
710 #endif // QTEXTENGINE_P_H