QTextEngine Class Reference

#include <qtextengine_p.h>

Inheritance diagram for QTextEngine:

Classes
struct	FontEngineCache
struct	LayoutData
struct	SpecialData

Public Types
enum	LayoutState { LayoutEmpty, InLayout, LayoutFailed }
enum	Mode { WidthOnly = 0x07 }
enum	ShaperFlag { RightToLeft = 0x0001, DesignMetrics = 0x0002, GlyphIndicesOnly = 0x0004 }

Public Functions
QFixed	alignLine (const QScriptLine &line)
bool	atSpace (int position) const
const HB_CharAttributes *	attributes () const
bool	atWordSeparator (int position) const
QGlyphLayout	availableGlyphs (const QScriptItem *si) const
glyph_metrics_t	boundingBox (int from, int len) const
QFixed	calculateTabWidth (int index, QFixed x) const
	returns the width of tab at index (in the tabs array) with the tab-start at position x More...
void	clearLineData ()
QAbstractTextDocumentLayout *	docLayout () const
QString	elidedText (Qt::TextElideMode mode, const QFixed &width, int flags=0) const
bool	ensureSpace (int nGlyphs) const
int	findItem (int strPos) const
QFont	font (const QScriptItem &si) const
QFont	font () const
QFontEngine *	fontEngine (const QScriptItem &si, QFixed *ascent=0, QFixed *descent=0, QFixed *leading=0) const
QTextCharFormat	format (const QScriptItem *si) const
int	formatIndex (const QScriptItem *si) const
QTextFormatCollection *	formats () const
void	freeMemory ()
bool	hasFormats () const
void	indexAdditionalFormats ()
void	insertionPointsForLine (int lineNum, QVector< int > &insertionPoints)
void	invalidate ()
bool	isRightToLeft () const
void	itemize () const
void	justify (const QScriptLine &si)
QFixed	leadingSpaceWidth (const QScriptLine &line)
int	length (int item) const
int	length (const QScriptItem *si) const
int	lineNumberForTextPosition (int pos)
unsigned short *	logClusters (const QScriptItem *si) const
int	nextLogicalPosition (int oldPos) const
QFixed	offsetInLigature (const QScriptItem *si, int pos, int max, int glyph_pos)
int	positionAfterVisualMovement (int oldPos, QTextCursor::MoveOperation op)
int	positionInLigature (const QScriptItem *si, int end, QFixed x, QFixed edge, int glyph_pos, bool cursorOnCharacter)
int	previousLogicalPosition (int oldPos) const
	QTextEngine (LayoutData *data)
	QTextEngine ()
	QTextEngine (const QString &str, const QFont &f)
void	resetFontEngineCache ()
void	shape (int item) const
QGlyphLayout	shapedGlyphs (const QScriptItem *si) const
void	shapeLine (const QScriptLine &line)
glyph_metrics_t	tightBoundingBox (int from, int len) const
void	validate () const
bool	visualCursorMovement () const
QFixed	width (int charFrom, int numChars) const
	~QTextEngine ()

Static Public Functions
static void	bidiReorder (int numRuns, const quint8 *levels, int *visualOrder)

Public Variables
QTextBlock	block
uint	cacheGlyphs: 1
FontEngineCache	feCache
QFont	fnt
uint	forceJustification: 1
uint	ignoreBidi: 1
LayoutData *	layoutData
QScriptLineArray	lines
QFixed	maxWidth
QFixed	minWidth
QTextOption	option
QPointF	position
SpecialData *	specialData
uint	stackEngine: 1
QString	text
int *	underlinePositions
uint	visualMovement: 1

Private Functions
void	addRequiredBoundaries () const
int	beginningOfLine (int lineNum)
int	endOfLine (int lineNum)
int	getClusterLength (unsigned short *logClusters, const HB_CharAttributes *attributes, int from, int to, int glyph_pos, int *start)
void	resolveAdditionalFormats () const
void	setBoundary (int strPos) const
void	shapeText (int item) const
void	shapeTextMac (int item) const
void	shapeTextWithCE (int item) const
void	shapeTextWithHarfbuzz (int item) const
	take the item from layoutData->items and More...
void	splitItem (int item, int pos) const

Detailed Description

Definition at line 421 of file qtextengine_p.h.

Enumerations

LayoutState

enum QTextEngine::LayoutState

Enumerator
LayoutEmpty
InLayout
LayoutFailed

Definition at line 423 of file qtextengine_p.h.

                     {
        LayoutEmpty,
        InLayout,
        LayoutFailed,
    };

Mode

enum QTextEngine::Mode

Enumerator
WidthOnly

Definition at line 452 of file qtextengine_p.h.

              {
        WidthOnly = 0x07
    };

ShaperFlag

enum QTextEngine::ShaperFlag

Enumerator
RightToLeft
DesignMetrics
GlyphIndicesOnly

Definition at line 457 of file qtextengine_p.h.

                    {
        RightToLeft = 0x0001,
        DesignMetrics = 0x0002,
        GlyphIndicesOnly = 0x0004
    };

Constructors and Destructors

QTextEngine() [1/3]

QTextEngine::QTextEngine

(

LayoutData *

data

)

QTextEngine() [2/3]

QTextEngine::QTextEngine

(

)

Definition at line 1385 of file qtextengine.cpp.

{
    init(this);
}

QTextEngine() [3/3]

QTextEngine::QTextEngine	(	const QString &	str,
		const QFont &	f
	)

