diff options
Diffstat (limited to 'src/gui/text/qtextengine.cpp')
| -rw-r--r-- | src/gui/text/qtextengine.cpp | 2845 |
1 files changed, 2845 insertions, 0 deletions
diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp new file mode 100644 index 0000000000..08d0eca7ac --- /dev/null +++ b/src/gui/text/qtextengine.cpp @@ -0,0 +1,2845 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdebug.h" +#include "qtextformat.h" +#include "qtextformat_p.h" +#include "qtextengine_p.h" +#include "qabstracttextdocumentlayout.h" +#include "qtextlayout.h" +#include "qtextboundaryfinder.h" +#include "qvarlengtharray.h" +#include "qfont.h" +#include "qfont_p.h" +#include "qfontengine_p.h" +#include "qstring.h" +#include <private/qunicodetables_p.h> +#include "qtextdocument_p.h" +#include <qapplication.h> +#include <stdlib.h> + + +QT_BEGIN_NAMESPACE + +namespace { +// Helper class used in QTextEngine::itemize +// keep it out here to allow us to keep supporting various compilers. +class Itemizer { +public: + Itemizer(const QString &string, const QScriptAnalysis *analysis, QScriptItemArray &items) + : m_string(string), + m_analysis(analysis), + m_items(items), + m_splitter(0) + { + } + ~Itemizer() + { + delete m_splitter; + } + + /// generate the script items + /// The caps parameter is used to choose the algoritm of splitting text and assiging roles to the textitems + void generate(int start, int length, QFont::Capitalization caps) + { + if ((int)caps == (int)QFont::SmallCaps) + generateScriptItemsSmallCaps(reinterpret_cast<const ushort *>(m_string.unicode()), start, length); + else if(caps == QFont::Capitalize) + generateScriptItemsCapitalize(start, length); + else if(caps != QFont::MixedCase) { + generateScriptItemsAndChangeCase(start, length, + caps == QFont::AllLowercase ? QScriptAnalysis::Lowercase : QScriptAnalysis::Uppercase); + } + else + generateScriptItems(start, length); + } + +private: + enum { MaxItemLength = 4096 }; + + void generateScriptItemsAndChangeCase(int start, int length, QScriptAnalysis::Flags flags) + { + generateScriptItems(start, length); + if (m_items.isEmpty()) // the next loop won't work in that case + return; + QScriptItemArray::Iterator iter = m_items.end(); + do { + iter--; + if (iter->analysis.flags < QScriptAnalysis::TabOrObject) + iter->analysis.flags = flags; + } while (iter->position > start); + } + + void generateScriptItems(int start, int length) + { + if (!length) + return; + const int end = start + length; + for (int i = start + 1; i < end; ++i) { + if ((m_analysis[i] == m_analysis[start]) + && m_analysis[i].flags < QScriptAnalysis::SpaceTabOrObject + && i - start < MaxItemLength) + continue; + m_items.append(QScriptItem(start, m_analysis[start])); + start = i; + } + m_items.append(QScriptItem(start, m_analysis[start])); + } + + void generateScriptItemsCapitalize(int start, int length) + { + if (!length) + return; + + if (!m_splitter) + m_splitter = new QTextBoundaryFinder(QTextBoundaryFinder::Word, + m_string.constData(), m_string.length(), + /*buffer*/0, /*buffer size*/0); + + m_splitter->setPosition(start); + QScriptAnalysis itemAnalysis = m_analysis[start]; + + if (m_splitter->boundaryReasons() & QTextBoundaryFinder::StartWord) { + itemAnalysis.flags = QScriptAnalysis::Uppercase; + m_splitter->toNextBoundary(); + } + + const int end = start + length; + for (int i = start + 1; i < end; ++i) { + + bool atWordBoundary = false; + + if (i == m_splitter->position()) { + if (m_splitter->boundaryReasons() & QTextBoundaryFinder::StartWord + && m_analysis[i].flags < QScriptAnalysis::TabOrObject) + atWordBoundary = true; + + m_splitter->toNextBoundary(); + } + + if (m_analysis[i] == itemAnalysis + && m_analysis[i].flags < QScriptAnalysis::TabOrObject + && !atWordBoundary + && i - start < MaxItemLength) + continue; + + m_items.append(QScriptItem(start, itemAnalysis)); + start = i; + itemAnalysis = m_analysis[start]; + + if (atWordBoundary) + itemAnalysis.flags = QScriptAnalysis::Uppercase; + } + m_items.append(QScriptItem(start, itemAnalysis)); + } + + void generateScriptItemsSmallCaps(const ushort *uc, int start, int length) + { + if (!length) + return; + bool lower = (QChar::category(uc[start]) == QChar::Letter_Lowercase); + const int end = start + length; + // split text into parts that are already uppercase and parts that are lowercase, and mark the latter to be uppercased later. + for (int i = start + 1; i < end; ++i) { + bool l = (QChar::category(uc[i]) == QChar::Letter_Lowercase); + if ((m_analysis[i] == m_analysis[start]) + && m_analysis[i].flags < QScriptAnalysis::TabOrObject + && l == lower + && i - start < MaxItemLength) + continue; + m_items.append(QScriptItem(start, m_analysis[start])); + if (lower) + m_items.last().analysis.flags = QScriptAnalysis::SmallCaps; + + start = i; + lower = l; + } + m_items.append(QScriptItem(start, m_analysis[start])); + if (lower) + m_items.last().analysis.flags = QScriptAnalysis::SmallCaps; + } + + const QString &m_string; + const QScriptAnalysis * const m_analysis; + QScriptItemArray &m_items; + QTextBoundaryFinder *m_splitter; +}; +} + + +// ---------------------------------------------------------------------------- +// +// The BiDi algorithm +// +// ---------------------------------------------------------------------------- + +#define BIDI_DEBUG 0 +#if (BIDI_DEBUG >= 1) +QT_BEGIN_INCLUDE_NAMESPACE +#include <iostream> +QT_END_INCLUDE_NAMESPACE +using namespace std; + +static const char *directions[] = { + "DirL", "DirR", "DirEN", "DirES", "DirET", "DirAN", "DirCS", "DirB", "DirS", "DirWS", "DirON", + "DirLRE", "DirLRO", "DirAL", "DirRLE", "DirRLO", "DirPDF", "DirNSM", "DirBN" +}; + +#endif + +struct QBidiStatus { + QBidiStatus() { + eor = QChar::DirON; + lastStrong = QChar::DirON; + last = QChar:: DirON; + dir = QChar::DirON; + } + QChar::Direction eor; + QChar::Direction lastStrong; + QChar::Direction last; + QChar::Direction dir; +}; + +enum { MaxBidiLevel = 61 }; + +struct QBidiControl { + inline QBidiControl(bool rtl) + : cCtx(0), base(rtl ? 1 : 0), level(rtl ? 1 : 0), override(false) {} + + inline void embed(bool rtl, bool o = false) { + unsigned int toAdd = 1; + if((level%2 != 0) == rtl ) { + ++toAdd; + } + if (level + toAdd <= MaxBidiLevel) { + ctx[cCtx].level = level; + ctx[cCtx].override = override; + cCtx++; + override = o; + level += toAdd; + } + } + inline bool canPop() const { return cCtx != 0; } + inline void pdf() { + Q_ASSERT(cCtx); + --cCtx; + level = ctx[cCtx].level; + override = ctx[cCtx].override; + } + + inline QChar::Direction basicDirection() const { + return (base ? QChar::DirR : QChar:: DirL); + } + inline unsigned int baseLevel() const { + return base; + } + inline QChar::Direction direction() const { + return ((level%2) ? QChar::DirR : QChar:: DirL); + } + + struct { + unsigned int level; + bool override; + } ctx[MaxBidiLevel]; + unsigned int cCtx; + const unsigned int base; + unsigned int level; + bool override; +}; + + +static void appendItems(QScriptAnalysis *analysis, int &start, int &stop, const QBidiControl &control, QChar::Direction dir) +{ + if (start > stop) + return; + + int level = control.level; + + if(dir != QChar::DirON && !control.override) { + // add level of run (cases I1 & I2) + if(level % 2) { + if(dir == QChar::DirL || dir == QChar::DirAN || dir == QChar::DirEN) + level++; + } else { + if(dir == QChar::DirR) + level++; + else if(dir == QChar::DirAN || dir == QChar::DirEN) + level += 2; + } + } + +#if (BIDI_DEBUG >= 1) + qDebug("new run: dir=%s from %d, to %d level = %d override=%d", directions[dir], start, stop, level, control.override); +#endif + QScriptAnalysis *s = analysis + start; + const QScriptAnalysis *e = analysis + stop; + while (s <= e) { + s->bidiLevel = level; + ++s; + } + ++stop; + start = stop; +} + + +// creates the next QScript items. +static bool bidiItemize(QTextEngine *engine, QScriptAnalysis *analysis, QBidiControl &control) +{ + bool rightToLeft = (control.basicDirection() == 1); + bool hasBidi = rightToLeft; +#if BIDI_DEBUG >= 2 + qDebug() << "bidiItemize: rightToLeft=" << rightToLeft << engine->layoutData->string; +#endif + + int sor = 0; + int eor = -1; + + + int length = engine->layoutData->string.length(); + + const ushort *unicode = (const ushort *)engine->layoutData->string.unicode(); + int current = 0; + + QChar::Direction dir = rightToLeft ? QChar::DirR : QChar::DirL; + QBidiStatus status; + + QChar::Direction sdir = QChar::direction(*unicode); + if (sdir != QChar::DirL && sdir != QChar::DirR && sdir != QChar::DirEN && sdir != QChar::DirAN) + sdir = QChar::DirON; + else + dir = QChar::DirON; + status.eor = sdir; + status.lastStrong = rightToLeft ? QChar::DirR : QChar::DirL; + status.last = status.lastStrong; + status.dir = sdir; + + + while (current <= length) { + + QChar::Direction dirCurrent; + if (current == (int)length) + dirCurrent = control.basicDirection(); + else + dirCurrent = QChar::direction(unicode[current]); + +#if (BIDI_DEBUG >= 2) +// qDebug() << "pos=" << current << " dir=" << directions[dir] +// << " current=" << directions[dirCurrent] << " last=" << directions[status.last] +// << " eor=" << eor << '/' << directions[status.eor] +// << " sor=" << sor << " lastStrong=" +// << directions[status.lastStrong] +// << " level=" << (int)control.level << " override=" << (bool)control.override; +#endif + + switch(dirCurrent) { + + // embedding and overrides (X1-X9 in the BiDi specs) + case QChar::DirRLE: + case QChar::DirRLO: + case QChar::DirLRE: + case QChar::DirLRO: + { + bool rtl = (dirCurrent == QChar::DirRLE || dirCurrent == QChar::DirRLO); + hasBidi |= rtl; + bool override = (dirCurrent == QChar::DirLRO || dirCurrent == QChar::DirRLO); + + unsigned int level = control.level+1; + if ((level%2 != 0) == rtl) ++level; + if(level < MaxBidiLevel) { + eor = current-1; + appendItems(analysis, sor, eor, control, dir); + eor = current; + control.embed(rtl, override); + QChar::Direction edir = (rtl ? QChar::DirR : QChar::DirL); + dir = status.eor = edir; + status.lastStrong = edir; + } + break; + } + case QChar::DirPDF: + { + if (control.canPop()) { + if (dir != control.direction()) { + eor = current-1; + appendItems(analysis, sor, eor, control, dir); + dir = control.direction(); + } + eor = current; + appendItems(analysis, sor, eor, control, dir); + control.pdf(); + dir = QChar::DirON; status.eor = QChar::DirON; + status.last = control.direction(); + if (control.override) + dir = control.direction(); + else + dir = QChar::DirON; + status.lastStrong = control.direction(); + } + break; + } + + // strong types + case QChar::DirL: + if(dir == QChar::DirON) + dir = QChar::DirL; + switch(status.last) + { + case QChar::DirL: + eor = current; status.eor = QChar::DirL; break; + case QChar::DirR: + case QChar::DirAL: + case QChar::DirEN: + case QChar::DirAN: + if (eor >= 0) { + appendItems(analysis, sor, eor, control, dir); + dir = eor < length ? QChar::direction(unicode[eor]) : control.basicDirection(); + status.eor = dir; + } else { + eor = current; status.eor = dir; + } + break; + case QChar::DirES: + case QChar::DirET: + case QChar::DirCS: + case QChar::DirBN: + case QChar::DirB: + case QChar::DirS: + case QChar::DirWS: + case QChar::DirON: + if(dir != QChar::DirL) { + //last stuff takes embedding dir + if(control.direction() == QChar::DirR) { + if(status.eor != QChar::DirR) { + // AN or EN + appendItems(analysis, sor, eor, control, dir); + status.eor = QChar::DirON; + dir = QChar::DirR; + } + eor = current - 1; + appendItems(analysis, sor, eor, control, dir); + dir = eor < length ? QChar::direction(unicode[eor]) : control.basicDirection(); + status.eor = dir; + } else { + if(status.eor != QChar::DirL) { + appendItems(analysis, sor, eor, control, dir); + status.eor = QChar::DirON; + dir = QChar::DirL; + } else { + eor = current; status.eor = QChar::DirL; break; + } + } + } else { + eor = current; status.eor = QChar::DirL; + } + default: + break; + } + status.lastStrong = QChar::DirL; + break; + case QChar::DirAL: + case QChar::DirR: + hasBidi = true; + if(dir == QChar::DirON) dir = QChar::DirR; + switch(status.last) + { + case QChar::DirL: + case QChar::DirEN: + case QChar::DirAN: + if (eor >= 0) + appendItems(analysis, sor, eor, control, dir); + // fall through + case QChar::DirR: + case QChar::DirAL: + dir = QChar::DirR; eor = current; status.eor = QChar::DirR; break; + case QChar::DirES: + case QChar::DirET: + case QChar::DirCS: + case QChar::DirBN: + case QChar::DirB: + case QChar::DirS: + case QChar::DirWS: + case QChar::DirON: + if(status.eor != QChar::DirR && status.eor != QChar::DirAL) { + //last stuff takes embedding dir + if(control.direction() == QChar::DirR + || status.lastStrong == QChar::DirR || status.lastStrong == QChar::DirAL) { + appendItems(analysis, sor, eor, control, dir); + dir = QChar::DirR; status.eor = QChar::DirON; + eor = current; + } else { + eor = current - 1; + appendItems(analysis, sor, eor, control, dir); + dir = QChar::DirR; status.eor = QChar::DirON; + } + } else { + eor = current; status.eor = QChar::DirR; + } + default: + break; + } + status.lastStrong = dirCurrent; + break; + + // weak types: + + case QChar::DirNSM: + if (eor == current-1) + eor = current; + break; + case QChar::DirEN: + // if last strong was AL change EN to AN + if(status.lastStrong != QChar::DirAL) { + if(dir == QChar::DirON) { + if(status.lastStrong == QChar::DirL) + dir = QChar::DirL; + else + dir = QChar::DirEN; + } + switch(status.last) + { + case QChar::DirET: + if (status.lastStrong == QChar::DirR || status.lastStrong == QChar::DirAL) { + appendItems(analysis, sor, eor, control, dir); + status.eor = QChar::DirON; + dir = QChar::DirAN; + } + // fall through + case QChar::DirEN: + case QChar::DirL: + eor = current; + status.eor = dirCurrent; + break; + case QChar::DirR: + case QChar::DirAL: + case QChar::DirAN: + if (eor >= 0) + appendItems(analysis, sor, eor, control, dir); + else + eor = current; + status.eor = QChar::DirEN; + dir = QChar::DirAN; break; + case QChar::DirES: + case QChar::DirCS: + if(status.eor == QChar::DirEN || dir == QChar::DirAN) { + eor = current; break; + } + case QChar::DirBN: + case QChar::DirB: + case QChar::DirS: + case QChar::DirWS: + case QChar::DirON: + if(status.eor == QChar::DirR) { + // neutrals go to R + eor = current - 1; + appendItems(analysis, sor, eor, control, dir); + dir = QChar::DirON; status.eor = QChar::DirEN; + dir = QChar::DirAN; + } + else if(status.eor == QChar::DirL || + (status.eor == QChar::DirEN && status.lastStrong == QChar::DirL)) { + eor = current; status.eor = dirCurrent; + } else { + // numbers on both sides, neutrals get right to left direction + if(dir != QChar::DirL) { + appendItems(analysis, sor, eor, control, dir); + dir = QChar::DirON; status.eor = QChar::DirON; + eor = current - 1; + dir = QChar::DirR; + appendItems(analysis, sor, eor, control, dir); + dir = QChar::DirON; status.eor = QChar::DirON; + dir = QChar::DirAN; + } else { + eor = current; status.eor = dirCurrent; + } + } + default: + break; + } + break; + } + case QChar::DirAN: + hasBidi = true; + dirCurrent = QChar::DirAN; + if(dir == QChar::DirON) dir = QChar::DirAN; + switch(status.last) + { + case QChar::DirL: + case QChar::DirAN: + eor = current; status.eor = QChar::DirAN; break; + case QChar::DirR: + case QChar::DirAL: + case QChar::DirEN: + if (eor >= 0){ + appendItems(analysis, sor, eor, control, dir); + } else { + eor = current; + } + dir = QChar::DirAN; status.eor = QChar::DirAN; + break; + case QChar::DirCS: + if(status.eor == QChar::DirAN) { + eor = current; break; + } + case QChar::DirES: + case QChar::DirET: + case QChar::DirBN: + case QChar::DirB: + case QChar::DirS: + case QChar::DirWS: + case QChar::DirON: + if(status.eor == QChar::DirR) { + // neutrals go to R + eor = current - 1; + appendItems(analysis, sor, eor, control, dir); + status.eor = QChar::DirAN; + dir = QChar::DirAN; + } else if(status.eor == QChar::DirL || + (status.eor == QChar::DirEN && status.lastStrong == QChar::DirL)) { + eor = current; status.eor = dirCurrent; + } else { + // numbers on both sides, neutrals get right to left direction + if(dir != QChar::DirL) { + appendItems(analysis, sor, eor, control, dir); + status.eor = QChar::DirON; + eor = current - 1; + dir = QChar::DirR; + appendItems(analysis, sor, eor, control, dir); + status.eor = QChar::DirAN; + dir = QChar::DirAN; + } else { + eor = current; status.eor = dirCurrent; + } + } + default: + break; + } + break; + case QChar::DirES: + case QChar::DirCS: + break; + case QChar::DirET: + if(status.last == QChar::DirEN) { + dirCurrent = QChar::DirEN; + eor = current; status.eor = dirCurrent; + } + break; + + // boundary neutrals should be ignored + case QChar::DirBN: + break; + // neutrals + case QChar::DirB: + // ### what do we do with newline and paragraph separators that come to here? + break; + case QChar::DirS: + // ### implement rule L1 + break; + case QChar::DirWS: + case QChar::DirON: + break; + default: + break; + } + + //qDebug() << " after: dir=" << // dir << " current=" << dirCurrent << " last=" << status.last << " eor=" << status.eor << " lastStrong=" << status.lastStrong << " embedding=" << control.direction(); + + if(current >= (int)length) break; + + // set status.last as needed. + switch(dirCurrent) { + case QChar::DirET: + case QChar::DirES: + case QChar::DirCS: + case QChar::DirS: + case QChar::DirWS: + case QChar::DirON: + switch(status.last) + { + case QChar::DirL: + case QChar::DirR: + case QChar::DirAL: + case QChar::DirEN: + case QChar::DirAN: + status.last = dirCurrent; + break; + default: + status.last = QChar::DirON; + } + break; + case QChar::DirNSM: + case QChar::DirBN: + // ignore these + break; + case QChar::DirLRO: + case QChar::DirLRE: + status.last = QChar::DirL; + break; + case QChar::DirRLO: + case QChar::DirRLE: + status.last = QChar::DirR; + break; + case QChar::DirEN: + if (status.last == QChar::DirL) { + status.last = QChar::DirL; + break; + } + // fall through + default: + status.last = dirCurrent; + } + + ++current; + } + +#if (BIDI_DEBUG >= 1) + qDebug() << "reached end of line current=" << current << ", eor=" << eor; +#endif + eor = current - 1; // remove dummy char + + if (sor <= eor) + appendItems(analysis, sor, eor, control, dir); + + return hasBidi; +} + +void QTextEngine::bidiReorder(int numItems, const quint8 *levels, int *visualOrder) +{ + + // first find highest and lowest levels + quint8 levelLow = 128; + quint8 levelHigh = 0; + int i = 0; + while (i < numItems) { + //printf("level = %d\n", r->level); + if (levels[i] > levelHigh) + levelHigh = levels[i]; + if (levels[i] < levelLow) + levelLow = levels[i]; + i++; + } + + // implements reordering of the line (L2 according to BiDi spec): + // L2. From the highest level found in the text to the lowest odd level on each line, + // reverse any contiguous sequence of characters that are at that level or higher. + + // reversing is only done up to the lowest odd level + if(!(levelLow%2)) levelLow++; + +#if (BIDI_DEBUG >= 1) +// qDebug() << "reorderLine: lineLow = " << (uint)levelLow << ", lineHigh = " << (uint)levelHigh; +#endif + + int count = numItems - 1; + for (i = 0; i < numItems; i++) + visualOrder[i] = i; + + while(levelHigh >= levelLow) { + int i = 0; + while (i < count) { + while(i < count && levels[i] < levelHigh) i++; + int start = i; + while(i <= count && levels[i] >= levelHigh) i++; + int end = i-1; + + if(start != end) { + //qDebug() << "reversing from " << start << " to " << end; + for(int j = 0; j < (end-start+1)/2; j++) { + int tmp = visualOrder[start+j]; + visualOrder[start+j] = visualOrder[end-j]; + visualOrder[end-j] = tmp; + } + } + i++; + } + levelHigh--; + } + +#if (BIDI_DEBUG >= 1) +// qDebug() << "visual order is:"; +// for (i = 0; i < numItems; i++) +// qDebug() << visualOrder[i]; +#endif +} + +QT_BEGIN_INCLUDE_NAMESPACE + +#if defined(Q_WS_X11) || defined (Q_WS_QWS) +# include "qfontengine_ft_p.h" +#elif defined(Q_WS_MAC) +# include "qtextengine_mac.cpp" +#endif + +#include <private/qharfbuzz_p.h> + +QT_END_INCLUDE_NAMESPACE + +// ask the font engine to find out which glyphs (as an index in the specific font) to use for the text in one item. +static bool stringToGlyphs(HB_ShaperItem *item, QGlyphLayout *glyphs, QFontEngine *fontEngine) +{ + int nGlyphs = item->num_glyphs; + + QTextEngine::ShaperFlags shaperFlags(QTextEngine::GlyphIndicesOnly); + if (item->item.bidiLevel % 2) + shaperFlags |= QTextEngine::RightToLeft; + + bool result = fontEngine->stringToCMap(reinterpret_cast<const QChar *>(item->string + item->item.pos), item->item.length, glyphs, &nGlyphs, shaperFlags); + item->num_glyphs = nGlyphs; + glyphs->numGlyphs = nGlyphs; + return result; +} + +// shape all the items that intersect with the line, taking tab widths into account to find out what text actually fits in the line. +void QTextEngine::shapeLine(const QScriptLine &line) +{ + QFixed x; + bool first = true; + const int end = findItem(line.from + line.length - 1); + int item = findItem(line.from); + if (item == -1) + return; + for (item = findItem(line.from); item <= end; ++item) { + QScriptItem &si = layoutData->items[item]; + if (si.analysis.flags == QScriptAnalysis::Tab) { + ensureSpace(1); + si.width = calculateTabWidth(item, x); + } else { + shape(item); + } + if (first && si.position != line.from) { // that means our x position has to be offset + QGlyphLayout glyphs = shapedGlyphs(&si); + Q_ASSERT(line.from > si.position); + for (int i = line.from - si.position - 1; i >= 0; i--) { + x -= glyphs.effectiveAdvance(i); + } + } + first = false; + + x += si.width; + } +} + +void QTextEngine::shapeText(int item) const +{ + Q_ASSERT(item < layoutData->items.size()); + QScriptItem &si = layoutData->items[item]; + + if (si.num_glyphs) + return; + +#if defined(Q_WS_MAC) + shapeTextMac(item); +#elif defined(Q_WS_WINCE) + shapeTextWithCE(item); +#else + shapeTextWithHarfbuzz(item); +#endif + + si.width = 0; + + if (!si.num_glyphs) + return; + QGlyphLayout glyphs = shapedGlyphs(&si); + + QFont font = this->font(si); + bool letterSpacingIsAbsolute = font.d->letterSpacingIsAbsolute; + QFixed letterSpacing = font.d->letterSpacing; + QFixed wordSpacing = font.d->wordSpacing; + + if (letterSpacingIsAbsolute && letterSpacing.value()) + letterSpacing *= font.d->dpi / qt_defaultDpiY(); + + if (letterSpacing != 0) { + for (int i = 1; i < si.num_glyphs; ++i) { + if (glyphs.attributes[i].clusterStart) { + if (letterSpacingIsAbsolute) + glyphs.advances_x[i-1] += letterSpacing; + else { + QFixed &advance = glyphs.advances_x[i-1]; + advance += (letterSpacing - 100) * advance / 100; + } + } + } + if (letterSpacingIsAbsolute) + glyphs.advances_x[si.num_glyphs-1] += letterSpacing; + else { + QFixed &advance = glyphs.advances_x[si.num_glyphs-1]; + advance += (letterSpacing - 100) * advance / 100; + } + } + if (wordSpacing != 0) { + for (int i = 0; i < si.num_glyphs; ++i) { + if (glyphs.attributes[i].justification == HB_Space + || glyphs.attributes[i].justification == HB_Arabic_Space) { + // word spacing only gets added once to a consecutive run of spaces (see CSS spec) + if (i + 1 == si.num_glyphs + ||(glyphs.attributes[i+1].justification != HB_Space + && glyphs.attributes[i+1].justification != HB_Arabic_Space)) + glyphs.advances_x[i] += wordSpacing; + } + } + } + + for (int i = 0; i < si.num_glyphs; ++i) + si.width += glyphs.advances_x[i]; +} + +static inline bool hasCaseChange(const QScriptItem &si) +{ + return si.analysis.flags == QScriptAnalysis::SmallCaps || + si.analysis.flags == QScriptAnalysis::Uppercase || + si.analysis.flags == QScriptAnalysis::Lowercase; +} + +#if defined(Q_WS_WINCE) //TODO +// set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs +// and no reordering. +// also computes logClusters heuristically +static void heuristicSetGlyphAttributes(const QChar *uc, int length, QGlyphLayout *glyphs, unsigned short *logClusters, int num_glyphs) +{ + // ### zeroWidth and justification are missing here!!!!! + + Q_UNUSED(num_glyphs); + Q_ASSERT(num_glyphs <= length); + +// qDebug("QScriptEngine::heuristicSetGlyphAttributes, num_glyphs=%d", item->num_glyphs); + + int glyph_pos = 0; + for (int i = 0; i < length; i++) { + if (uc[i].unicode() >= 0xd800 && uc[i].unicode() < 0xdc00 && i < length-1 + && uc[i+1].unicode() >= 0xdc00 && uc[i+1].unicode() < 0xe000) { + logClusters[i] = glyph_pos; + logClusters[++i] = glyph_pos; + } else { + logClusters[i] = glyph_pos; + } + ++glyph_pos; + } + + // first char in a run is never (treated as) a mark + int cStart = 0; + + const bool symbolFont = false; // #### + glyphs->attributes[0].mark = false; + glyphs->attributes[0].clusterStart = true; + glyphs->attributes[0].dontPrint = (!symbolFont && uc[0].unicode() == 0x00ad) || qIsControlChar(uc[0].unicode()); + + int pos = 0; + int lastCat = QChar::category(uc[0].unicode()); + for (int i = 1; i < length; ++i) { + if (logClusters[i] == pos) + // same glyph + continue; + ++pos; + while (pos < logClusters[i]) { + glyphs[pos].attributes = glyphs[pos-1].attributes; + ++pos; + } + // hide soft-hyphens by default + if ((!symbolFont && uc[i].unicode() == 0x00ad) || qIsControlChar(uc[i].unicode())) + glyphs->attributes[pos].dontPrint = true; + const QUnicodeTables::Properties *prop = QUnicodeTables::properties(uc[i].unicode()); + int cat = prop->category; + if (cat != QChar::Mark_NonSpacing) { + glyphs->attributes[pos].mark = false; + glyphs->attributes[pos].clusterStart = true; + glyphs->attributes[pos].combiningClass = 0; + cStart = logClusters[i]; + } else { + int cmb = prop->combiningClass; + + if (cmb == 0) { + // Fix 0 combining classes + if ((uc[pos].unicode() & 0xff00) == 0x0e00) { + // thai or lao + unsigned char col = uc[pos].cell(); + if (col == 0x31 || + col == 0x34 || + col == 0x35 || + col == 0x36 || + col == 0x37 || + col == 0x47 || + col == 0x4c || + col == 0x4d || + col == 0x4e) { + cmb = QChar::Combining_AboveRight; + } else if (col == 0xb1 || + col == 0xb4 || + col == 0xb5 || + col == 0xb6 || + col == 0xb7 || + col == 0xbb || + col == 0xcc || + col == 0xcd) { + cmb = QChar::Combining_Above; + } else if (col == 0xbc) { + cmb = QChar::Combining_Below; + } + } + } + + glyphs->attributes[pos].mark = true; + glyphs->attributes[pos].clusterStart = false; + glyphs->attributes[pos].combiningClass = cmb; + logClusters[i] = cStart; + glyphs->advances_x[pos] = 0; + glyphs->advances_y[pos] = 0; + } + + // one gets an inter character justification point if the current char is not a non spacing mark. + // as then the current char belongs to the last one and one gets a space justification point + // after the space char. + if (lastCat == QChar::Separator_Space) + glyphs->attributes[pos-1].justification = HB_Space; + else if (cat != QChar::Mark_NonSpacing) + glyphs->attributes[pos-1].justification = HB_Character; + else + glyphs->attributes[pos-1].justification = HB_NoJustification; + + lastCat = cat; + } + pos = logClusters[length-1]; + if (lastCat == QChar::Separator_Space) + glyphs->attributes[pos].justification = HB_Space; + else + glyphs->attributes[pos].justification = HB_Character; +} + +void QTextEngine::shapeTextWithCE(int item) const +{ + QScriptItem &si = layoutData->items[item]; + si.glyph_data_offset = layoutData->used; + + QFontEngine *fe = fontEngine(si, &si.ascent, &si.descent, &si.leading); + + QTextEngine::ShaperFlags flags; + if (si.analysis.bidiLevel % 2) + flags |= RightToLeft; + if (option.useDesignMetrics()) + flags |= DesignMetrics; + + // pre-initialize char attributes + if (! attributes()) + return; + + const int len = length(item); + int num_glyphs = length(item); + const QChar *str = layoutData->string.unicode() + si.position; + ushort upperCased[256]; + if (hasCaseChange(si)) { + ushort *uc = upperCased; + if (len > 256) + uc = new ushort[len]; + for (int i = 0; i < len; ++i) { + if(si.analysis.flags == QScriptAnalysis::Lowercase) + uc[i] = str[i].toLower().unicode(); + else + uc[i] = str[i].toUpper().unicode(); + } + str = reinterpret_cast<const QChar *>(uc); + } + + while (true) { + if (! ensureSpace(num_glyphs)) { + // If str is converted to uppercase/lowercase form with a new buffer, + // we need to delete that buffer before return for error + const ushort *uc = reinterpret_cast<const ushort *>(str); + if (hasCaseChange(si) && uc != upperCased) + delete [] uc; + return; + } + num_glyphs = layoutData->glyphLayout.numGlyphs - layoutData->used; + + QGlyphLayout g = availableGlyphs(&si); + unsigned short *log_clusters = logClusters(&si); + + if (fe->stringToCMap(str, + len, + &g, + &num_glyphs, + flags)) { + heuristicSetGlyphAttributes(str, len, &g, log_clusters, num_glyphs); + break; + } + } + + si.num_glyphs = num_glyphs; + + layoutData->used += si.num_glyphs; + + const ushort *uc = reinterpret_cast<const ushort *>(str); + if (hasCaseChange(si) && uc != upperCased) + delete [] uc; +} +#endif + +static inline void moveGlyphData(const QGlyphLayout &destination, const QGlyphLayout &source, int num) +{ + if (num > 0 && destination.glyphs != source.glyphs) { + memmove(destination.glyphs, source.glyphs, num * sizeof(HB_Glyph)); + memmove(destination.attributes, source.attributes, num * sizeof(HB_GlyphAttributes)); + memmove(destination.advances_x, source.advances_x, num * sizeof(HB_Fixed)); + memmove(destination.offsets, source.offsets, num * sizeof(HB_FixedPoint)); + } +} + +/// take the item from layoutData->items and +void QTextEngine::shapeTextWithHarfbuzz(int item) const +{ + Q_ASSERT(sizeof(HB_Fixed) == sizeof(QFixed)); + Q_ASSERT(sizeof(HB_FixedPoint) == sizeof(QFixedPoint)); + + QScriptItem &si = layoutData->items[item]; + + si.glyph_data_offset = layoutData->used; + + QFontEngine *font = fontEngine(si, &si.ascent, &si.descent, &si.leading); + + bool kerningEnabled = this->font(si).d->kerning; + + HB_ShaperItem entire_shaper_item; + qMemSet(&entire_shaper_item, 0, sizeof(entire_shaper_item)); + entire_shaper_item.string = reinterpret_cast<const HB_UChar16 *>(layoutData->string.constData()); + entire_shaper_item.stringLength = layoutData->string.length(); + entire_shaper_item.item.script = (HB_Script)si.analysis.script; + entire_shaper_item.item.pos = si.position; + entire_shaper_item.item.length = length(item); + entire_shaper_item.item.bidiLevel = si.analysis.bidiLevel; + + HB_UChar16 upperCased[256]; // XXX what about making this 4096, so we don't have to extend it ever. + if (hasCaseChange(si)) { + HB_UChar16 *uc = upperCased; + if (entire_shaper_item.item.length > 256) + uc = new HB_UChar16[entire_shaper_item.item.length]; + for (uint i = 0; i < entire_shaper_item.item.length; ++i) { + if(si.analysis.flags == QScriptAnalysis::Lowercase) + uc[i] = QChar::toLower(entire_shaper_item.string[si.position + i]); + else + uc[i] = QChar::toUpper(entire_shaper_item.string[si.position + i]); + } + entire_shaper_item.item.pos = 0; + entire_shaper_item.string = uc; + entire_shaper_item.stringLength = entire_shaper_item.item.length; + } + + entire_shaper_item.shaperFlags = 0; + if (!kerningEnabled) + entire_shaper_item.shaperFlags |= HB_ShaperFlag_NoKerning; + if (option.useDesignMetrics()) + entire_shaper_item.shaperFlags |= HB_ShaperFlag_UseDesignMetrics; + + entire_shaper_item.num_glyphs = qMax(layoutData->glyphLayout.numGlyphs - layoutData->used, int(entire_shaper_item.item.length)); + if (! ensureSpace(entire_shaper_item.num_glyphs)) { + if (hasCaseChange(si)) + delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string); + return; + } + QGlyphLayout initialGlyphs = availableGlyphs(&si).mid(0, entire_shaper_item.num_glyphs); + + if (!stringToGlyphs(&entire_shaper_item, &initialGlyphs, font)) { + if (! ensureSpace(entire_shaper_item.num_glyphs)) { + if (hasCaseChange(si)) + delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string); + return; + } + initialGlyphs = availableGlyphs(&si).mid(0, entire_shaper_item.num_glyphs); + + if (!stringToGlyphs(&entire_shaper_item, &initialGlyphs, font)) { + // ############ if this happens there's a bug in the fontengine + if (hasCaseChange(si) && entire_shaper_item.string != upperCased) + delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string); + return; + } + } + + // split up the item into parts that come from different font engines. + QVarLengthArray<int> itemBoundaries(2); + // k * 2 entries, array[k] == index in string, array[k + 1] == index in glyphs + itemBoundaries[0] = entire_shaper_item.item.pos; + itemBoundaries[1] = 0; + + if (font->type() == QFontEngine::Multi) { + uint lastEngine = 0; + int charIdx = entire_shaper_item.item.pos; + const int stringEnd = charIdx + entire_shaper_item.item.length; + for (quint32 i = 0; i < entire_shaper_item.num_glyphs; ++i, ++charIdx) { + uint engineIdx = initialGlyphs.glyphs[i] >> 24; + if (engineIdx != lastEngine && i > 0) { + itemBoundaries.append(charIdx); + itemBoundaries.append(i); + } + lastEngine = engineIdx; + if (HB_IsHighSurrogate(entire_shaper_item.string[charIdx]) + && charIdx < stringEnd - 1 + && HB_IsLowSurrogate(entire_shaper_item.string[charIdx + 1])) + ++charIdx; + } + } + + + + int remaining_glyphs = entire_shaper_item.num_glyphs; + int glyph_pos = 0; + // for each item shape using harfbuzz and store the results in our layoutData's glyphs array. + for (int k = 0; k < itemBoundaries.size(); k += 2) { // for the +2, see the comment at the definition of itemBoundaries + + HB_ShaperItem shaper_item = entire_shaper_item; + + shaper_item.item.pos = itemBoundaries[k]; + if (k < itemBoundaries.size() - 3) { + shaper_item.item.length = itemBoundaries[k + 2] - shaper_item.item.pos; + shaper_item.num_glyphs = itemBoundaries[k + 3] - itemBoundaries[k + 1]; + } else { // last combo in the list, avoid out of bounds access. + shaper_item.item.length -= shaper_item.item.pos - entire_shaper_item.item.pos; + shaper_item.num_glyphs -= itemBoundaries[k + 1]; + } + shaper_item.initialGlyphCount = shaper_item.num_glyphs; + if (shaper_item.num_glyphs < shaper_item.item.length) + shaper_item.num_glyphs = shaper_item.item.length; + + QFontEngine *actualFontEngine = font; + uint engineIdx = 0; + if (font->type() == QFontEngine::Multi) { + engineIdx = uint(availableGlyphs(&si).glyphs[glyph_pos] >> 24); + + actualFontEngine = static_cast<QFontEngineMulti *>(font)->engine(engineIdx); + } + + shaper_item.font = actualFontEngine->harfbuzzFont(); + shaper_item.face = actualFontEngine->harfbuzzFace(); + + shaper_item.glyphIndicesPresent = true; + + remaining_glyphs -= shaper_item.initialGlyphCount; + + do { + if (! ensureSpace(glyph_pos + shaper_item.num_glyphs + remaining_glyphs)) { + if (hasCaseChange(si)) + delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string); + return; + } + + const QGlyphLayout g = availableGlyphs(&si).mid(glyph_pos); + if (shaper_item.num_glyphs > shaper_item.item.length) + moveGlyphData(g.mid(shaper_item.num_glyphs), g.mid(shaper_item.initialGlyphCount), remaining_glyphs); + + shaper_item.glyphs = g.glyphs; + shaper_item.attributes = g.attributes; + shaper_item.advances = reinterpret_cast<HB_Fixed *>(g.advances_x); + shaper_item.offsets = reinterpret_cast<HB_FixedPoint *>(g.offsets); + + if (shaper_item.glyphIndicesPresent) { + for (hb_uint32 i = 0; i < shaper_item.initialGlyphCount; ++i) + shaper_item.glyphs[i] &= 0x00ffffff; + } + + shaper_item.log_clusters = logClusters(&si) + shaper_item.item.pos - entire_shaper_item.item.pos; + +// qDebug(" .. num_glyphs=%d, used=%d, item.num_glyphs=%d", num_glyphs, used, shaper_item.num_glyphs); + } while (!qShapeItem(&shaper_item)); // this does the actual shaping via harfbuzz. + + QGlyphLayout g = availableGlyphs(&si).mid(glyph_pos, shaper_item.num_glyphs); + moveGlyphData(g.mid(shaper_item.num_glyphs), g.mid(shaper_item.initialGlyphCount), remaining_glyphs); + + for (hb_uint32 i = 0; i < shaper_item.num_glyphs; ++i) + g.glyphs[i] = g.glyphs[i] | (engineIdx << 24); + + for (hb_uint32 i = 0; i < shaper_item.item.length; ++i) + shaper_item.log_clusters[i] += glyph_pos; + + if (kerningEnabled && !shaper_item.kerning_applied) + font->doKerning(&g, option.useDesignMetrics() ? QFlag(QTextEngine::DesignMetrics) : QFlag(0)); + + glyph_pos += shaper_item.num_glyphs; + } + +// qDebug(" -> item: script=%d num_glyphs=%d", shaper_item.script, shaper_item.num_glyphs); + si.num_glyphs = glyph_pos; + + layoutData->used += si.num_glyphs; + + if (hasCaseChange(si) && entire_shaper_item.string != upperCased) + delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string); +} + +static void init(QTextEngine *e) +{ + e->ignoreBidi = false; + e->cacheGlyphs = false; + e->forceJustification = false; + + e->layoutData = 0; + + e->minWidth = 0; + e->maxWidth = 0; + + e->underlinePositions = 0; + e->specialData = 0; + e->stackEngine = false; +} + +QTextEngine::QTextEngine() +{ + init(this); +} + +QTextEngine::QTextEngine(const QString &str, const QFont &f) + : text(str), + fnt(f) +{ + init(this); +} + +QTextEngine::~QTextEngine() +{ + if (!stackEngine) + delete layoutData; + delete specialData; +} + +const HB_CharAttributes *QTextEngine::attributes() const +{ + if (layoutData && layoutData->haveCharAttributes) + return (HB_CharAttributes *) layoutData->memory; + + itemize(); + if (! ensureSpace(layoutData->string.length())) + return NULL; + + QVarLengthArray<HB_ScriptItem> hbScriptItems(layoutData->items.size()); + + for (int i = 0; i < layoutData->items.size(); ++i) { + const QScriptItem &si = layoutData->items[i]; + hbScriptItems[i].pos = si.position; + hbScriptItems[i].length = length(i); + hbScriptItems[i].bidiLevel = si.analysis.bidiLevel; + hbScriptItems[i].script = (HB_Script)si.analysis.script; + } + + qGetCharAttributes(reinterpret_cast<const HB_UChar16 *>(layoutData->string.constData()), + layoutData->string.length(), + hbScriptItems.data(), hbScriptItems.size(), + (HB_CharAttributes *)layoutData->memory); + + + layoutData->haveCharAttributes = true; + return (HB_CharAttributes *) layoutData->memory; +} + +void QTextEngine::shape(int item) const +{ + if (layoutData->items[item].analysis.flags == QScriptAnalysis::Object) { + ensureSpace(1); + if (block.docHandle()) { + QTextFormat format = formats()->format(formatIndex(&layoutData->items[item])); + docLayout()->resizeInlineObject(QTextInlineObject(item, const_cast<QTextEngine *>(this)), + layoutData->items[item].position + block.position(), format); + } + } else if (layoutData->items[item].analysis.flags == QScriptAnalysis::Tab) { + // set up at least the ascent/descent/leading of the script item for the tab + fontEngine(layoutData->items[item], + &layoutData->items[item].ascent, + &layoutData->items[item].descent, + &layoutData->items[item].leading); + } else { + shapeText(item); + } +} + +static inline void releaseCachedFontEngine(QFontEngine *fontEngine) +{ + if (fontEngine) { + fontEngine->ref.deref(); + if (fontEngine->cache_count == 0 && fontEngine->ref == 0) + delete fontEngine; + } +} + +void QTextEngine::invalidate() +{ + freeMemory(); + minWidth = 0; + maxWidth = 0; + if (specialData) + specialData->resolvedFormatIndices.clear(); + + releaseCachedFontEngine(feCache.prevFontEngine); + releaseCachedFontEngine(feCache.prevScaledFontEngine); + feCache.reset(); +} + +void QTextEngine::clearLineData() +{ + lines.clear(); +} + +void QTextEngine::validate() const +{ + if (layoutData) + return; + layoutData = new LayoutData(); + if (block.docHandle()) { + layoutData->string = block.text(); + if (option.flags() & QTextOption::ShowLineAndParagraphSeparators) + layoutData->string += QLatin1Char(block.next().isValid() ? 0xb6 : 0x20); + } else { + layoutData->string = text; + } + if (specialData && specialData->preeditPosition != -1) + layoutData->string.insert(specialData->preeditPosition, specialData->preeditText); +} + +void QTextEngine::itemize() const +{ + validate(); + if (layoutData->items.size()) + return; + + int length = layoutData->string.length(); + if (!length) + return; +#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA) + // ATSUI requires RTL flags to correctly identify the character stops. + bool ignore = false; +#else + bool ignore = ignoreBidi; +#endif + + bool rtl = isRightToLeft(); + + if (!ignore && !rtl) { + ignore = true; + const QChar *start = layoutData->string.unicode(); + const QChar * const end = start + length; + while (start < end) { + if (start->unicode() >= 0x590) { + ignore = false; + break; + } + ++start; + } + } + + QVarLengthArray<QScriptAnalysis, 4096> scriptAnalysis(length); + QScriptAnalysis *analysis = scriptAnalysis.data(); + + QBidiControl control(rtl); + + if (ignore) { + memset(analysis, 0, length*sizeof(QScriptAnalysis)); + if (option.textDirection() == Qt::RightToLeft) { + for (int i = 0; i < length; ++i) + analysis[i].bidiLevel = 1; + layoutData->hasBidi = true; + } + } else { + layoutData->hasBidi = bidiItemize(const_cast<QTextEngine *>(this), analysis, control); + } + + const ushort *uc = reinterpret_cast<const ushort *>(layoutData->string.unicode()); + const ushort *e = uc + length; + int lastScript = QUnicodeTables::Common; + while (uc < e) { + int script = QUnicodeTables::script(*uc); + if (script == QUnicodeTables::Inherited) + script = lastScript; + analysis->flags = QScriptAnalysis::None; + if (*uc == QChar::ObjectReplacementCharacter) { + if (analysis->bidiLevel % 2) + --analysis->bidiLevel; + analysis->script = QUnicodeTables::Common; + analysis->flags = QScriptAnalysis::Object; + } else if (*uc == QChar::LineSeparator) { + if (analysis->bidiLevel % 2) + --analysis->bidiLevel; + analysis->script = QUnicodeTables::Common; + analysis->flags = QScriptAnalysis::LineOrParagraphSeparator; + if (option.flags() & QTextOption::ShowLineAndParagraphSeparators) + *const_cast<ushort*>(uc) = 0x21B5; // visual line separator + } else if (*uc == 9) { + analysis->script = QUnicodeTables::Common; + analysis->flags = QScriptAnalysis::Tab; + analysis->bidiLevel = control.baseLevel(); + } else if ((*uc == 32 || *uc == QChar::Nbsp) + && (option.flags() & QTextOption::ShowTabsAndSpaces)) { + analysis->script = QUnicodeTables::Common; + analysis->flags = QScriptAnalysis::Space; + analysis->bidiLevel = control.baseLevel(); + } else { + analysis->script = script; + } + lastScript = analysis->script; + ++uc; + ++analysis; + } + if (option.flags() & QTextOption::ShowLineAndParagraphSeparators) { + (analysis-1)->flags = QScriptAnalysis::LineOrParagraphSeparator; // to exclude it from width + } + + Itemizer itemizer(layoutData->string, scriptAnalysis.data(), layoutData->items); + + const QTextDocumentPrivate *p = block.docHandle(); + if (p) { + SpecialData *s = specialData; + + QTextDocumentPrivate::FragmentIterator it = p->find(block.position()); + QTextDocumentPrivate::FragmentIterator end = p->find(block.position() + block.length() - 1); // -1 to omit the block separator char + int format = it.value()->format; + + int prevPosition = 0; + int position = prevPosition; + while (1) { + const QTextFragmentData * const frag = it.value(); + if (it == end || format != frag->format) { + if (s && position >= s->preeditPosition) { + position += s->preeditText.length(); + s = 0; + } + Q_ASSERT(position <= length); + itemizer.generate(prevPosition, position - prevPosition, + formats()->charFormat(format).fontCapitalization()); + if (it == end) { + if (position < length) + itemizer.generate(position, length - position, + formats()->charFormat(format).fontCapitalization()); + break; + } + format = frag->format; + prevPosition = position; + } + position += frag->size_array[0]; + ++it; + } + } else { + itemizer.generate(0, length, static_cast<QFont::Capitalization> (fnt.d->capital)); + } + + addRequiredBoundaries(); + resolveAdditionalFormats(); +} + +bool QTextEngine::isRightToLeft() const +{ + switch (option.textDirection()) { + case Qt::LeftToRight: + return false; + case Qt::RightToLeft: + return true; + default: + break; + } + // this places the cursor in the right position depending on the keyboard layout + if (layoutData->string.isEmpty()) + return QApplication::keyboardInputDirection() == Qt::RightToLeft; + return layoutData->string.isRightToLeft(); +} + + +int QTextEngine::findItem(int strPos) const +{ + itemize(); + int left = 0; + int right = layoutData->items.size()-1; + while(left <= right) { + int middle = ((right-left)/2)+left; + if (strPos > layoutData->items[middle].position) + left = middle+1; + else if(strPos < layoutData->items[middle].position) + right = middle-1; + else { + return middle; + } + } + return right; +} + +QFixed QTextEngine::width(int from, int len) const +{ + itemize(); + + QFixed w = 0; + +// qDebug("QTextEngine::width(from = %d, len = %d), numItems=%d, strleng=%d", from, len, items.size(), string.length()); + for (int i = 0; i < layoutData->items.size(); i++) { + const QScriptItem *si = layoutData->items.constData() + i; + int pos = si->position; + int ilen = length(i); +// qDebug("item %d: from %d len %d", i, pos, ilen); + if (pos >= from + len) + break; + if (pos + ilen > from) { + if (!si->num_glyphs) + shape(i); + + if (si->analysis.flags == QScriptAnalysis::Object) { + w += si->width; + continue; + } else if (si->analysis.flags == QScriptAnalysis::Tab) { + w += calculateTabWidth(i, w); + continue; + } + + + QGlyphLayout glyphs = shapedGlyphs(si); + unsigned short *logClusters = this->logClusters(si); + +// fprintf(stderr, " logclusters:"); +// for (int k = 0; k < ilen; k++) +// fprintf(stderr, " %d", logClusters[k]); +// fprintf(stderr, "\n"); + // do the simple thing for now and give the first glyph in a cluster the full width, all other ones 0. + int charFrom = from - pos; + if (charFrom < 0) + charFrom = 0; + int glyphStart = logClusters[charFrom]; + if (charFrom > 0 && logClusters[charFrom-1] == glyphStart) + while (charFrom < ilen && logClusters[charFrom] == glyphStart) + charFrom++; + if (charFrom < ilen) { + glyphStart = logClusters[charFrom]; + int charEnd = from + len - 1 - pos; + if (charEnd >= ilen) + charEnd = ilen-1; + int glyphEnd = logClusters[charEnd]; + while (charEnd < ilen && logClusters[charEnd] == glyphEnd) + charEnd++; + glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd]; + +// qDebug("char: start=%d end=%d / glyph: start = %d, end = %d", charFrom, charEnd, glyphStart, glyphEnd); + for (int i = glyphStart; i < glyphEnd; i++) + w += glyphs.advances_x[i] * !glyphs.attributes[i].dontPrint; + } + } + } +// qDebug(" --> w= %d ", w); + return w; +} + +glyph_metrics_t QTextEngine::boundingBox(int from, int len) const +{ + itemize(); + + glyph_metrics_t gm; + + for (int i = 0; i < layoutData->items.size(); i++) { + const QScriptItem *si = layoutData->items.constData() + i; + + int pos = si->position; + int ilen = length(i); + if (pos > from + len) + break; + if (pos + ilen > from) { + if (!si->num_glyphs) + shape(i); + + if (si->analysis.flags == QScriptAnalysis::Object) { + gm.width += si->width; + continue; + } else if (si->analysis.flags == QScriptAnalysis::Tab) { + gm.width += calculateTabWidth(i, gm.width); + continue; + } + + unsigned short *logClusters = this->logClusters(si); + QGlyphLayout glyphs = shapedGlyphs(si); + + // do the simple thing for now and give the first glyph in a cluster the full width, all other ones 0. + int charFrom = from - pos; + if (charFrom < 0) + charFrom = 0; + int glyphStart = logClusters[charFrom]; + if (charFrom > 0 && logClusters[charFrom-1] == glyphStart) + while (charFrom < ilen && logClusters[charFrom] == glyphStart) + charFrom++; + if (charFrom < ilen) { + QFontEngine *fe = fontEngine(*si); + glyphStart = logClusters[charFrom]; + int charEnd = from + len - 1 - pos; + if (charEnd >= ilen) + charEnd = ilen-1; + int glyphEnd = logClusters[charEnd]; + while (charEnd < ilen && logClusters[charEnd] == glyphEnd) + charEnd++; + glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd]; + if (glyphStart <= glyphEnd ) { + glyph_metrics_t m = fe->boundingBox(glyphs.mid(glyphStart, glyphEnd - glyphStart)); + gm.x = qMin(gm.x, m.x + gm.xoff); + gm.y = qMin(gm.y, m.y + gm.yoff); + gm.width = qMax(gm.width, m.width+gm.xoff); + gm.height = qMax(gm.height, m.height+gm.yoff); + gm.xoff += m.xoff; + gm.yoff += m.yoff; + } + } + } + } + return gm; +} + +glyph_metrics_t QTextEngine::tightBoundingBox(int from, int len) const +{ + itemize(); + + glyph_metrics_t gm; + + for (int i = 0; i < layoutData->items.size(); i++) { + const QScriptItem *si = layoutData->items.constData() + i; + int pos = si->position; + int ilen = length(i); + if (pos > from + len) + break; + if (pos + len > from) { + if (!si->num_glyphs) + shape(i); + unsigned short *logClusters = this->logClusters(si); + QGlyphLayout glyphs = shapedGlyphs(si); + + // do the simple thing for now and give the first glyph in a cluster the full width, all other ones 0. + int charFrom = from - pos; + if (charFrom < 0) + charFrom = 0; + int glyphStart = logClusters[charFrom]; + if (charFrom > 0 && logClusters[charFrom-1] == glyphStart) + while (charFrom < ilen && logClusters[charFrom] == glyphStart) + charFrom++; + if (charFrom < ilen) { + glyphStart = logClusters[charFrom]; + int charEnd = from + len - 1 - pos; + if (charEnd >= ilen) + charEnd = ilen-1; + int glyphEnd = logClusters[charEnd]; + while (charEnd < ilen && logClusters[charEnd] == glyphEnd) + charEnd++; + glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd]; + if (glyphStart <= glyphEnd ) { + QFontEngine *fe = fontEngine(*si); + glyph_metrics_t m = fe->tightBoundingBox(glyphs.mid(glyphStart, glyphEnd - glyphStart)); + gm.x = qMin(gm.x, m.x + gm.xoff); + gm.y = qMin(gm.y, m.y + gm.yoff); + gm.width = qMax(gm.width, m.width+gm.xoff); + gm.height = qMax(gm.height, m.height+gm.yoff); + gm.xoff += m.xoff; + gm.yoff += m.yoff; + } + } + } + } + return gm; +} + +QFont QTextEngine::font(const QScriptItem &si) const +{ + QFont font = fnt; + if (hasFormats()) { + QTextCharFormat f = format(&si); + font = f.font(); + + if (block.docHandle() && block.docHandle()->layout()) { + // Make sure we get the right dpi on printers + QPaintDevice *pdev = block.docHandle()->layout()->paintDevice(); + if (pdev) + font = QFont(font, pdev); + } else { + font = font.resolve(fnt); + } + QTextCharFormat::VerticalAlignment valign = f.verticalAlignment(); + if (valign == QTextCharFormat::AlignSuperScript || valign == QTextCharFormat::AlignSubScript) { + if (font.pointSize() != -1) + font.setPointSize((font.pointSize() * 2) / 3); + else + font.setPixelSize((font.pixelSize() * 2) / 3); + } + } + + if (si.analysis.flags == QScriptAnalysis::SmallCaps) + font = font.d->smallCapsFont(); + + return font; +} + +QTextEngine::FontEngineCache::FontEngineCache() +{ + reset(); +} + +//we cache the previous results of this function, as calling it numerous times with the same effective +//input is common (and hard to cache at a higher level) +QFontEngine *QTextEngine::fontEngine(const QScriptItem &si, QFixed *ascent, QFixed *descent, QFixed *leading) const +{ + QFontEngine *engine = 0; + QFontEngine *scaledEngine = 0; + int script = si.analysis.script; + + QFont font = fnt; + if (hasFormats()) { + if (feCache.prevFontEngine && feCache.prevPosition == si.position && feCache.prevLength == length(&si) && feCache.prevScript == script) { + engine = feCache.prevFontEngine; + scaledEngine = feCache.prevScaledFontEngine; + } else { + QTextCharFormat f = format(&si); + font = f.font(); + + if (block.docHandle() && block.docHandle()->layout()) { + // Make sure we get the right dpi on printers + QPaintDevice *pdev = block.docHandle()->layout()->paintDevice(); + if (pdev) + font = QFont(font, pdev); + } else { + font = font.resolve(fnt); + } + engine = font.d->engineForScript(script); + QTextCharFormat::VerticalAlignment valign = f.verticalAlignment(); + if (valign == QTextCharFormat::AlignSuperScript || valign == QTextCharFormat::AlignSubScript) { + if (font.pointSize() != -1) + font.setPointSize((font.pointSize() * 2) / 3); + else + font.setPixelSize((font.pixelSize() * 2) / 3); + scaledEngine = font.d->engineForScript(script); + } + feCache.prevFontEngine = engine; + if (engine) + engine->ref.ref(); + feCache.prevScaledFontEngine = scaledEngine; + if (scaledEngine) + scaledEngine->ref.ref(); + feCache.prevScript = script; + feCache.prevPosition = si.position; + feCache.prevLength = length(&si); + } + } else { + if (feCache.prevFontEngine && feCache.prevScript == script && feCache.prevPosition == -1) + engine = feCache.prevFontEngine; + else { + engine = font.d->engineForScript(script); + feCache.prevFontEngine = engine; + if (engine) + engine->ref.ref(); + feCache.prevScript = script; + feCache.prevPosition = -1; + feCache.prevLength = -1; + feCache.prevScaledFontEngine = 0; + } + } + + if (si.analysis.flags == QScriptAnalysis::SmallCaps) { + QFontPrivate *p = font.d->smallCapsFontPrivate(); + scaledEngine = p->engineForScript(script); + } + + if (ascent) { + *ascent = engine->ascent(); + *descent = engine->descent(); + *leading = engine->leading(); + } + + if (scaledEngine) + return scaledEngine; + return engine; +} + +struct QJustificationPoint { + int type; + QFixed kashidaWidth; + QGlyphLayout glyph; + QFontEngine *fontEngine; +}; + +Q_DECLARE_TYPEINFO(QJustificationPoint, Q_PRIMITIVE_TYPE); + +static void set(QJustificationPoint *point, int type, const QGlyphLayout &glyph, QFontEngine *fe) +{ + point->type = type; + point->glyph = glyph; + point->fontEngine = fe; + + if (type >= HB_Arabic_Normal) { + QChar ch(0x640); // Kashida character + QGlyphLayoutArray<8> glyphs; + int nglyphs = 7; + fe->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0); + if (glyphs.glyphs[0] && glyphs.advances_x[0] != 0) { + point->kashidaWidth = glyphs.advances_x[0]; + } else { + point->type = HB_NoJustification; + point->kashidaWidth = 0; + } + } +} + + +void QTextEngine::justify(const QScriptLine &line) +{ +// qDebug("justify: line.gridfitted = %d, line.justified=%d", line.gridfitted, line.justified); + if (line.gridfitted && line.justified) + return; + + if (!line.gridfitted) { + // redo layout in device metrics, then adjust + const_cast<QScriptLine &>(line).gridfitted = true; + } + + if ((option.alignment() & Qt::AlignHorizontal_Mask) != Qt::AlignJustify) + return; + + itemize(); + + if (!forceJustification) { + int end = line.from + (int)line.length; + if (end == layoutData->string.length()) + return; // no justification at end of paragraph + if (end && layoutData->items[findItem(end-1)].analysis.flags == QScriptAnalysis::LineOrParagraphSeparator) + return; // no justification at the end of an explicitly separated line + } + + // justify line + int maxJustify = 0; + + // don't include trailing white spaces when doing justification + int line_length = line.length; + const HB_CharAttributes *a = attributes(); + if (! a) + return; + a += line.from; + while (line_length && a[line_length-1].whiteSpace) + --line_length; + // subtract one char more, as we can't justfy after the last character + --line_length; + + if (!line_length) + return; + + int firstItem = findItem(line.from); + int nItems = findItem(line.from + line_length - 1) - firstItem + 1; + + QVarLengthArray<QJustificationPoint> justificationPoints; + int nPoints = 0; +// qDebug("justifying from %d len %d, firstItem=%d, nItems=%d (%s)", line.from, line_length, firstItem, nItems, layoutData->string.mid(line.from, line_length).toUtf8().constData()); + QFixed minKashida = 0x100000; + + // we need to do all shaping before we go into the next loop, as we there + // store pointers to the glyph data that could get reallocated by the shaping + // process. + for (int i = 0; i < nItems; ++i) { + QScriptItem &si = layoutData->items[firstItem + i]; + if (!si.num_glyphs) + shape(firstItem + i); + } + + for (int i = 0; i < nItems; ++i) { + QScriptItem &si = layoutData->items[firstItem + i]; + + int kashida_type = HB_Arabic_Normal; + int kashida_pos = -1; + + int start = qMax(line.from - si.position, 0); + int end = qMin(line.from + line_length - (int)si.position, length(firstItem+i)); + + unsigned short *log_clusters = logClusters(&si); + + int gs = log_clusters[start]; + int ge = (end == length(firstItem+i) ? si.num_glyphs : log_clusters[end]); + + const QGlyphLayout g = shapedGlyphs(&si); + + for (int i = gs; i < ge; ++i) { + g.justifications[i].type = QGlyphJustification::JustifyNone; + g.justifications[i].nKashidas = 0; + g.justifications[i].space_18d6 = 0; + + justificationPoints.resize(nPoints+3); + int justification = g.attributes[i].justification; + + switch(justification) { + case HB_NoJustification: + break; + case HB_Space : + // fall through + case HB_Arabic_Space : + if (kashida_pos >= 0) { +// qDebug("kashida position at %d in word", kashida_pos); + set(&justificationPoints[nPoints], kashida_type, g.mid(kashida_pos), fontEngine(si)); + if (justificationPoints[nPoints].kashidaWidth > 0) { + minKashida = qMin(minKashida, justificationPoints[nPoints].kashidaWidth); + maxJustify = qMax(maxJustify, justificationPoints[nPoints].type); + ++nPoints; + } + } + kashida_pos = -1; + kashida_type = HB_Arabic_Normal; + // fall through + case HB_Character : + set(&justificationPoints[nPoints++], justification, g.mid(i), fontEngine(si)); + maxJustify = qMax(maxJustify, justification); + break; + case HB_Arabic_Normal : + case HB_Arabic_Waw : + case HB_Arabic_BaRa : + case HB_Arabic_Alef : + case HB_Arabic_HaaDal : + case HB_Arabic_Seen : + case HB_Arabic_Kashida : + if (justification >= kashida_type) { + kashida_pos = i; + kashida_type = justification; + } + } + } + if (kashida_pos >= 0) { + set(&justificationPoints[nPoints], kashida_type, g.mid(kashida_pos), fontEngine(si)); + if (justificationPoints[nPoints].kashidaWidth > 0) { + minKashida = qMin(minKashida, justificationPoints[nPoints].kashidaWidth); + maxJustify = qMax(maxJustify, justificationPoints[nPoints].type); + ++nPoints; + } + } + } + + QFixed need = line.width - line.textWidth; + if (need < 0) { + // line overflows already! + const_cast<QScriptLine &>(line).justified = true; + return; + } + +// qDebug("doing justification: textWidth=%x, requested=%x, maxJustify=%d", line.textWidth.value(), line.width.value(), maxJustify); +// qDebug(" minKashida=%f, need=%f", minKashida.toReal(), need.toReal()); + + // distribute in priority order + if (maxJustify >= HB_Arabic_Normal) { + while (need >= minKashida) { + for (int type = maxJustify; need >= minKashida && type >= HB_Arabic_Normal; --type) { + for (int i = 0; need >= minKashida && i < nPoints; ++i) { + if (justificationPoints[i].type == type && justificationPoints[i].kashidaWidth <= need) { + justificationPoints[i].glyph.justifications->nKashidas++; + // ############ + justificationPoints[i].glyph.justifications->space_18d6 += justificationPoints[i].kashidaWidth.value(); + need -= justificationPoints[i].kashidaWidth; +// qDebug("adding kashida type %d with width %x, neednow %x", type, justificationPoints[i].kashidaWidth, need.value()); + } + } + } + } + } + Q_ASSERT(need >= 0); + if (!need) + goto end; + + maxJustify = qMin(maxJustify, (int)HB_Space); + for (int type = maxJustify; need != 0 && type > 0; --type) { + int n = 0; + for (int i = 0; i < nPoints; ++i) { + if (justificationPoints[i].type == type) + ++n; + } +// qDebug("number of points for justification type %d: %d", type, n); + + + if (!n) + continue; + + for (int i = 0; i < nPoints; ++i) { + if (justificationPoints[i].type == type) { + QFixed add = need/n; +// qDebug("adding %x to glyph %x", add.value(), justificationPoints[i].glyph->glyph); + justificationPoints[i].glyph.justifications[0].space_18d6 = add.value(); + need -= add; + --n; + } + } + + Q_ASSERT(!need); + } + end: + const_cast<QScriptLine &>(line).justified = true; +} + +void QScriptLine::setDefaultHeight(QTextEngine *eng) +{ + QFont f; + QFontEngine *e; + + if (eng->block.docHandle() && eng->block.docHandle()->layout()) { + f = eng->block.charFormat().font(); + // Make sure we get the right dpi on printers + QPaintDevice *pdev = eng->block.docHandle()->layout()->paintDevice(); + if (pdev) + f = QFont(f, pdev); + e = f.d->engineForScript(QUnicodeTables::Common); + } else { + e = eng->fnt.d->engineForScript(QUnicodeTables::Common); + } + + QFixed other_ascent = e->ascent(); + QFixed other_descent = e->descent(); + QFixed other_leading = e->leading(); + leading = qMax(leading + ascent, other_leading + other_ascent) - qMax(ascent, other_ascent); + ascent = qMax(ascent, other_ascent); + descent = qMax(descent, other_descent); +} + +QTextEngine::LayoutData::LayoutData() +{ + memory = 0; + allocated = 0; + memory_on_stack = false; + used = 0; + hasBidi = false; + layoutState = LayoutEmpty; + haveCharAttributes = false; + logClustersPtr = 0; + available_glyphs = 0; +} + +QTextEngine::LayoutData::LayoutData(const QString &str, void **stack_memory, int _allocated) + : string(str) +{ + allocated = _allocated; + + int space_charAttributes = sizeof(HB_CharAttributes)*string.length()/sizeof(void*) + 1; + int space_logClusters = sizeof(unsigned short)*string.length()/sizeof(void*) + 1; + available_glyphs = ((int)allocated - space_charAttributes - space_logClusters)*(int)sizeof(void*)/(int)QGlyphLayout::spaceNeededForGlyphLayout(1); + + if (available_glyphs < str.length()) { + // need to allocate on the heap + allocated = 0; + + memory_on_stack = false; + memory = 0; + logClustersPtr = 0; + } else { + memory_on_stack = true; + memory = stack_memory; + logClustersPtr = (unsigned short *)(memory + space_charAttributes); + + void *m = memory + space_charAttributes + space_logClusters; + glyphLayout = QGlyphLayout(reinterpret_cast<char *>(m), str.length()); + glyphLayout.clear(); + memset(memory, 0, space_charAttributes*sizeof(void *)); + } + used = 0; + hasBidi = false; + layoutState = LayoutEmpty; + haveCharAttributes = false; +} + +QTextEngine::LayoutData::~LayoutData() +{ + if (!memory_on_stack) + free(memory); + memory = 0; +} + +bool QTextEngine::LayoutData::reallocate(int totalGlyphs) +{ + Q_ASSERT(totalGlyphs >= glyphLayout.numGlyphs); + if (memory_on_stack && available_glyphs >= totalGlyphs) { + glyphLayout.grow(glyphLayout.data(), totalGlyphs); + return true; + } + + int space_charAttributes = sizeof(HB_CharAttributes)*string.length()/sizeof(void*) + 1; + int space_logClusters = sizeof(unsigned short)*string.length()/sizeof(void*) + 1; + int space_glyphs = QGlyphLayout::spaceNeededForGlyphLayout(totalGlyphs)/sizeof(void*) + 2; + + int newAllocated = space_charAttributes + space_glyphs + space_logClusters; + // These values can be negative if the length of string/glyphs causes overflow, + // we can't layout such a long string all at once, so return false here to + // indicate there is a failure + if (space_charAttributes < 0 || space_logClusters < 0 || space_glyphs < 0 || newAllocated < allocated) { + layoutState = LayoutFailed; + return false; + } + + void **newMem = memory; + newMem = (void **)::realloc(memory_on_stack ? 0 : memory, newAllocated*sizeof(void *)); + if (!newMem) { + layoutState = LayoutFailed; + return false; + } + if (memory_on_stack) + memcpy(newMem, memory, allocated*sizeof(void *)); + memory = newMem; + memory_on_stack = false; + + void **m = memory; + m += space_charAttributes; + logClustersPtr = (unsigned short *) m; + m += space_logClusters; + + const int space_preGlyphLayout = space_charAttributes + space_logClusters; + if (allocated < space_preGlyphLayout) + memset(memory + allocated, 0, (space_preGlyphLayout - allocated)*sizeof(void *)); + + glyphLayout.grow(reinterpret_cast<char *>(m), totalGlyphs); + + allocated = newAllocated; + return true; +} + +// grow to the new size, copying the existing data to the new layout +void QGlyphLayout::grow(char *address, int totalGlyphs) +{ + QGlyphLayout oldLayout(address, numGlyphs); + QGlyphLayout newLayout(address, totalGlyphs); + + if (numGlyphs) { + // move the existing data + memmove(newLayout.attributes, oldLayout.attributes, numGlyphs * sizeof(HB_GlyphAttributes)); + memmove(newLayout.justifications, oldLayout.justifications, numGlyphs * sizeof(QGlyphJustification)); + memmove(newLayout.advances_y, oldLayout.advances_y, numGlyphs * sizeof(QFixed)); + memmove(newLayout.advances_x, oldLayout.advances_x, numGlyphs * sizeof(QFixed)); + memmove(newLayout.glyphs, oldLayout.glyphs, numGlyphs * sizeof(HB_Glyph)); + } + + // clear the new data + newLayout.clear(numGlyphs); + + *this = newLayout; +} + +void QTextEngine::freeMemory() +{ + if (!stackEngine) { + delete layoutData; + layoutData = 0; + } else { + layoutData->used = 0; + layoutData->hasBidi = false; + layoutData->layoutState = LayoutEmpty; + layoutData->haveCharAttributes = false; + } + for (int i = 0; i < lines.size(); ++i) { + lines[i].justified = 0; + lines[i].gridfitted = 0; + } +} + +int QTextEngine::formatIndex(const QScriptItem *si) const +{ + if (specialData && !specialData->resolvedFormatIndices.isEmpty()) + return specialData->resolvedFormatIndices.at(si - &layoutData->items[0]); + QTextDocumentPrivate *p = block.docHandle(); + if (!p) + return -1; + int pos = si->position; + if (specialData && si->position >= specialData->preeditPosition) { + if (si->position < specialData->preeditPosition + specialData->preeditText.length()) + pos = qMax(specialData->preeditPosition - 1, 0); + else + pos -= specialData->preeditText.length(); + } + QTextDocumentPrivate::FragmentIterator it = p->find(block.position() + pos); + return it.value()->format; +} + + +QTextCharFormat QTextEngine::format(const QScriptItem *si) const +{ + QTextCharFormat format; + const QTextFormatCollection *formats = 0; + if (block.docHandle()) { + formats = this->formats(); + format = formats->charFormat(formatIndex(si)); + } + if (specialData && specialData->resolvedFormatIndices.isEmpty()) { + int end = si->position + length(si); + for (int i = 0; i < specialData->addFormats.size(); ++i) { + const QTextLayout::FormatRange &r = specialData->addFormats.at(i); + if (r.start <= si->position && r.start + r.length >= end) { + if (!specialData->addFormatIndices.isEmpty()) + format.merge(formats->format(specialData->addFormatIndices.at(i))); + else + format.merge(r.format); + } + } + } + return format; +} + +void QTextEngine::addRequiredBoundaries() const +{ + if (specialData) { + for (int i = 0; i < specialData->addFormats.size(); ++i) { + const QTextLayout::FormatRange &r = specialData->addFormats.at(i); + setBoundary(r.start); + setBoundary(r.start + r.length); + //qDebug("adding boundaries %d %d", r.start, r.start+r.length); + } + } +} + +bool QTextEngine::atWordSeparator(int position) const +{ + const QChar c = layoutData->string.at(position); + switch (c.toLatin1()) { + case '.': + case ',': + case '?': + case '!': + case '@': + case '#': + case '$': + case ':': + case ';': + case '-': + case '<': + case '>': + case '[': + case ']': + case '(': + case ')': + case '{': + case '}': + case '=': + case '/': + case '+': + case '%': + case '&': + case '^': + case '*': + case '\'': + case '"': + case '`': + case '~': + case '|': + return true; + default: + return false; + } +} + +bool QTextEngine::atSpace(int position) const +{ + const QChar c = layoutData->string.at(position); + + return c == QLatin1Char(' ') + || c == QChar::Nbsp + || c == QChar::LineSeparator + || c == QLatin1Char('\t') + ; +} + + +void QTextEngine::indexAdditionalFormats() +{ + if (!block.docHandle()) + return; + + specialData->addFormatIndices.resize(specialData->addFormats.count()); + QTextFormatCollection * const formats = this->formats(); + + for (int i = 0; i < specialData->addFormats.count(); ++i) { + specialData->addFormatIndices[i] = formats->indexForFormat(specialData->addFormats.at(i).format); + specialData->addFormats[i].format = QTextCharFormat(); + } +} + +/* These two helper functions are used to determine whether we need to insert a ZWJ character + between the text that gets truncated and the ellipsis. This is important to get + correctly shaped results for arabic text. +*/ +static bool nextCharJoins(const QString &string, int pos) +{ + while (pos < string.length() && string.at(pos).category() == QChar::Mark_NonSpacing) + ++pos; + if (pos == string.length()) + return false; + return string.at(pos).joining() != QChar::OtherJoining; +} + +static bool prevCharJoins(const QString &string, int pos) +{ + while (pos > 0 && string.at(pos - 1).category() == QChar::Mark_NonSpacing) + --pos; + if (pos == 0) + return false; + return (string.at(pos - 1).joining() == QChar::Dual || string.at(pos - 1).joining() == QChar::Center); +} + +QString QTextEngine::elidedText(Qt::TextElideMode mode, const QFixed &width, int flags) const +{ +// qDebug() << "elidedText; available width" << width.toReal() << "text width:" << this->width(0, layoutData->string.length()).toReal(); + + if (flags & Qt::TextShowMnemonic) { + itemize(); + HB_CharAttributes *attributes = const_cast<HB_CharAttributes *>(this->attributes()); + if (!attributes) + return QString(); + for (int i = 0; i < layoutData->items.size(); ++i) { + QScriptItem &si = layoutData->items[i]; + if (!si.num_glyphs) + shape(i); + + unsigned short *logClusters = this->logClusters(&si); + QGlyphLayout glyphs = shapedGlyphs(&si); + + const int end = si.position + length(&si); + for (int i = si.position; i < end - 1; ++i) { + if (layoutData->string.at(i) == QLatin1Char('&')) { + const int gp = logClusters[i - si.position]; + glyphs.attributes[gp].dontPrint = true; + attributes[i + 1].charStop = false; + attributes[i + 1].whiteSpace = false; + attributes[i + 1].lineBreakType = HB_NoBreak; + if (layoutData->string.at(i + 1) == QLatin1Char('&')) + ++i; + } + } + } + } + + validate(); + + if (mode == Qt::ElideNone + || this->width(0, layoutData->string.length()) <= width + || layoutData->string.length() <= 1) + return layoutData->string; + + QFixed ellipsisWidth; + QString ellipsisText; + { + QChar ellipsisChar(0x2026); + + QFontEngine *fe = fnt.d->engineForScript(QUnicodeTables::Common); + + QGlyphLayoutArray<1> ellipsisGlyph; + { + QFontEngine *feForEllipsis = (fe->type() == QFontEngine::Multi) + ? static_cast<QFontEngineMulti *>(fe)->engine(0) + : fe; + + if (feForEllipsis->type() == QFontEngine::Mac) + feForEllipsis = fe; + + // the lookup can be really slow when we use XLFD fonts + if (feForEllipsis->type() != QFontEngine::XLFD + && feForEllipsis->canRender(&ellipsisChar, 1)) { + int nGlyphs = 1; + feForEllipsis->stringToCMap(&ellipsisChar, 1, &ellipsisGlyph, &nGlyphs, 0); + } + } + + if (ellipsisGlyph.glyphs[0]) { + ellipsisWidth = ellipsisGlyph.advances_x[0]; + ellipsisText = ellipsisChar; + } else { + QString dotDotDot(QLatin1String("...")); + + QGlyphLayoutArray<3> glyphs; + int nGlyphs = 3; + if (!fe->stringToCMap(dotDotDot.constData(), 3, &glyphs, &nGlyphs, 0)) + // should never happen... + return layoutData->string; + for (int i = 0; i < nGlyphs; ++i) + ellipsisWidth += glyphs.advances_x[i]; + ellipsisText = dotDotDot; + } + } + + const QFixed availableWidth = width - ellipsisWidth; + if (availableWidth < 0) + return QString(); + + const HB_CharAttributes *attributes = this->attributes(); + if (!attributes) + return QString(); + + if (mode == Qt::ElideRight) { + QFixed currentWidth; + int pos; + int nextBreak = 0; + + do { + pos = nextBreak; + + ++nextBreak; + while (nextBreak < layoutData->string.length() && !attributes[nextBreak].charStop) + ++nextBreak; + + currentWidth += this->width(pos, nextBreak - pos); + } while (nextBreak < layoutData->string.length() + && currentWidth < availableWidth); + + if (nextCharJoins(layoutData->string, pos)) + ellipsisText.prepend(QChar(0x200d) /* ZWJ */); + + return layoutData->string.left(pos) + ellipsisText; + } else if (mode == Qt::ElideLeft) { + QFixed currentWidth; + int pos; + int nextBreak = layoutData->string.length(); + + do { + pos = nextBreak; + + --nextBreak; + while (nextBreak > 0 && !attributes[nextBreak].charStop) + --nextBreak; + + currentWidth += this->width(nextBreak, pos - nextBreak); + } while (nextBreak > 0 + && currentWidth < availableWidth); + + if (prevCharJoins(layoutData->string, pos)) + ellipsisText.append(QChar(0x200d) /* ZWJ */); + + return ellipsisText + layoutData->string.mid(pos); + } else if (mode == Qt::ElideMiddle) { + QFixed leftWidth; + QFixed rightWidth; + + int leftPos = 0; + int nextLeftBreak = 0; + + int rightPos = layoutData->string.length(); + int nextRightBreak = layoutData->string.length(); + + do { + leftPos = nextLeftBreak; + rightPos = nextRightBreak; + + ++nextLeftBreak; + while (nextLeftBreak < layoutData->string.length() && !attributes[nextLeftBreak].charStop) + ++nextLeftBreak; + + --nextRightBreak; + while (nextRightBreak > 0 && !attributes[nextRightBreak].charStop) + --nextRightBreak; + + leftWidth += this->width(leftPos, nextLeftBreak - leftPos); + rightWidth += this->width(nextRightBreak, rightPos - nextRightBreak); + } while (nextLeftBreak < layoutData->string.length() + && nextRightBreak > 0 + && leftWidth + rightWidth < availableWidth); + + if (nextCharJoins(layoutData->string, leftPos)) + ellipsisText.prepend(QChar(0x200d) /* ZWJ */); + if (prevCharJoins(layoutData->string, rightPos)) + ellipsisText.append(QChar(0x200d) /* ZWJ */); + + return layoutData->string.left(leftPos) + ellipsisText + layoutData->string.mid(rightPos); + } + + return layoutData->string; +} + +void QTextEngine::setBoundary(int strPos) const +{ + if (strPos <= 0 || strPos >= layoutData->string.length()) + return; + + int itemToSplit = 0; + while (itemToSplit < layoutData->items.size() && layoutData->items.at(itemToSplit).position <= strPos) + itemToSplit++; + itemToSplit--; + if (layoutData->items.at(itemToSplit).position == strPos) { + // already a split at the requested position + return; + } + splitItem(itemToSplit, strPos - layoutData->items.at(itemToSplit).position); +} + +void QTextEngine::splitItem(int item, int pos) const +{ + if (pos <= 0) + return; + + layoutData->items.insert(item + 1, layoutData->items[item]); + QScriptItem &oldItem = layoutData->items[item]; + QScriptItem &newItem = layoutData->items[item+1]; + newItem.position += pos; + + if (oldItem.num_glyphs) { + // already shaped, break glyphs aswell + int breakGlyph = logClusters(&oldItem)[pos]; + + newItem.num_glyphs = oldItem.num_glyphs - breakGlyph; + oldItem.num_glyphs = breakGlyph; + newItem.glyph_data_offset = oldItem.glyph_data_offset + breakGlyph; + + for (int i = 0; i < newItem.num_glyphs; i++) + logClusters(&newItem)[i] -= breakGlyph; + + QFixed w = 0; + const QGlyphLayout g = shapedGlyphs(&oldItem); + for(int j = 0; j < breakGlyph; ++j) + w += g.advances_x[j]; + + newItem.width = oldItem.width - w; + oldItem.width = w; + } + +// qDebug("split at position %d itempos=%d", pos, item); +} + +QFixed QTextEngine::calculateTabWidth(int item, QFixed x) const +{ + const QScriptItem &si = layoutData->items[item]; + + QFixed dpiScale = 1; + if (block.docHandle() && block.docHandle()->layout()) { + QPaintDevice *pdev = block.docHandle()->layout()->paintDevice(); + if (pdev) + dpiScale = QFixed::fromReal(pdev->logicalDpiY() / qreal(qt_defaultDpiY())); + } else { + dpiScale = QFixed::fromReal(fnt.d->dpi / qreal(qt_defaultDpiY())); + } + + QList<QTextOption::Tab> tabArray = option.tabs(); + if (!tabArray.isEmpty()) { + if (isRightToLeft()) { // rebase the tabArray positions. + QList<QTextOption::Tab> newTabs; + QList<QTextOption::Tab>::Iterator iter = tabArray.begin(); + while(iter != tabArray.end()) { + QTextOption::Tab tab = *iter; + if (tab.type == QTextOption::LeftTab) + tab.type = QTextOption::RightTab; + else if (tab.type == QTextOption::RightTab) + tab.type = QTextOption::LeftTab; + newTabs << tab; + ++iter; + } + tabArray = newTabs; + } + for (int i = 0; i < tabArray.size(); ++i) { + QFixed tab = QFixed::fromReal(tabArray[i].position) * dpiScale; + if (tab > x) { // this is the tab we need. + QTextOption::Tab tabSpec = tabArray[i]; + int tabSectionEnd = layoutData->string.count(); + if (tabSpec.type == QTextOption::RightTab || tabSpec.type == QTextOption::CenterTab) { + // find next tab to calculate the width required. + tab = QFixed::fromReal(tabSpec.position); + for (int i=item + 1; i < layoutData->items.count(); i++) { + const QScriptItem &item = layoutData->items[i]; + if (item.analysis.flags == QScriptAnalysis::TabOrObject) { // found it. + tabSectionEnd = item.position; + break; + } + } + } + else if (tabSpec.type == QTextOption::DelimiterTab) + // find delimitor character to calculate the width required + tabSectionEnd = qMax(si.position, layoutData->string.indexOf(tabSpec.delimiter, si.position) + 1); + + if (tabSectionEnd > si.position) { + QFixed length; + // Calculate the length of text between this tab and the tabSectionEnd + for (int i=item; i < layoutData->items.count(); i++) { + QScriptItem &item = layoutData->items[i]; + if (item.position > tabSectionEnd || item.position <= si.position) + continue; + shape(i); // first, lets make sure relevant text is already shaped + QGlyphLayout glyphs = this->shapedGlyphs(&item); + const int end = qMin(item.position + item.num_glyphs, tabSectionEnd) - item.position; + for (int i=0; i < end; i++) + length += glyphs.advances_x[i] * !glyphs.attributes[i].dontPrint; + if (end + item.position == tabSectionEnd && tabSpec.type == QTextOption::DelimiterTab) // remove half of matching char + length -= glyphs.advances_x[end] / 2 * !glyphs.attributes[end].dontPrint; + } + + switch (tabSpec.type) { + case QTextOption::CenterTab: + length /= 2; + // fall through + case QTextOption::DelimiterTab: + // fall through + case QTextOption::RightTab: + tab = QFixed::fromReal(tabSpec.position) * dpiScale - length; + if (tab < 0) // default to tab taking no space + return QFixed(); + break; + case QTextOption::LeftTab: + break; + } + } + return tab - x; + } + } + } + QFixed tab = QFixed::fromReal(option.tabStop()); + if (tab <= 0) + tab = 80; // default + tab *= dpiScale; + QFixed nextTabPos = ((x / tab).truncate() + 1) * tab; + QFixed tabWidth = nextTabPos - x; + + return tabWidth; +} + +void QTextEngine::resolveAdditionalFormats() const +{ + if (!specialData || specialData->addFormats.isEmpty() + || !block.docHandle() + || !specialData->resolvedFormatIndices.isEmpty()) + return; + + QTextFormatCollection *collection = this->formats(); + + specialData->resolvedFormatIndices.clear(); + QVector<int> indices(layoutData->items.count()); + for (int i = 0; i < layoutData->items.count(); ++i) { + QTextCharFormat f = format(&layoutData->items.at(i)); + indices[i] = collection->indexForFormat(f); + } + specialData->resolvedFormatIndices = indices; +} + +QFixed QTextEngine::leadingSpaceWidth(const QScriptLine &line) +{ + if (!line.hasTrailingSpaces + || (option.flags() & QTextOption::IncludeTrailingSpaces) + || !isRightToLeft()) + return QFixed(); + + int pos = line.length; + const HB_CharAttributes *attributes = this->attributes(); + if (!attributes) + return QFixed(); + while (pos > 0 && attributes[line.from + pos - 1].whiteSpace) + --pos; + return width(line.from + pos, line.length - pos); +} + +QStackTextEngine::QStackTextEngine(const QString &string, const QFont &f) + : QTextEngine(string, f), + _layoutData(string, _memory, MemSize) +{ + stackEngine = true; + layoutData = &_layoutData; +} + +QTextItemInt::QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFormat &format) + : justified(false), underlineStyle(QTextCharFormat::NoUnderline), charFormat(format), + num_chars(0), chars(0), logClusters(0), f(0), fontEngine(0) +{ + // explicitly initialize flags so that initFontAttributes can be called + // multiple times on the same TextItem + flags = 0; + if (si.analysis.bidiLevel %2) + flags |= QTextItem::RightToLeft; + ascent = si.ascent; + descent = si.descent; + f = font; + fontEngine = f->d->engineForScript(si.analysis.script); + Q_ASSERT(fontEngine); + + if (format.hasProperty(QTextFormat::TextUnderlineStyle)) { + underlineStyle = format.underlineStyle(); + } else if (format.boolProperty(QTextFormat::FontUnderline) + || f->d->underline) { + underlineStyle = QTextCharFormat::SingleUnderline; + } + + // compat + if (underlineStyle == QTextCharFormat::SingleUnderline) + flags |= QTextItem::Underline; + + if (f->d->overline || format.fontOverline()) + flags |= QTextItem::Overline; + if (f->d->strikeOut || format.fontStrikeOut()) + flags |= QTextItem::StrikeOut; +} + +QTextItemInt::QTextItemInt(const QGlyphLayout &g, QFont *font, const QChar *chars_, int numChars, QFontEngine *fe) + : flags(0), justified(false), underlineStyle(QTextCharFormat::NoUnderline), + num_chars(numChars), chars(chars_), logClusters(0), f(font), glyphs(g), fontEngine(fe) +{ +} + +QTextItemInt QTextItemInt::midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const +{ + QTextItemInt ti = *this; + const int end = firstGlyphIndex + numGlyphs; + ti.glyphs = glyphs.mid(firstGlyphIndex, numGlyphs); + ti.fontEngine = fontEngine; + + if (logClusters && chars) { + const int logClusterOffset = logClusters[0]; + while (logClusters[ti.chars - chars] - logClusterOffset < firstGlyphIndex) + ++ti.chars; + + ti.logClusters += (ti.chars - chars); + + ti.num_chars = 0; + int char_start = ti.chars - chars; + while (char_start + ti.num_chars < num_chars && ti.logClusters[ti.num_chars] - logClusterOffset < end) + ++ti.num_chars; + } + return ti; +} + + +QTransform qt_true_matrix(qreal w, qreal h, QTransform x) +{ + QRectF rect = x.mapRect(QRectF(0, 0, w, h)); + return x * QTransform::fromTranslate(-rect.x(), -rect.y()); +} + + +glyph_metrics_t glyph_metrics_t::transformed(const QTransform &matrix) const +{ + if (matrix.type() < QTransform::TxTranslate) + return *this; + + glyph_metrics_t m = *this; + + qreal w = width.toReal(); + qreal h = height.toReal(); + QTransform xform = qt_true_matrix(w, h, matrix); + + QRectF rect(0, 0, w, h); + rect = xform.mapRect(rect); + m.width = QFixed::fromReal(rect.width()); + m.height = QFixed::fromReal(rect.height()); + + QLineF l = xform.map(QLineF(x.toReal(), y.toReal(), xoff.toReal(), yoff.toReal())); + + m.x = QFixed::fromReal(l.x1()); + m.y = QFixed::fromReal(l.y1()); + + // The offset is relative to the baseline which is why we use dx/dy of the line + m.xoff = QFixed::fromReal(l.dx()); + m.yoff = QFixed::fromReal(l.dy()); + + return m; +} + + +QT_END_NAMESPACE |