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
  74 #include "private/qharfbuzz_copy_p.h"
  75
  76 #include "private/qfixed_p.h"
  77
  78 #include <stdlib.h>
  79
  80 QT_BEGIN_NAMESPACE
  81
  82 class QFontPrivate;
  83 class QFontEngine;
  84
  85 class QString;
  86 class QPainter;
  87
  88 class QAbstractTextDocumentLayout;
  89
  90
  91 // this uses the same coordinate system as Qt, but a different one to freetype.
  92 // * y is usually negative, and is equal to the ascent.
  93 // * negative yoff means the following stuff is drawn higher up.
  94 // the characters bounding rect is given by QRect(x,y,width,height), its advance by
  95 // xoo and yoff
  96 struct glyph_metrics_t
  97 {
  98     inline glyph_metrics_t()
  99         : x(100000),  y(100000) {}
 100     inline glyph_metrics_t(QFixed _x, QFixed _y, QFixed _width, QFixed _height, QFixed _xoff, QFixed _yoff)
 101         : x(_x),
 102           y(_y),
 103           width(_width),
 104           height(_height),
 105           xoff(_xoff),
 106           yoff(_yoff)
 107         {}
 108     QFixed x;
 109     QFixed y;
 110     QFixed width;
 111     QFixed height;
 112     QFixed xoff;
 113     QFixed yoff;
 114
 115     glyph_metrics_t transformed(const QTransform &xform) const;
 116     inline bool isValid() const {return x != 100000 && y != 100000;}
 117 };
 118 Q_DECLARE_TYPEINFO(glyph_metrics_t, Q_PRIMITIVE_TYPE);
 119
 120 struct Q_AUTOTEST_EXPORT QScriptAnalysis
 121 {
 122     enum Flags {
 123         None = 0,
 124         Lowercase = 1,
 125         Uppercase = 2,
 126         SmallCaps = 3,
 127         LineOrParagraphSeparator = 4,
 128         Space = 5,
 129         SpaceTabOrObject = Space,
 130         Tab = 6,
 131         TabOrObject = Tab,
 132         Object = 7
 133     };
 134     unsigned short script    : 7;
 135     unsigned short bidiLevel : 6;  // Unicode Bidi algorithm embedding level (0-61)
 136     unsigned short flags     : 3;
 137     inline bool operator == (const QScriptAnalysis &other) const {
 138         return script == other.script && bidiLevel == other.bidiLevel && flags == other.flags;
 139     }
 140 };
 141 Q_DECLARE_TYPEINFO(QScriptAnalysis, Q_PRIMITIVE_TYPE);
 142
 143 struct QGlyphJustification
 144 {
 145     inline QGlyphJustification()
 146         : type(0), nKashidas(0), space_18d6(0)
 147     {}
 148
 149     enum JustificationType {
 150         JustifyNone,
 151         JustifySpace,
 152         JustifyKashida
 153     };
 154
 155     uint type :2;
 156     uint nKashidas : 6; // more do not make sense...
 157     uint space_18d6 : 24;
 158 };
 159 Q_DECLARE_TYPEINFO(QGlyphJustification, Q_PRIMITIVE_TYPE);
 160
 161 struct QGlyphLayoutInstance
 162 {
 163     QFixedPoint offset;
 164     QFixedPoint advance;
 165     HB_Glyph glyph;
 166     QGlyphJustification justification;
 167     HB_GlyphAttributes attributes;
 168 };
 169
 170 struct QGlyphLayout
 171 {
 172     // init to 0 not needed, done when shaping
 173     QFixedPoint *offsets; // 8 bytes per element
 174     HB_Glyph *glyphs; // 4 bytes per element
 175     QFixed *advances_x; // 4 bytes per element
 176     QFixed *advances_y; // 4 bytes per element
 177     QGlyphJustification *justifications; // 4 bytes per element
 178     HB_GlyphAttributes *attributes; // 2 bytes per element
 179
 180     int numGlyphs;
 181
 182     inline QGlyphLayout() : numGlyphs(0) {}
 183
 184     inline explicit QGlyphLayout(char *address, int totalGlyphs)
 185     {
 186         offsets = reinterpret_cast<QFixedPoint *>(address);
 187         int offset = totalGlyphs * sizeof(HB_FixedPoint);
 188         glyphs = reinterpret_cast<HB_Glyph *>(address + offset);
 189         offset += totalGlyphs * sizeof(HB_Glyph);
 190         advances_x = reinterpret_cast<QFixed *>(address + offset);
 191         offset += totalGlyphs * sizeof(QFixed);
 192         advances_y = reinterpret_cast<QFixed *>(address + offset);
 193         offset += totalGlyphs * sizeof(QFixed);
 194         justifications = reinterpret_cast<QGlyphJustification *>(address + offset);
 195         offset += totalGlyphs * sizeof(QGlyphJustification);
 196         attributes = reinterpret_cast<HB_GlyphAttributes *>(address + offset);
 197         numGlyphs = totalGlyphs;
 198     }
 199
 200     inline QGlyphLayout mid(int position, int n = -1) const {
 201         QGlyphLayout copy = *this;
 202         copy.glyphs += position;
 203         copy.advances_x += position;
 204         copy.advances_y += position;
 205         copy.offsets += position;
 206         copy.justifications += position;
 207         copy.attributes += position;
 208         if (n == -1)
 209             copy.numGlyphs -= position;
 210         else
 211             copy.numGlyphs = n;
 212         return copy;
 213     }
 214
 215     static inline int spaceNeededForGlyphLayout(int totalGlyphs) {
 216         return totalGlyphs * (sizeof(HB_Glyph) + sizeof(HB_GlyphAttributes)
 217                 + sizeof(QFixed) + sizeof(QFixed) + sizeof(QFixedPoint)
 218                 + sizeof(QGlyphJustification));
 219     }
 220
 221     inline QFixed effectiveAdvance(int item) const
 222     { return (advances_x[item] + QFixed::fromFixed(justifications[item].space_18d6)) * !attributes[item].dontPrint; }
 223
 224     inline QGlyphLayoutInstance instance(int position) const {
 225         QGlyphLayoutInstance g;
 226         g.offset.x = offsets[position].x;
 227         g.offset.y = offsets[position].y;
 228         g.glyph = glyphs[position];
 229         g.advance.x = advances_x[position];
 230         g.advance.y = advances_y[position];
 231         g.justification = justifications[position];
 232         g.attributes = attributes[position];
 233         return g;
 234     }
 235
 236     inline void setInstance(int position, const QGlyphLayoutInstance &g) {
 237         offsets[position].x = g.offset.x;
 238         offsets[position].y = g.offset.y;
 239         glyphs[position] = g.glyph;
 240         advances_x[position] = g.advance.x;
 241         advances_y[position] = g.advance.y;
 242         justifications[position] = g.justification;
 243         attributes[position] = g.attributes;
 244     }
 245
 246     inline void clear(int first = 0, int last = -1) {
 247         if (last == -1)
 248             last = numGlyphs;
 249         if (first == 0 && last == numGlyphs
 250             && reinterpret_cast<char *>(offsets + numGlyphs) == reinterpret_cast<char *>(glyphs)) {
 251             memset(offsets, 0, spaceNeededForGlyphLayout(numGlyphs));
 252         } else {
 253             const int num = last - first;
 254             memset(offsets + first, 0, num * sizeof(QFixedPoint));
 255             memset(glyphs + first, 0, num * sizeof(HB_Glyph));
 256             memset(advances_x + first, 0, num * sizeof(QFixed));
 257             memset(advances_y + first, 0, num * sizeof(QFixed));
 258             memset(justifications + first, 0, num * sizeof(QGlyphJustification));
 259             memset(attributes + first, 0, num * sizeof(HB_GlyphAttributes));
 260         }
 261     }
 262
 263     inline char *data() {
 264         return reinterpret_cast<char *>(offsets);
 265     }
 266
 267     void grow(char *address, int totalGlyphs);
 268 };
 269
 270 class QVarLengthGlyphLayoutArray : private QVarLengthArray<void *>, public QGlyphLayout
 271 {
 272 private:
 273     typedef QVarLengthArray<void *> Array;
 274 public:
 275     QVarLengthGlyphLayoutArray(int totalGlyphs)
 276         : Array(spaceNeededForGlyphLayout(totalGlyphs) / sizeof(void *) + 1)
 277         , QGlyphLayout(reinterpret_cast<char *>(Array::data()), totalGlyphs)
 278     {
 279         memset(Array::data(), 0, Array::size() * sizeof(void *));
 280     }
 281
 282     void resize(int totalGlyphs)
 283     {
 284         Array::resize(spaceNeededForGlyphLayout(totalGlyphs) / sizeof(void *) + 1);
 285
 286         *((QGlyphLayout *)this) = QGlyphLayout(reinterpret_cast<char *>(Array::data()), totalGlyphs);
 287         memset(Array::data(), 0, Array::size() * sizeof(void *));
 288     }
 289 };
 290
 291 template <int N> struct QGlyphLayoutArray : public QGlyphLayout
 292 {
 293 public:
 294     QGlyphLayoutArray()
 295         : QGlyphLayout(reinterpret_cast<char *>(buffer), N)
 296     {
 297         memset(buffer, 0, sizeof(buffer));
 298     }
 299
 300 private:
 301     void *buffer[(N * (sizeof(HB_Glyph) + sizeof(HB_GlyphAttributes)
 302                 + sizeof(QFixed) + sizeof(QFixed) + sizeof(QFixedPoint)
 303                 + sizeof(QGlyphJustification)))
 304                     / sizeof(void *) + 1];
 305 };
 306
 307 struct QScriptItem;
 308 /// Internal QTextItem
 309 class QTextItemInt : public QTextItem
 310 {
 311 public:
 312     inline QTextItemInt()
 313         : justified(false), underlineStyle(QTextCharFormat::NoUnderline), num_chars(0), chars(0),
 314           logClusters(0), f(0), fontEngine(0)
 315     {}
 316     QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFormat &format = QTextCharFormat());
 317     QTextItemInt(const QGlyphLayout &g, QFont *font, const QChar *chars, int numChars, QFontEngine *fe);
 318
 319     /// copy the structure items, adjusting the glyphs arrays to the right subarrays.
 320     /// the width of the returned QTextItemInt is not adjusted, for speed reasons
 321     QTextItemInt midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const;
 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), 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     signed int length : 28;
 392     mutable uint justified : 1;
 393     mutable uint gridfitted : 1;
 394     uint hasTrailingSpaces : 1;
 395     uint leadingIncluded : 1;
 396     QFixed height() const { return (ascent + descent).ceil() + 1
 397                             + (leadingIncluded?  qMax(QFixed(),leading) : QFixed()); }
 398     QFixed base() const { return ascent
 399                           + (leadingIncluded ? qMax(QFixed(),leading) : QFixed()); }
 400     void setDefaultHeight(QTextEngine *eng);
 401     void operator+=(const QScriptLine &other);
 402 };
 403 Q_DECLARE_TYPEINFO(QScriptLine, Q_PRIMITIVE_TYPE);
 404
 405
 406 inline void QScriptLine::operator+=(const QScriptLine &other)
 407 {
 408     leading= qMax(leading + ascent, other.leading + other.ascent) - qMax(ascent, other.ascent);
 409     descent = qMax(descent, other.descent);
 410     ascent = qMax(ascent, other.ascent);
 411     textWidth += other.textWidth;
 412     length += other.length;
 413 }
 414
 415 typedef QVector<QScriptLine> QScriptLineArray;
 416
 417 class QFontPrivate;
 418 class QTextFormatCollection;
 419
 420 class Q_GUI_EXPORT QTextEngine {
 421 public:
 422     enum LayoutState {
 423         LayoutEmpty,
 424         InLayout,
 425         LayoutFailed,
 426     };
 427     struct LayoutData {
 428         LayoutData(const QString &str, void **stack_memory, int mem_size);
 429         LayoutData();
 430         ~LayoutData();
 431         mutable QScriptItemArray items;
 432         int allocated;
 433         int available_glyphs;
 434         void **memory;
 435         unsigned short *logClustersPtr;
 436         QGlyphLayout glyphLayout;
 437         mutable int used;
 438         uint hasBidi : 1;
 439         uint layoutState : 2;
 440         uint memory_on_stack : 1;
 441         uint haveCharAttributes : 1;
 442         QString string;
 443         bool reallocate(int totalGlyphs);
 444     };
 445
 446     QTextEngine(LayoutData *data);
 447     QTextEngine();
 448     QTextEngine(const QString &str, const QFont &f);
 449     ~QTextEngine();
 450
 451     enum Mode {
 452         WidthOnly = 0x07
 453     };
 454
 455     // keep in sync with QAbstractFontEngine::TextShapingFlag!!
 456     enum ShaperFlag {
 457         RightToLeft = 0x0001,
 458         DesignMetrics = 0x0002,
 459         GlyphIndicesOnly = 0x0004
 460     };
 461     Q_DECLARE_FLAGS(ShaperFlags, ShaperFlag)
 462
 463     void invalidate();
 464     void clearLineData();
 465
 466     void validate() const;
 467     void itemize() const;
 468
 469     bool isRightToLeft() const;
 470     static void bidiReorder(int numRuns, const quint8 *levels, int *visualOrder);
 471
 472     const HB_CharAttributes *attributes() const;
 473
 474     void shape(int item) const;
 475
 476     void justify(const QScriptLine &si);
 477     QFixed alignLine(const QScriptLine &line);
 478
 479     QFixed width(int charFrom, int numChars) const;
 480     glyph_metrics_t boundingBox(int from,  int len) const;
 481     glyph_metrics_t tightBoundingBox(int from,  int len) const;
 482
 483     int length(int item) const {
 484         const QScriptItem &si = layoutData->items[item];
 485         int from = si.position;
 486         item++;
 487         return (item < layoutData->items.size() ? layoutData->items[item].position : layoutData->string.length()) - from;
 488     }
 489     int length(const QScriptItem *si) const {
 490         int end;
 491         if (si + 1 < layoutData->items.constData()+ layoutData->items.size())
 492             end = (si+1)->position;
 493         else
 494             end = layoutData->string.length();
 495         return end - si->position;
 496     }
 497
 498     QFontEngine *fontEngine(const QScriptItem &si, QFixed *ascent = 0, QFixed *descent = 0, QFixed *leading = 0) const;
 499     QFont font(const QScriptItem &si) const;
 500     inline QFont font() const { return fnt; }
 501
 502     /**
 503      * Returns a pointer to an array of log clusters, offset at the script item.
 504      * Each item in the array is a unsigned short.  For each character in the original string there is an entry in the table
 505      * so there is a one to one correlation in indexes between the original text and the index in the logcluster.
 506      * The value of each item is the position in the glyphs array. Multiple similar pointers in the logclusters array imply
 507      * that one glyph is used for more than one character.
 508      * \sa glyphs()
 509      */
 510     inline unsigned short *logClusters(const QScriptItem *si) const
 511         { return layoutData->logClustersPtr+si->position; }
 512     /**
 513      * Returns an array of QGlyphLayout items, offset at the script item.
 514      * Each item in the array matches one glyph in the text, storing the advance, position etc.
 515      * The returned item's length equals to the number of available glyphs. This may be more
 516      * than what was actually shaped.
 517      * \sa logClusters()
 518      */
 519     inline QGlyphLayout availableGlyphs(const QScriptItem *si) const {
 520         return layoutData->glyphLayout.mid(si->glyph_data_offset);
 521     }
 522     /**
 523      * Returns an array of QGlyphLayout items, offset at the script item.
 524      * Each item in the array matches one glyph in the text, storing the advance, position etc.
 525      * The returned item's length equals to the number of shaped glyphs.
 526      * \sa logClusters()
 527      */
 528     inline QGlyphLayout shapedGlyphs(const QScriptItem *si) const {
 529         return layoutData->glyphLayout.mid(si->glyph_data_offset, si->num_glyphs);
 530     }
 531
 532     inline bool ensureSpace(int nGlyphs) const {
 533         if (layoutData->glyphLayout.numGlyphs - layoutData->used < nGlyphs)
 534             return layoutData->reallocate((((layoutData->used + nGlyphs)*3/2 + 15) >> 4) << 4);
 535         return true;
 536     }
 537
 538     void freeMemory();
 539
 540     int findItem(int strPos) const;
 541     inline QTextFormatCollection *formats() const {
 542 #ifdef QT_BUILD_COMPAT_LIB
 543         return 0; // Compat should never reference this symbol
 544 #else
 545         return block.docHandle()->formatCollection();
 546 #endif
 547     }
 548     QTextCharFormat format(const QScriptItem *si) const;
 549     inline QAbstractTextDocumentLayout *docLayout() const {
 550 #ifdef QT_BUILD_COMPAT_LIB
 551         return 0; // Compat should never reference this symbol
 552 #else
 553         return block.docHandle()->document()->documentLayout();
 554 #endif
 555     }
 556     int formatIndex(const QScriptItem *si) const;
 557
 558     /// returns the width of tab at index (in the tabs array) with the tab-start at position x
 559     QFixed calculateTabWidth(int index, QFixed x) const;
 560
 561     mutable QScriptLineArray lines;
 562
 563     struct FontEngineCache {
 564         FontEngineCache();
 565         mutable QFontEngine *prevFontEngine;
 566         mutable QFontEngine *prevScaledFontEngine;
 567         mutable int prevScript;
 568         mutable int prevPosition;
 569         mutable int prevLength;
 570         inline void reset() {
 571             prevFontEngine = 0;
 572             prevScaledFontEngine = 0;
 573             prevScript = -1;
 574             prevPosition = -1;
 575             prevLength = -1;
 576         }
 577     };
 578     mutable FontEngineCache feCache;
 579
 580     QString text;
 581     QFont fnt;
 582     QTextBlock block;
 583
 584     QTextOption option;
 585
 586     QFixed minWidth;
 587     QFixed maxWidth;
 588     QPointF position;
 589     uint ignoreBidi : 1;
 590     uint cacheGlyphs : 1;
 591     uint stackEngine : 1;
 592     uint forceJustification : 1;
 593     uint visualMovement : 1;
 594
 595     int *underlinePositions;
 596
 597     mutable LayoutData *layoutData;
 598
 599     inline bool hasFormats() const { return (block.docHandle() || specialData); }
 600     inline bool visualCursorMovement() const
 601     {
 602         return (visualMovement ||
 603                 (block.docHandle() ? block.docHandle()->defaultCursorMoveStyle == Qt::VisualMoveStyle : false));
 604     }
 605
 606     struct SpecialData {
 607         int preeditPosition;
 608         QString preeditText;
 609         QList<QTextLayout::FormatRange> addFormats;
 610         QVector<int> addFormatIndices;
 611         QVector<int> resolvedFormatIndices;
 612     };
 613     SpecialData *specialData;
 614
 615     bool atWordSeparator(int position) const;
 616     bool atSpace(int position) const;
 617     void indexAdditionalFormats();
 618
 619     QString elidedText(Qt::TextElideMode mode, const QFixed &width, int flags = 0) const;
 620
 621     void shapeLine(const QScriptLine &line);
 622     QFixed leadingSpaceWidth(const QScriptLine &line);
 623
 624     QFixed offsetInLigature(const QScriptItem *si, int pos, int max, int glyph_pos);
 625     int positionInLigature(const QScriptItem *si, int end, QFixed x, QFixed edge, int glyph_pos, bool cursorOnCharacter);
 626     int previousLogicalPosition(int oldPos) const;
 627     int nextLogicalPosition(int oldPos) const;
 628     int lineNumberForTextPosition(int pos);
 629     int positionAfterVisualMovement(int oldPos, QTextCursor::MoveOperation op);
 630     void insertionPointsForLine(int lineNum, QVector<int> &insertionPoints);
 631
 632 private:
 633     void setBoundary(int strPos) const;
 634     void addRequiredBoundaries() const;
 635     void shapeText(int item) const;
 636     void shapeTextWithHarfbuzz(int item) const;
 637 #if defined(Q_WS_WINCE)
 638     void shapeTextWithCE(int item) const;
 639 #endif
 640 #if defined(Q_WS_MAC)
 641     void shapeTextMac(int item) const;
 642 #endif
 643     void splitItem(int item, int pos) const;
 644
 645     void resolveAdditionalFormats() const;
 646     int endOfLine(int lineNum);
 647     int beginningOfLine(int lineNum);
 648     int getClusterLength(unsigned short *logClusters, const HB_CharAttributes *attributes, int from, int to, int glyph_pos, int *start);
 649 };
 650
 651 class QStackTextEngine : public QTextEngine {
 652 public:
 653     enum { MemSize = 256*40/sizeof(void *) };
 654     QStackTextEngine(const QString &string, const QFont &f);
 655     LayoutData _layoutData;
 656     void *_memory[MemSize];
 657 };
 658
 659 struct QTextLineItemIterator
 660 {
 661     QTextLineItemIterator(QTextEngine *eng, int lineNum, const QPointF &pos = QPointF(),
 662                           const QTextLayout::FormatRange *_selection = 0);
 663
 664     inline bool atEnd() const { return logicalItem >= nItems - 1; }
 665     inline bool atBeginning() const { return logicalItem <= 0; }
 666     QScriptItem &next();
 667
 668     bool getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const;
 669     inline bool isOutsideSelection() const {
 670         QFixed tmp1, tmp2;
 671         return !getSelectionBounds(&tmp1, &tmp2);
 672     }
 673
 674     QTextEngine *eng;
 675
 676     QFixed x;
 677     QFixed pos_x;
 678     const QScriptLine &line;
 679     QScriptItem *si;
 680
 681     int lineNum;
 682     int lineEnd;
 683     int firstItem;
 684     int lastItem;
 685     int nItems;
 686     int logicalItem;
 687     int item;
 688     int itemLength;
 689
 690     int glyphsStart;
 691     int glyphsEnd;
 692     int itemStart;
 693     int itemEnd;
 694
 695     QFixed itemWidth;
 696
 697     QVarLengthArray<int> visualOrder;
 698     QVarLengthArray<uchar> levels;
 699
 700     const QTextLayout::FormatRange *selection;
 701 };
 702
 703 Q_DECLARE_OPERATORS_FOR_FLAGS(QTextEngine::ShaperFlags)
 704
 705 QT_END_NAMESPACE
 706
 707 #endif // QTEXTENGINE_P_H