Definition at line 1390 of file qtextengine.cpp.

    : text(str),
      fnt(f)
{
    init(this);
}

~QTextEngine()

QTextEngine::~QTextEngine

(

)

Definition at line 1397 of file qtextengine.cpp.

{
    if (!stackEngine)
        delete layoutData;
    delete specialData;
    resetFontEngineCache();
}

Functions

addRequiredBoundaries()

void QTextEngine::addRequiredBoundaries ( ) const

private

Definition at line 2385 of file qtextengine.cpp.

Referenced by itemize().

{
    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);
        }
    }
}

alignLine()

QFixed QTextEngine::alignLine

(

const QScriptLine &

line

)

Definition at line 2832 of file qtextengine.cpp.

Referenced by QTextLine::cursorToX(), QTextLine::naturalTextRect(), QTextLineItemIterator::QTextLineItemIterator(), and QTextLine::xToCursor().

{
    QFixed x = 0;
    justify(line);
    // if width is QFIXED_MAX that means we used setNumColumns() and that implicitly makes this line left aligned.
    if (!line.justified && line.width != QFIXED_MAX) {
        int align = option.alignment();
        if (align & Qt::AlignJustify && isRightToLeft())
            align = Qt::AlignRight;
        if (align & Qt::AlignRight)
            x = line.width - (line.textAdvance);
        else if (align & Qt::AlignHCenter)
            x = (line.width - line.textAdvance)/2;
    }
    return x;
}

atSpace()

bool QTextEngine::atSpace

(

int

position

)

const

Definition at line 2437 of file qtextengine.cpp.

Referenced by QTextCursorPrivate::movePosition().

{
    const QChar c = layoutData->string.at(position);

    return c == QLatin1Char(' ')
        || c == QChar::Nbsp
        || c == QChar::LineSeparator
        || c == QLatin1Char('\t')
        ;
}

attributes()

const HB_CharAttributes * QTextEngine::attributes

(

)

const

Definition at line 1405 of file qtextengine.cpp.

Referenced by QTextLine::cursorToX(), elidedText(), justify(), QTextLine::layout_helper(), QTextCursorPrivate::movePosition(), nextLogicalPosition(), positionInLigature(), and previousLogicalPosition().

{
    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;
}

atWordSeparator()

bool QTextEngine::atWordSeparator

(

int

position

)

const

Definition at line 2397 of file qtextengine.cpp.

Referenced by QTextCursorPrivate::movePosition().

{
    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;
    }
}

availableGlyphs()

QGlyphLayout QTextEngine::availableGlyphs ( const QScriptItem *  si ) const

inline

Returns an array of QGlyphLayout items, offset at the script item. Each item in the array matches one glyph in the text, storing the advance, position etc. The returned item's length equals to the number of available glyphs. This may be more than what was actually shaped.

See also

logClusters()

Definition at line 520 of file qtextengine_p.h.

                                                                     {
        return layoutData->glyphLayout.mid(si->glyph_data_offset);
    }

beginningOfLine()

int QTextEngine::beginningOfLine ( int  lineNum )

private

Definition at line 3029 of file qtextengine.cpp.

Referenced by positionAfterVisualMovement().

{
    QVector<int> insertionPoints;
    insertionPointsForLine(lineNum, insertionPoints);

    if (insertionPoints.size() > 0)
        return insertionPoints.first();
    return 0;
}

bidiReorder()

void QTextEngine::bidiReorder ( int  numRuns, const quint8 *  levels, int *  visualOrder  )

static

Definition at line 774 of file qtextengine.cpp.

Referenced by QPainterPath::addText(), QTextLine::cursorToX(), QPainter::drawText(), QTextLineItemIterator::QTextLineItemIterator(), and QTextLine::xToCursor().

{

    // 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
}

boundingBox()

glyph_metrics_t QTextEngine::boundingBox	(	int	from,
		int	len
	)		const

Definition at line 1736 of file qtextengine.cpp.

{
    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;
}

calculateTabWidth()

QFixed QTextEngine::calculateTabWidth	(	int	index,
		QFixed	x
	)		const

returns the width of tab at index (in the tabs array) with the tab-start at position x

Definition at line 2710 of file qtextengine.cpp.

Referenced by boundingBox(), QTextLine::layout_helper(), and width().

{
    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;
}

clearLineData()

void QTextEngine::clearLineData

(

)

Definition at line 1481 of file qtextengine.cpp.

{
    lines.clear();
}

docLayout()

QAbstractTextDocumentLayout* QTextEngine::docLayout ( ) const

inline

Definition at line 550 of file qtextengine_p.h.

Referenced by QTextLine::draw(), QTextLine::layout_helper(), and shape().

                                                          {
#ifdef QT_BUILD_COMPAT_LIB
        return 0; // Compat should never reference this symbol
#else
        return block.docHandle()->document()->documentLayout();
#endif
    }

elidedText()

QString QTextEngine::elidedText	(	Qt::TextElideMode	mode,
		const QFixed &	width,
		int	flags = 0
	)		const

Definition at line 2486 of file qtextengine.cpp.

Referenced by QFontMetrics::elidedText(), QFontMetricsF::elidedText(), and QCommonStylePrivate::viewItemDrawText().

{
//    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;
}

endOfLine()

int QTextEngine::endOfLine ( int  lineNum )

private

Definition at line 3019 of file qtextengine.cpp.

Referenced by positionAfterVisualMovement().

