Qt 4.8
qtextengine_p.h
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
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 Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
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 
79 
80 class QFontPrivate;
81 class QFontEngine;
82 
83 class QString;
84 class QPainter;
85 
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
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  {}
112 
113  glyph_metrics_t transformed(const QTransform &xform) const;
114  inline bool isValid() const {return x != 100000 && y != 100000;}
115 };
117 
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 };
140 
142 {
144  : type(0), nKashidas(0), space_18d6(0)
145  {}
146 
150  JustifyKashida
151  };
152 
153  uint type :2;
154  uint nKashidas : 6; // more do not make sense...
156 };
158 
160 {
163  HB_Glyph glyph;
165  HB_GlyphAttributes attributes;
166 };
167 
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 
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 
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 
269 {
270 private:
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:
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;
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,
317 
320  QTextItemInt midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const;
321  void initWithScriptItem(const QScriptItem &si);
322 
326 
327  RenderFlags flags;
328  bool justified;
332  const QChar *chars;
333  const unsigned short *logClusters;
334  const QFont *f;
335 
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 
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;
361  unsigned short num_glyphs;
367  QFixed height() const { return ascent + descent + 1; }
368 };
369 
370 
372 
374 
376 {
377  // created and filled in QTextLine::layout_helper
379  : from(0), trailingSpaces(0), length(0),
380  justified(0), gridfitted(0),
381  hasTrailingSpaces(0), leadingIncluded(0) {}
390  int from;
391  unsigned short trailingSpaces;
392  signed int length : 28;
393  mutable uint justified : 1;
394  mutable uint gridfitted : 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 };
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 
417 
418 class QFontPrivate;
420 
422 public:
423  enum LayoutState {
427  };
428  struct LayoutData {
429  LayoutData(const QString &str, void **stack_memory, int mem_size);
430  LayoutData();
431  ~LayoutData();
435  void **memory;
436  unsigned short *logClustersPtr;
438  mutable int used;
444  bool reallocate(int totalGlyphs);
445  };
446 
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 
511  inline unsigned short *logClusters(const QScriptItem *si) const
512  { return layoutData->logClustersPtr+si->position; }
520  inline QGlyphLayout availableGlyphs(const QScriptItem *si) const {
521  return layoutData->glyphLayout.mid(si->glyph_data_offset);
522  }
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;
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 
560  QFixed calculateTabWidth(int index, QFixed x) const;
561 
563 
565  FontEngineCache();
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  };
580 
584 
586 
595 
597 
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 {
613  };
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  void resetFontEngineCache();
633 
634 private:
635  void setBoundary(int strPos) const;
636  void addRequiredBoundaries() const;
637  void shapeText(int item) const;
638  void shapeTextWithHarfbuzz(int item) const;
639 #if defined(Q_WS_WINCE)
640  void shapeTextWithCE(int item) const;
641 #endif
642 #if defined(Q_WS_MAC)
643  void shapeTextMac(int item) const;
644 #endif
645  void splitItem(int item, int pos) const;
646 
647  void resolveAdditionalFormats() const;
648  int endOfLine(int lineNum);
649  int beginningOfLine(int lineNum);
650  int getClusterLength(unsigned short *logClusters, const HB_CharAttributes *attributes, int from, int to, int glyph_pos, int *start);
651 };
652 
654 public:
655  enum { MemSize = 256*40/sizeof(void *) };
656  QStackTextEngine(const QString &string, const QFont &f);
658  void *_memory[MemSize];
659 };
660 
662 {
663  QTextLineItemIterator(QTextEngine *eng, int lineNum, const QPointF &pos = QPointF(),
664  const QTextLayout::FormatRange *_selection = 0);
665 
666  inline bool atEnd() const { return logicalItem >= nItems - 1; }
667  inline bool atBeginning() const { return logicalItem <= 0; }
668  QScriptItem &next();
669 
670  bool getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const;
671  inline bool isOutsideSelection() const {
672  QFixed tmp1, tmp2;
673  return !getSelectionBounds(&tmp1, &tmp2);
674  }
675 
677 
682 
683  int lineNum;
684  int lineEnd;
686  int lastItem;
687  int nItems;
689  int item;
691 
695  int itemEnd;
696 
698 
701 
703 };
704 
705 Q_DECLARE_OPERATORS_FOR_FLAGS(QTextEngine::ShaperFlags)
706 
708 
709 #endif // QTEXTENGINE_P_H
The QPainter class performs low-level painting on widgets and other paint devices.
Definition: qpainter.h:86
QFontEngine * fontEngine
QVarLengthArray< uchar > levels
The QTextLayout::FormatRange structure is used to apply extra formatting information for a specified ...
Definition: qtextlayout.h:128
unsigned short trailingSpaces
QFixed leading
uint leadingIncluded
QGlyphJustification * justifications
QFixed * advances_y
static QFixed fromFixed(int fixed)
Definition: qfixed_p.h:71
int type
Definition: qmetatype.cpp:239
The QTextCharFormat class provides formatting information for characters in a QTextDocument.
Definition: qtextformat.h:372
char * data()
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
QFixed * advances_x
void clear(int first=0, int last=-1)
bool qIsControlChar(ushort uc)
#define Q_DECLARE_FLAGS(Flags, Enum)
The Q_DECLARE_FLAGS() macro expands to.
Definition: qglobal.h:2348
const QChar * chars
HB_Glyph * glyphs
QVarLengthArray< void * > Array
SpecialData * specialData
#define Q_GUI_EXPORT
Definition: qglobal.h:1450
RenderFlags flags
TextElideMode
Definition: qnamespace.h:263
The QPointF class defines a point in the plane using floating point precision.
Definition: qpoint.h:214
static qreal position(QGraphicsObject *item, QDeclarativeAnchorLine::AnchorLine anchorLine)
int * underlinePositions
QTextDocument * document() const
Returns the text document that this layout is operating on.
bool ensureSpace(int nGlyphs) const
QScriptItemArray items
const unsigned short * logClusters
long ASN1_INTEGER_get ASN1_INTEGER * a
unsigned char quint8
Definition: qglobal.h:934
QFixed textWidth
LayoutData * layoutData
unsigned short * logClusters(const QScriptItem *si) const
The QString class provides a Unicode character string.
Definition: qstring.h:83
bool hasFormats() const
QFixed height() const
QGlyphLayout mid(int position, int n=-1) const
QVarLengthArray< int > visualOrder
uint forceJustification
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72
QList< QTextLayout::FormatRange > addFormats
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
QFont font() const
glyph_metrics_t(QFixed _x, QFixed _y, QFixed _width, QFixed _height, QFixed _xoff, QFixed _yoff)
Definition: qtextengine_p.h:98
QGlyphLayout glyphs
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
glyph_metrics_t transformed(const QTransform &xform) const
QFixed y
Definition: qfixed_p.h:191
UnderlineStyle
This enum describes the different ways drawing underlined text.
Definition: qtextformat.h:384
#define Q_DECLARE_OPERATORS_FOR_FLAGS(Flags)
The Q_DECLARE_OPERATORS_FOR_FLAGS() macro declares global operator|() functions for Flags...
Definition: qglobal.h:2355
int length(const QScriptItem *si) const
QFixed height() const
QGlyphLayout shapedGlyphs(const QScriptItem *si) const
FontEngineCache feCache
unsigned short bidiLevel
Internal QTextItem.
QVector< QScriptLine > QScriptLineArray
The QTextBlock class provides a container for text fragments in a QTextDocument.
Definition: qtextobject.h:199
static const char * data(const QByteArray &arr)
unsigned int uint
Definition: qglobal.h:996
LayoutData _layoutData
unsigned short num_glyphs
const QTextLayout::FormatRange * selection
uint hasTrailingSpaces
QGlyphLayoutInstance instance(int position) const
QScriptLineArray lines
QTextOption option
void operator+=(const QScriptLine &other)
static int spaceNeededForGlyphLayout(int totalGlyphs)
QGlyphLayout availableGlyphs(const QScriptItem *si) const
Q_CORE_EXPORT int QT_FASTCALL script(uint ucs4)
bool isValid() const
#define None
QFixed descent
QScriptItem(int p, const QScriptAnalysis &a)
unsigned short flags
QTextBlock block
unsigned short * logClustersPtr
void resize(int totalGlyphs)
QFixed leading
QFixed x
Definition: qfixed_p.h:190
QGlyphJustification justification
QVector< QScriptItem > QScriptItemArray
QFixed textAdvance
QFixed descent
unsigned short script
QTextCharFormat::UnderlineStyle underlineStyle
The QFont class specifies a font used for drawing text.
Definition: qfont.h:64
unsigned short ushort
Definition: qglobal.h:995
QFixed maxWidth
QVector< int > addFormatIndices
QPointF position
QAbstractTextDocumentLayout * documentLayout() const
Returns the document layout for this document.
QVector< int > resolvedFormatIndices
bool atBeginning() const
int length(int item) const
#define Q_AUTOTEST_EXPORT
Definition: qglobal.h:1510
uint visualMovement
The QTextOption class provides a description of general rich text properties.
Definition: qtextoption.h:59
signed int length
QVarLengthGlyphLayoutArray(int totalGlyphs)
quint16 index
Q_DECLARE_TYPEINFO(glyph_metrics_t, Q_PRIMITIVE_TYPE)
QGlyphLayout(char *address, int totalGlyphs)
QFixed effectiveAdvance(int item) const
QFixed base() const
HB_GlyphAttributes * attributes
QString text
Qt::CursorMoveStyle defaultCursorMoveStyle
const QScriptLine & line
HB_GlyphAttributes attributes
int glyph_data_offset
QTextDocumentPrivate * docHandle() const
Definition: qtextobject.h:283
static int grow(int size)
Definition: qlist.cpp:62
The QTextItem class provides all the information required to draw text in a custom paint engine...
Definition: qpaintengine.h:68
timeval & operator+=(timeval &t1, const timeval &t2)
Definition: qcore_unix_p.h:120
bool isOutsideSelection() const
QFontEngine * prevScaledFontEngine
const QTextCharFormat charFormat
QFixedPoint * offsets
static const KeyPair *const end
void setInstance(int position, const QGlyphLayoutInstance &g)
const QFont * f
QTextFormatCollection * formats() const
bool operator==(QBool b1, bool b2)
Definition: qglobal.h:2023
QFixed ceil() const
Definition: qfixed_p.h:82
QFixed minWidth
bool visualCursorMovement() const
QAbstractTextDocumentLayout * docLayout() const
The QTransform class specifies 2D transformations of a coordinate system.
Definition: qtransform.h:65
QScriptAnalysis analysis
The QAbstractTextDocumentLayout class is an abstract base class used to implement custom layouts for ...