{
    QVector<int> insertionPoints;
    insertionPointsForLine(lineNum, insertionPoints);

    if (insertionPoints.size() > 0)
        return insertionPoints.last();
    return 0;
}

ensureSpace()

bool QTextEngine::ensureSpace ( int  nGlyphs ) const

inline

Definition at line 533 of file qtextengine_p.h.

Referenced by attributes(), and shape().

                                               {
        if (layoutData->glyphLayout.numGlyphs - layoutData->used < nGlyphs)
            return layoutData->reallocate((((layoutData->used + nGlyphs)*3/2 + 15) >> 4) << 4);
        return true;
    }

findItem()

int QTextEngine::findItem

(

int

strPos

)

const

Definition at line 1655 of file qtextengine.cpp.

Referenced by QTextLine::cursorToX(), justify(), QTextLine::layout_helper(), and QTextLine::xToCursor().

{
    itemize();

    int left = 1;
    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;
}

font() [1/2]

QFont QTextEngine::font

(

const QScriptItem &

si

)

const

Definition at line 1848 of file qtextengine.cpp.

Referenced by QTextLine::draw(), QPainter::drawText(), and QTextLine::glyphs().

{
    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;
}

font() [2/2]

QFont QTextEngine::font ( ) const

inline

Definition at line 501 of file qtextengine_p.h.

Referenced by font(), and fontEngine().

{ return fnt; }

fontEngine()

QFontEngine * QTextEngine::fontEngine	(	const QScriptItem &	si,
		QFixed *	ascent = 0,
		QFixed *	descent = 0,
		QFixed *	leading = 0
	)		const

Definition at line 1885 of file qtextengine.cpp.

Referenced by boundingBox(), QTextLine::draw(), justify(), QTextLine::layout_helper(), releaseCachedFontEngine(), shape(), and tightBoundingBox().

{
    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);
            }
            if (engine)
                engine->ref.ref();
            if (feCache.prevFontEngine)
                releaseCachedFontEngine(feCache.prevFontEngine);
            feCache.prevFontEngine = engine;

            if (scaledEngine)
                scaledEngine->ref.ref();
            if (feCache.prevScaledFontEngine)
                releaseCachedFontEngine(feCache.prevScaledFontEngine);
            feCache.prevScaledFontEngine = scaledEngine;
            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);
            if (engine)
                engine->ref.ref();
            if (feCache.prevFontEngine)
                releaseCachedFontEngine(feCache.prevFontEngine);
            feCache.prevFontEngine = engine;
            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;
}

format()

QTextCharFormat QTextEngine::format

(

const QScriptItem *

si

)

const

Definition at line 2362 of file qtextengine.cpp.

Referenced by QTextLine::draw(), font(), fontEngine(), resolveAdditionalFormats(), and shape().

{
    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;
}

formatIndex()

int QTextEngine::formatIndex

(

const QScriptItem *

si

)

const

Definition at line 2343 of file qtextengine.cpp.

Referenced by QTextInlineObject::format(), format(), QTextInlineObject::formatIndex(), QTextLine::layout_helper(), and shape().

{
    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;
}

formats()

QTextFormatCollection* QTextEngine::formats ( ) const

inline

Definition at line 542 of file qtextengine_p.h.

Referenced by QTextInlineObject::format(), format(), indexAdditionalFormats(), itemize(), QTextLine::layout_helper(), resolveAdditionalFormats(), and shape().

                                                  {
#ifdef QT_BUILD_COMPAT_LIB
        return 0; // Compat should never reference this symbol
#else
        return block.docHandle()->formatCollection();
#endif
    }

freeMemory()

void QTextEngine::freeMemory

(

)

Definition at line 2326 of file qtextengine.cpp.

Referenced by invalidate().

{
    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;
    }
}

getClusterLength()

int QTextEngine::getClusterLength ( unsigned short *  logClusters, const HB_CharAttributes *  attributes, int  from, int  to, int  glyph_pos, int *  start  )

private

Definition at line 2880 of file qtextengine.cpp.

Referenced by positionInLigature().

{
    int clusterLength = 0;
    for (int i = from; i < to; i++) {
        if (logClusters[i] == glyph_pos && attributes[i].charStop) {
            if (*start < 0)
                *start = i;
            clusterLength++;
        }
        else if (clusterLength)
            break;
    }
    return clusterLength;
}

hasFormats()

bool QTextEngine::hasFormats ( ) const

inline

Definition at line 600 of file qtextengine_p.h.

Referenced by QTextLine::draw(), font(), and fontEngine().

{ return (block.docHandle() || specialData); }

indexAdditionalFormats()

void QTextEngine::indexAdditionalFormats

(

)

Definition at line 2449 of file qtextengine.cpp.

{
    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();
    }
}

insertionPointsForLine()

void QTextEngine::insertionPointsForLine	(	int	lineNum,
		QVector< int > &	insertionPoints
	)

Definition at line 2994 of file qtextengine.cpp.

Referenced by beginningOfLine(), endOfLine(), positionAfterVisualMovement(), and QTextLine::xToCursor().

{
    QTextLineItemIterator iterator(this, lineNum);
    bool rtl = isRightToLeft();
    bool lastLine = lineNum >= lines.size() - 1;

    while (!iterator.atEnd()) {
        iterator.next();
        const QScriptItem *si = &layoutData->items[iterator.item];
        if (si->analysis.bidiLevel % 2) {
            int i = iterator.itemEnd - 1, min = iterator.itemStart;
            if (lastLine && (rtl ? iterator.atBeginning() : iterator.atEnd()))
                i++;
            for (; i >= min; i--)
                insertionPoints.push_back(i);
        } else {
            int i = iterator.itemStart, max = iterator.itemEnd;
            if (lastLine && (rtl ? iterator.atBeginning() : iterator.atEnd()))
                max++;
            for (; i < max; i++)
                insertionPoints.push_back(i);
        }
    }
}

invalidate()

void QTextEngine::invalidate

(

)

Definition at line 1470 of file qtextengine.cpp.

Referenced by QTextBlockData::invalidate().

{
    freeMemory();
    minWidth = 0;
    maxWidth = 0;
    if (specialData)
        specialData->resolvedFormatIndices.clear();

    resetFontEngineCache();
}

isRightToLeft()

bool QTextEngine::isRightToLeft

(

)

const

Definition at line 1636 of file qtextengine.cpp.

Referenced by alignLine(), calculateTabWidth(), QTextLine::cursorToX(), insertionPointsForLine(), itemize(), leadingSpaceWidth(), positionAfterVisualMovement(), and QTextLine::xToCursor().

{
    switch (option.textDirection()) {
    case Qt::LeftToRight:
        return false;
    case Qt::RightToLeft:
        return true;
    default:
        break;
    }
    if (!layoutData)
        itemize();
    // 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();
}

itemize()

void QTextEngine::itemize

(

)

const

Definition at line 1502 of file qtextengine.cpp.

Referenced by attributes(), boundingBox(), QTextLine::cursorToX(), QPainter::drawText(), elidedText(), findItem(), isRightToLeft(), justify(), lineNumberForTextPosition(), positionAfterVisualMovement(), tightBoundingBox(), width(), and QTextLine::xToCursor().

{
    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) {
        switch (*uc) {
        case QChar::ObjectReplacementCharacter:
            analysis->script = QUnicodeTables::Common;
            analysis->flags = QScriptAnalysis::Object;
            break;
        case 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
            break;
        case 9: // Tab
            analysis->script = QUnicodeTables::Common;
            analysis->flags = QScriptAnalysis::Tab;
            analysis->bidiLevel = control.baseLevel();
            break;
        case 32: // Space
        case QChar::Nbsp:
            if (option.flags() & QTextOption::ShowTabsAndSpaces) {
                analysis->script = QUnicodeTables::Common;
                analysis->flags = QScriptAnalysis::Space;
                analysis->bidiLevel = control.baseLevel();
                break;
            }
        // fall through
        default:
            int script = QUnicodeTables::script(*uc);
            analysis->script = script == QUnicodeTables::Inherited ? lastScript : script;
            analysis->flags = QScriptAnalysis::None;
            break;
        }
        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();
}

justify()

void QTextEngine::justify

(

const QScriptLine &

si

)

Definition at line 1995 of file qtextengine.cpp.

Referenced by alignLine(), and QPainter::drawText().

{
//     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 leading = leadingSpaceWidth(line);
    QFixed need = line.width - line.textWidth - leading;
    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;
}

leadingSpaceWidth()

QFixed QTextEngine::leadingSpaceWidth

(

const QScriptLine &

line

)

Definition at line 2822 of file qtextengine.cpp.

Referenced by QTextLine::cursorToX(), justify(), and qt_format_text().

{
    if (!line.hasTrailingSpaces
        || (option.flags() & QTextOption::IncludeTrailingSpaces)
        || !isRightToLeft())
        return QFixed();

    return width(line.from + line.length, line.trailingSpaces);
}

length() [1/2]

int QTextEngine::length ( int  item ) const

inline

Definition at line 484 of file qtextengine_p.h.

Referenced by attributes(), boundingBox(), calculateTabWidth(), QTextLine::cursorToX(), QPainter::drawText(), elidedText(), fontEngine(), format(), QTextLineItemIterator::getSelectionBounds(), QTextLine::glyphs(), itemize(), justify(), QTextLine::layout_helper(), QTextEngine::LayoutData::LayoutData(), QTextLineItemIterator::next(), nextCharJoins(), nextLogicalPosition(), QTextEngine::LayoutData::reallocate(), tightBoundingBox(), width(), and QTextLine::xToCursor().

                               {
        const QScriptItem &si = layoutData->items[item];
        int from = si.position;
        item++;
        return (item < layoutData->items.size() ? layoutData->items[item].position : layoutData->string.length()) - from;
    }

length() [2/2]

int QTextEngine::length ( const QScriptItem *  si ) const

inline

Definition at line 490 of file qtextengine_p.h.

                                            {
        int end;
        if (si + 1 < layoutData->items.constData()+ layoutData->items.size())
            end = (si+1)->position;
        else
            end = layoutData->string.length();
        return end - si->position;
    }

lineNumberForTextPosition()

int QTextEngine::lineNumberForTextPosition

(

int

pos

)

Definition at line 2980 of file qtextengine.cpp.

Referenced by positionAfterVisualMovement().

{
    if (!layoutData)
        itemize();
    if (pos == layoutData->string.length() && lines.size())
        return lines.size() - 1;
    for (int i = 0; i < lines.size(); ++i) {
        const QScriptLine& line = lines[i];
        if (line.from + line.length + line.trailingSpaces > pos)
            return i;
    }
    return -1;
}

logClusters()

unsigned short* QTextEngine::logClusters ( const QScriptItem *  si ) const

inline

Returns a pointer to an array of log clusters, offset at the script item. Each item in the array is a unsigned short. For each character in the original string there is an entry in the table so there is a one to one correlation in indexes between the original text and the index in the logcluster. The value of each item is the position in the glyphs array. Multiple similar pointers in the logclusters array imply that one glyph is used for more than one character.

See also

glyphs()

Definition at line 511 of file qtextengine_p.h.

Referenced by boundingBox(), QTextLine::cursorToX(), QTextLine::draw(), drawMenuText(), QPainter::drawText(), elidedText(), QTextLineItemIterator::getSelectionBounds(), justify(), QTextLineItemIterator::next(), offsetInLigature(), positionInLigature(), splitItem(), tightBoundingBox(), width(), and QTextLine::xToCursor().

        { return layoutData->logClustersPtr+si->position; }

nextLogicalPosition()

int QTextEngine::nextLogicalPosition

(

int

oldPos

)

const

Definition at line 2965 of file qtextengine.cpp.

Referenced by positionAfterVisualMovement().

{
    const HB_CharAttributes *attrs = attributes();
    int len = block.isValid() ? block.length() - 1
                              : layoutData->string.length();
    Q_ASSERT(len <= layoutData->string.length());
    if (!attrs || oldPos < 0 || oldPos >= len)
        return oldPos;

    oldPos++;
    while (oldPos < len && !attrs[oldPos].charStop)
        oldPos++;
    return oldPos;
}

offsetInLigature()

QFixed QTextEngine::offsetInLigature	(	const QScriptItem *	si,
		int	pos,
		int	max,
		int	glyph_pos
	)

Definition at line 2849 of file qtextengine.cpp.

Referenced by QTextLine::cursorToX(), and QTextLineItemIterator::getSelectionBounds().

{
    unsigned short *logClusters = this->logClusters(si);
    const QGlyphLayout &glyphs = shapedGlyphs(si);

    int offsetInCluster = 0;
    for (int i = pos - 1; i >= 0; i--) {
        if (logClusters[i] == glyph_pos)
            offsetInCluster++;
        else
            break;
    }

    // in the case that the offset is inside a (multi-character) glyph,
    // interpolate the position.
    if (offsetInCluster > 0) {
        int clusterLength = 0;
        for (int i = pos - offsetInCluster; i < max; i++) {
            if (logClusters[i] == glyph_pos)
                clusterLength++;
            else
                break;
        }
        if (clusterLength)
            return glyphs.advances_x[glyph_pos] * offsetInCluster / clusterLength;
    }

    return 0;
}

positionAfterVisualMovement()

int QTextEngine::positionAfterVisualMovement	(	int	oldPos,
		QTextCursor::MoveOperation	op
	)

Definition at line 3039 of file qtextengine.cpp.

{
    if (!layoutData)
        itemize();

    bool moveRight = (op == QTextCursor::Right);
    bool alignRight = isRightToLeft();
    if (!layoutData->hasBidi)
        return moveRight ^ alignRight ? nextLogicalPosition(pos) : previousLogicalPosition(pos);

    int lineNum = lineNumberForTextPosition(pos);
    Q_ASSERT(lineNum >= 0);

    QVector<int> insertionPoints;
    insertionPointsForLine(lineNum, insertionPoints);
    int i, max = insertionPoints.size();
    for (i = 0; i < max; i++)
        if (pos == insertionPoints[i]) {
            if (moveRight) {
                if (i + 1 < max)
                    return insertionPoints[i + 1];
            } else {
                if (i > 0)
                    return insertionPoints[i - 1];
            }

            if (moveRight ^ alignRight) {
                if (lineNum + 1 < lines.size())
                    return alignRight ? endOfLine(lineNum + 1) : beginningOfLine(lineNum + 1);
            }
            else {
                if (lineNum > 0)
                    return alignRight ? beginningOfLine(lineNum - 1) : endOfLine(lineNum - 1);
            }
        }

    return pos;
}

positionInLigature()

int QTextEngine::positionInLigature	(	const QScriptItem *	si,
		int	end,
		QFixed	x,
		QFixed	edge,
		int	glyph_pos,
		bool	cursorOnCharacter
	)

Definition at line 2897 of file qtextengine.cpp.

Referenced by QTextLine::xToCursor().

{
    unsigned short *logClusters = this->logClusters(si);
    int clusterStart = -1;
    int clusterLength = 0;

    if (si->analysis.script != QUnicodeTables::Common &&
        si->analysis.script != QUnicodeTables::Greek) {
        if (glyph_pos == -1)
            return si->position + end;
        else {
            int i;
            for (i = 0; i < end; i++)
                if (logClusters[i] == glyph_pos)
                    break;
            return si->position + i;
        }
    }

    if (glyph_pos == -1 && end > 0)
        glyph_pos = logClusters[end - 1];
    else {
        if (x <= edge)
            glyph_pos--;
    }

    const HB_CharAttributes *attrs = attributes();
    logClusters = this->logClusters(si);
    clusterLength = getClusterLength(logClusters, attrs, 0, end, glyph_pos, &clusterStart);

    if (clusterLength) {
        const QGlyphLayout &glyphs = shapedGlyphs(si);
        QFixed glyphWidth = glyphs.effectiveAdvance(glyph_pos);
        // the approximate width of each individual element of the ligature
        QFixed perItemWidth = glyphWidth / clusterLength;
        if (perItemWidth <= 0)
            return si->position + clusterStart;
        QFixed left = x > edge ? edge : edge - glyphWidth;
        int n = ((x - left) / perItemWidth).floor().toInt();
        QFixed dist = x - left - n * perItemWidth;
        int closestItem = dist > (perItemWidth / 2) ? n + 1 : n;
        if (cursorOnCharacter && closestItem > 0)
            closestItem--;
        int pos = si->position + clusterStart + closestItem;
        // Jump to the next charStop
        while (pos < end && !attrs[pos].charStop)
            pos++;
        return pos;
    }
    return si->position + end;
}

previousLogicalPosition()

int QTextEngine::previousLogicalPosition

(

int

oldPos

)

const

Definition at line 2951 of file qtextengine.cpp.

Referenced by positionAfterVisualMovement().

{
    const HB_CharAttributes *attrs = attributes();
    if (!attrs || oldPos < 0)
        return oldPos;

    if (oldPos <= 0)
        return 0;
    oldPos--;
    while (oldPos && !attrs[oldPos].charStop)
        oldPos--;
    return oldPos;
}

resetFontEngineCache()

void QTextEngine::resetFontEngineCache

(

)

Definition at line 1463 of file qtextengine.cpp.

Referenced by invalidate(), and ~QTextEngine().

{
    releaseCachedFontEngine(feCache.prevFontEngine);
    releaseCachedFontEngine(feCache.prevScaledFontEngine);
    feCache.reset();
}

resolveAdditionalFormats()

void QTextEngine::resolveAdditionalFormats ( ) const

private

Definition at line 2804 of file qtextengine.cpp.

Referenced by itemize().

{
    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;
}

setBoundary()

void QTextEngine::setBoundary ( int  strPos ) const

private

Definition at line 2661 of file qtextengine.cpp.

Referenced by addRequiredBoundaries().

{
    if (strPos <= 0 || strPos >= layoutData->string.length())
        return;

    const QScriptItem* it = qUpperBound(layoutData->items.constBegin(), layoutData->items.constEnd(),
                                        strPos, QScriptItemComparator());
    Q_ASSERT(it > layoutData->items.constBegin());
    --it;
    if (it->position == strPos) {
        // already a split at the requested position
        return;
    }
    splitItem(it - layoutData->items.constBegin(), strPos - it->position);
}

shape()

void QTextEngine::shape

(

int

item

)

const

Definition at line 1434 of file qtextengine.cpp.

Referenced by boundingBox(), calculateTabWidth(), QTextLine::cursorToX(), elidedText(), justify(), QTextLine::layout_helper(), QTextLineItemIterator::next(), tightBoundingBox(), width(), and QTextLine::xToCursor().

{
    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);
    }
}

shapedGlyphs()

QGlyphLayout QTextEngine::shapedGlyphs ( const QScriptItem *  si ) const

inline

Returns an array of QGlyphLayout items, offset at the script item. Each item in the array matches one glyph in the text, storing the advance, position etc. The returned item's length equals to the number of shaped glyphs.

See also

logClusters()

Definition at line 529 of file qtextengine_p.h.

Referenced by QPainterPath::addText(), boundingBox(), calculateTabWidth(), QTextLine::cursorToX(), QTextLine::draw(), drawMenuText(), QPainter::drawText(), elidedText(), QTextLineItemIterator::getSelectionBounds(), QTextLine::glyphs(), justify(), QTextLine::layout_helper(), QTextLineItemIterator::next(), offsetInLigature(), positionInLigature(), splitItem(), tightBoundingBox(), width(), and QTextLine::xToCursor().

                                                                  {
        return layoutData->glyphLayout.mid(si->glyph_data_offset, si->num_glyphs);
    }

shapeLine()

void QTextEngine::shapeLine

(

const QScriptLine &

line

)

Definition at line 861 of file qtextengine.cpp.

Referenced by QTextLine::cursorToX(), QPainter::drawText(), QTextLineItemIterator::QTextLineItemIterator(), and QTextLine::xToCursor().

{
    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;
    }
}

shapeText()

void QTextEngine::shapeText ( int  item ) const

private

Definition at line 905 of file qtextengine.cpp.

Referenced by shape().

{
    Q_ASSERT(item < layoutData->items.size());
    QScriptItem &si = layoutData->items[item];

    if (si.num_glyphs)
        return;

#if defined(Q_WS_MAC)
#if !defined(QT_ENABLE_HARFBUZZ_FOR_MAC)
    if (enableHarfBuzz()) {
#endif
        QFontEngine *actualFontEngine = fontEngine(si, &si.ascent, &si.descent, &si.leading);
        if (actualFontEngine->type() == QFontEngine::Multi)
            actualFontEngine = static_cast<QFontEngineMulti *>(actualFontEngine)->engine(0);

        HB_Face face = actualFontEngine->harfbuzzFace();
        HB_Script script = (HB_Script) si.analysis.script;
        if (face->supported_scripts[script])
            shapeTextWithHarfbuzz(item);
        else
            shapeTextMac(item);
#if !defined(QT_ENABLE_HARFBUZZ_FOR_MAC)
    } else {
        shapeTextMac(item);
    }
#endif
#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] * !glyphs.attributes[i].dontPrint;
}

shapeTextMac()

void QTextEngine::shapeTextMac ( int  item ) const

private

Definition at line 557 of file qtextengine_mac.cpp.

{
    QScriptItem &si = layoutData->items[item];

    si.glyph_data_offset = layoutData->used;

    QFontEngine *font = fontEngine(si, &si.ascent, &si.descent, &si.leading);
    if (font->type() != QFontEngine::Multi) {
        shapeTextWithHarfbuzz(item);
        return;
    }
    
#ifndef QT_MAC_USE_COCOA
    QFontEngineMacMulti *fe = static_cast<QFontEngineMacMulti *>(font);
#else
    QCoreTextFontEngineMulti *fe = static_cast<QCoreTextFontEngineMulti *>(font);
#endif
    QTextEngine::ShaperFlags flags;
    if (si.analysis.bidiLevel % 2)
        flags |= RightToLeft;
    if (option.useDesignMetrics())
    flags |= DesignMetrics;

    attributes(); // pre-initialize char attributes

    const int len = length(item);
    int num_glyphs = length(item);
    const QChar *str = layoutData->string.unicode() + si.position;
    ushort upperCased[256];
    if (si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase
            || si.analysis.flags == QScriptAnalysis::Lowercase) {
        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);
    }

    ensureSpace(num_glyphs);
    num_glyphs = layoutData->glyphLayout.numGlyphs - layoutData->used;

    QGlyphLayout g = availableGlyphs(&si);
    g.numGlyphs = num_glyphs;
    unsigned short *log_clusters = logClusters(&si);

    bool stringToCMapFailed = false;
    // Skip shaping of line or paragraph separators since we are not
    // going to draw them anyway
    if (si.analysis.flags == QScriptAnalysis::LineOrParagraphSeparator
        && !(option.flags() & QTextOption::ShowLineAndParagraphSeparators)) {
        memset(log_clusters, 0, len * sizeof(unsigned short));
        goto cleanUp;
    }

    if (!fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters, attributes(), &si)) {
        ensureSpace(num_glyphs);
        g = availableGlyphs(&si);
        stringToCMapFailed = !fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters,
                                               attributes(), &si);
    }

    if (!stringToCMapFailed) {
        heuristicSetGlyphAttributes(str, len, &g, log_clusters, num_glyphs);

        si.num_glyphs = num_glyphs;

        layoutData->used += si.num_glyphs;

        QGlyphLayout g = shapedGlyphs(&si);

        if (si.analysis.script == QUnicodeTables::Arabic) {
            QVarLengthArray<QArabicProperties> props(len + 2);
            QArabicProperties *properties = props.data();
            int f = si.position;
            int l = len;
            if (f > 0) {
                --f;
                ++l;
                ++properties;
            }
            if (f + l < layoutData->string.length()) {
                ++l;
            }
            qt_getArabicProperties((const unsigned short *)(layoutData->string.unicode()+f), l, props.data());

            unsigned short *log_clusters = logClusters(&si);

            for (int i = 0; i < len; ++i) {
                int gpos = log_clusters[i];
                g.attributes[gpos].justification = properties[i].justification;
            }
        }
    }

cleanUp:
    const ushort *uc = reinterpret_cast<const ushort *>(str);

    if ((si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase
         || si.analysis.flags == QScriptAnalysis::Lowercase)
        && uc != upperCased)
        delete [] uc;
}

shapeTextWithCE()

void QTextEngine::shapeTextWithCE ( int  item ) const

private

Definition at line 1107 of file qtextengine.cpp.

{
    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;
}

shapeTextWithHarfbuzz()

void QTextEngine::shapeTextWithHarfbuzz ( int  item ) const

private

take the item from layoutData->items and

Definition at line 1186 of file qtextengine.cpp.

{
    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);
        }

        si.ascent = qMax(actualFontEngine->ascent(), si.ascent);
        si.descent = qMax(actualFontEngine->descent(), si.descent);
        si.leading = qMax(actualFontEngine->leading(), si.leading);

        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);
}

splitItem()

void QTextEngine::splitItem ( int  item, int  pos  ) const

private

Definition at line 2677 of file qtextengine.cpp.

Referenced by setBoundary().

{
    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] * !g.attributes[j].dontPrint;

        newItem.width = oldItem.width - w;
        oldItem.width = w;
    }

//     qDebug("split at position %d itempos=%d", pos, item);
}

tightBoundingBox()

glyph_metrics_t QTextEngine::tightBoundingBox	(	int	from,
		int	len
	)		const

Definition at line 1797 of file qtextengine.cpp.

{
    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;
}

validate()

void QTextEngine::validate

(

)

const

Definition at line 1486 of file qtextengine.cpp.

Referenced by elidedText(), and itemize().

{
    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);
}

visualCursorMovement()

bool QTextEngine::visualCursorMovement ( ) const

inline

Definition at line 601 of file qtextengine_p.h.

Referenced by QTextLine::cursorToX(), and QTextLine::xToCursor().

    {
        return (visualMovement ||
                (block.docHandle() ? block.docHandle()->defaultCursorMoveStyle == Qt::VisualMoveStyle : false));
    }

width()

QFixed QTextEngine::width	(	int	charFrom,
		int	numChars
	)		const

Definition at line 1674 of file qtextengine.cpp.

Referenced by elidedText(), and leadingSpaceWidth().

{
    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;
}

Properties

block

QTextBlock QTextEngine::block

Definition at line 583 of file qtextengine_p.h.

Referenced by calculateTabWidth(), QTextLine::draw(), font(), fontEngine(), QTextInlineObject::format(), format(), formatIndex(), indexAdditionalFormats(), itemize(), QTextLine::layout_helper(), nextLogicalPosition(), resolveAdditionalFormats(), QScriptLine::setDefaultHeight(), shape(), QTextLine::textLength(), and validate().

cacheGlyphs

uint QTextEngine::cacheGlyphs

Definition at line 591 of file qtextengine_p.h.

Referenced by init().

feCache

FontEngineCache QTextEngine::feCache

mutable

Definition at line 579 of file qtextengine_p.h.

Referenced by fontEngine(), and resetFontEngineCache().

fnt

QFont QTextEngine::fnt

Definition at line 582 of file qtextengine_p.h.

Referenced by calculateTabWidth(), elidedText(), font(), fontEngine(), itemize(), and QScriptLine::setDefaultHeight().

forceJustification

uint QTextEngine::forceJustification

Definition at line 593 of file qtextengine_p.h.

Referenced by QPainter::drawText(), init(), justify(), and qt_format_text().

ignoreBidi

uint QTextEngine::ignoreBidi

Definition at line 590 of file qtextengine_p.h.

Referenced by QPainter::drawText(), init(), itemize(), and qt_format_text().

layoutData

LayoutData* QTextEngine::layoutData

mutable

Definition at line 598 of file qtextengine_p.h.

Referenced by QPainterPath::addText(), QTextInlineObject::ascent(), atSpace(), attributes(), atWordSeparator(), bidiItemize(), boundingBox(), calculateTabWidth(), QTextLine::cursorToX(), QTextInlineObject::descent(), QTextLine::draw(), drawMenuText(), QPainter::drawText(), elidedText(), findItem(), QTextInlineObject::format(), QTextInlineObject::formatIndex(), formatIndex(), freeMemory(), QTextInlineObject::height(), init(), insertionPointsForLine(), isRightToLeft(), itemize(), justify(), QTextLine::layout_helper(), lineNumberForTextPosition(), QTextLineItemIterator::next(), nextLogicalPosition(), positionAfterVisualMovement(), QStackTextEngine::QStackTextEngine(), QTextLineItemIterator::QTextLineItemIterator(), QTextInlineObject::rect(), resolveAdditionalFormats(), QTextInlineObject::setAscent(), setBoundary(), QTextInlineObject::setDescent(), QTextLine::setLineWidth(), QTextInlineObject::setWidth(), shape(), splitItem(), QTextInlineObject::textDirection(), QTextInlineObject::textPosition(), tightBoundingBox(), validate(), QTextInlineObject::width(), width(), QTextLine::xToCursor(), and ~QTextEngine().

lines

QScriptLineArray QTextEngine::lines

mutable

Definition at line 562 of file qtextengine_p.h.

Referenced by addSelectedRegionsToPath(), QPainterPath::addText(), QTextLine::ascent(), clearLineData(), QTextLine::cursorToX(), QTextLine::descent(), QTextLine::draw(), freeMemory(), QTextLine::glyphs(), QTextLine::height(), QTextLine::horizontalAdvance(), insertionPointsForLine(), QTextLine::layout_helper(), QTextLine::leading(), QTextLine::leadingIncluded(), lineNumberForTextPosition(), QTextLine::naturalTextRect(), QTextLine::naturalTextWidth(), QTextLine::position(), positionAfterVisualMovement(), qt_format_text(), QTextLine::rect(), QTextLine::setLeadingIncluded(), QTextLine::setLineWidth(), QTextLine::setNumColumns(), QTextLine::setPosition(), QTextLine::textLength(), QTextLine::textStart(), QTextLine::width(), QTextLine::x(), QTextLine::xToCursor(), and QTextLine::y().

maxWidth

QFixed QTextEngine::maxWidth

Definition at line 588 of file qtextengine_p.h.

Referenced by init(), invalidate(), and QTextLine::layout_helper().

minWidth

QFixed QTextEngine::minWidth

Definition at line 587 of file qtextengine_p.h.

Referenced by init(), invalidate(), and QTextLine::layout_helper().

option

QTextOption QTextEngine::option

Definition at line 585 of file qtextengine_p.h.

Referenced by alignLine(), calculateTabWidth(), QTextLine::cursorToX(), QTextLine::draw(), QPainter::drawText(), isRightToLeft(), itemize(), justify(), QTextLine::layout_helper(), leadingSpaceWidth(), qt_format_text(), QTextLine::textLength(), and validate().

position

QPointF QTextEngine::position

Definition at line 589 of file qtextengine_p.h.

Referenced by calculateTabWidth(), findItem(), and itemize().

specialData

SpecialData* QTextEngine::specialData

Definition at line 614 of file qtextengine_p.h.

Referenced by addRequiredBoundaries(), format(), formatIndex(), indexAdditionalFormats(), init(), invalidate(), itemize(), resolveAdditionalFormats(), validate(), and ~QTextEngine().

stackEngine

uint QTextEngine::stackEngine

Definition at line 592 of file qtextengine_p.h.

Referenced by freeMemory(), init(), QStackTextEngine::QStackTextEngine(), and ~QTextEngine().

text

QString QTextEngine::text

Definition at line 581 of file qtextengine_p.h.

Referenced by validate().

underlinePositions

int* QTextEngine::underlinePositions

Definition at line 596 of file qtextengine_p.h.

Referenced by QTextLine::draw(), drawMenuText(), init(), and qt_format_text().

visualMovement

uint QTextEngine::visualMovement

Definition at line 594 of file qtextengine_p.h.

Referenced by init().

---

The documentation for this class was generated from the following files:

• /src/gui/text/qtextengine_p.h
• /src/gui/text/qtextengine.cpp
• /src/gui/text/qtextengine_mac.cpp