Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

qtextengine.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago
trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 97.7 KB

Rev	Line
[2]	1	/****************************************************************************
	2	**
[846]	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
[561]	4	** All rights reserved.
	5	** Contact: Nokia Corporation (qt-info@nokia.com)
[2]	6	**
	7	** This file is part of the QtGui module of the Qt Toolkit.
	8	**
	9	** $QT_BEGIN_LICENSE:LGPL$
	10	** Commercial Usage
	11	** Licensees holding valid Qt Commercial licenses may use this file in
	12	** accordance with the Qt Commercial License Agreement provided with the
	13	** Software or, alternatively, in accordance with the terms contained in
	14	** a written agreement between you and Nokia.
	15	**
	16	** GNU Lesser General Public License Usage
	17	** Alternatively, this file may be used under the terms of the GNU Lesser
	18	** General Public License version 2.1 as published by the Free Software
	19	** Foundation and appearing in the file LICENSE.LGPL included in the
	20	** packaging of this file. Please review the following information to
	21	** ensure the GNU Lesser General Public License version 2.1 requirements
	22	** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	23	**
[561]	24	** In addition, as a special exception, Nokia gives you certain additional
	25	** rights. These rights are described in the Nokia Qt LGPL Exception
	26	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
[2]	27	**
	28	** GNU General Public License Usage
	29	** Alternatively, this file may be used under the terms of the GNU
	30	** General Public License version 3.0 as published by the Free Software
	31	** Foundation and appearing in the file LICENSE.GPL included in the
	32	** packaging of this file. Please review the following information to
	33	** ensure the GNU General Public License version 3.0 requirements will be
	34	** met: http://www.gnu.org/copyleft/gpl.html.
	35	**
[561]	36	** If you have questions regarding the use of this file, please contact
	37	** Nokia at qt-info@nokia.com.
[2]	38	** $QT_END_LICENSE$
	39	**
	40	****************************************************************************/
	41
	42	#include "qdebug.h"
	43	#include "qtextformat.h"
	44	#include "qtextformat_p.h"
	45	#include "qtextengine_p.h"
	46	#include "qabstracttextdocumentlayout.h"
	47	#include "qtextlayout.h"
	48	#include "qtextboundaryfinder.h"
	49	#include "qvarlengtharray.h"
	50	#include "qfont.h"
	51	#include "qfont_p.h"
	52	#include "qfontengine_p.h"
	53	#include "qstring.h"
	54	#include <private/qunicodetables_p.h>
	55	#include "qtextdocument_p.h"
	56	#include <qapplication.h>
	57	#include <stdlib.h>
	58
	59
	60	QT_BEGIN_NAMESPACE
	61
	62	namespace {
	63	// Helper class used in QTextEngine::itemize
	64	// keep it out here to allow us to keep supporting various compilers.
	65	class Itemizer {
	66	public:
	67	Itemizer(const QString &string, const QScriptAnalysis *analysis, QScriptItemArray &items)
	68	: m_string(string),
	69	m_analysis(analysis),
	70	m_items(items),
	71	m_splitter(0)
	72	{
	73	}
	74	~Itemizer()
	75	{
	76	delete m_splitter;
	77	}
	78
	79	/// generate the script items
	80	/// The caps parameter is used to choose the algoritm of splitting text and assiging roles to the textitems
	81	void generate(int start, int length, QFont::Capitalization caps)
	82	{
	83	if ((int)caps == (int)QFont::SmallCaps)
[769]	84	generateScriptItemsSmallCaps(reinterpret_cast<const ushort *>(m_string.unicode()), start, length);
[2]	85	else if(caps == QFont::Capitalize)
	86	generateScriptItemsCapitalize(start, length);
	87	else if(caps != QFont::MixedCase) {
	88	generateScriptItemsAndChangeCase(start, length,
	89	caps == QFont::AllLowercase ? QScriptAnalysis::Lowercase : QScriptAnalysis::Uppercase);
	90	}
	91	else
	92	generateScriptItems(start, length);
	93	}
	94
	95	private:
	96	enum { MaxItemLength = 4096 };
	97
	98	void generateScriptItemsAndChangeCase(int start, int length, QScriptAnalysis::Flags flags)
	99	{
	100	generateScriptItems(start, length);
	101	if (m_items.isEmpty()) // the next loop won't work in that case
	102	return;
	103	QScriptItemArray::Iterator iter = m_items.end();
	104	do {
	105	iter--;
	106	if (iter->analysis.flags < QScriptAnalysis::TabOrObject)
	107	iter->analysis.flags = flags;
	108	} while (iter->position > start);
	109	}
	110
	111	void generateScriptItems(int start, int length)
	112	{
	113	if (!length)
	114	return;
	115	const int end = start + length;
	116	for (int i = start + 1; i < end; ++i) {
	117	if ((m_analysis[i] == m_analysis[start])
	118	&& m_analysis[i].flags < QScriptAnalysis::SpaceTabOrObject
	119	&& i - start < MaxItemLength)
	120	continue;
	121	m_items.append(QScriptItem(start, m_analysis[start]));
	122	start = i;
	123	}
	124	m_items.append(QScriptItem(start, m_analysis[start]));
	125	}
	126
	127	void generateScriptItemsCapitalize(int start, int length)
	128	{
	129	if (!length)
	130	return;
	131
	132	if (!m_splitter)
	133	m_splitter = new QTextBoundaryFinder(QTextBoundaryFinder::Word,
	134	m_string.constData(), m_string.length(),
	135	/buffer/0, /buffer size/0);
	136
	137	m_splitter->setPosition(start);
	138	QScriptAnalysis itemAnalysis = m_analysis[start];
	139
	140	if (m_splitter->boundaryReasons() & QTextBoundaryFinder::StartWord) {
	141	itemAnalysis.flags = QScriptAnalysis::Uppercase;
	142	m_splitter->toNextBoundary();
	143	}
	144
	145	const int end = start + length;
	146	for (int i = start + 1; i < end; ++i) {
	147
	148	bool atWordBoundary = false;
	149
	150	if (i == m_splitter->position()) {
	151	if (m_splitter->boundaryReasons() & QTextBoundaryFinder::StartWord
	152	&& m_analysis[i].flags < QScriptAnalysis::TabOrObject)
	153	atWordBoundary = true;
	154
	155	m_splitter->toNextBoundary();
	156	}
	157
	158	if (m_analysis[i] == itemAnalysis
	159	&& m_analysis[i].flags < QScriptAnalysis::TabOrObject
	160	&& !atWordBoundary
	161	&& i - start < MaxItemLength)
	162	continue;
	163
	164	m_items.append(QScriptItem(start, itemAnalysis));
	165	start = i;
	166	itemAnalysis = m_analysis[start];
	167
	168	if (atWordBoundary)
	169	itemAnalysis.flags = QScriptAnalysis::Uppercase;
	170	}
	171	m_items.append(QScriptItem(start, itemAnalysis));
	172	}
	173
	174	void generateScriptItemsSmallCaps(const ushort *uc, int start, int length)
	175	{
	176	if (!length)
	177	return;
	178	bool lower = (QChar::category(uc[start]) == QChar::Letter_Lowercase);
	179	const int end = start + length;
	180	// split text into parts that are already uppercase and parts that are lowercase, and mark the latter to be uppercased later.
	181	for (int i = start + 1; i < end; ++i) {
	182	bool l = (QChar::category(uc[i]) == QChar::Letter_Lowercase);
	183	if ((m_analysis[i] == m_analysis[start])
	184	&& m_analysis[i].flags < QScriptAnalysis::TabOrObject
	185	&& l == lower
	186	&& i - start < MaxItemLength)
	187	continue;
	188	m_items.append(QScriptItem(start, m_analysis[start]));
	189	if (lower)
	190	m_items.last().analysis.flags = QScriptAnalysis::SmallCaps;
	191
	192	start = i;
	193	lower = l;
	194	}
	195	m_items.append(QScriptItem(start, m_analysis[start]));
	196	if (lower)
	197	m_items.last().analysis.flags = QScriptAnalysis::SmallCaps;
	198	}
	199
	200	const QString &m_string;
	201	const QScriptAnalysis * const m_analysis;
	202	QScriptItemArray &m_items;
	203	QTextBoundaryFinder *m_splitter;
	204	};
	205	}
	206
	207
	208	// ----------------------------------------------------------------------------
	209	//
	210	// The BiDi algorithm
	211	//
	212	// ----------------------------------------------------------------------------
	213
	214	#define BIDI_DEBUG 0
	215	#if (BIDI_DEBUG >= 1)
	216	QT_BEGIN_INCLUDE_NAMESPACE
	217	#include <iostream>
	218	QT_END_INCLUDE_NAMESPACE
	219	using namespace std;
	220
	221	static const char *directions[] = {
	222	"DirL", "DirR", "DirEN", "DirES", "DirET", "DirAN", "DirCS", "DirB", "DirS", "DirWS", "DirON",
	223	"DirLRE", "DirLRO", "DirAL", "DirRLE", "DirRLO", "DirPDF", "DirNSM", "DirBN"
	224	};
	225
	226	#endif
	227
	228	struct QBidiStatus {
	229	QBidiStatus() {
	230	eor = QChar::DirON;
	231	lastStrong = QChar::DirON;
	232	last = QChar:: DirON;
	233	dir = QChar::DirON;
	234	}
	235	QChar::Direction eor;
	236	QChar::Direction lastStrong;
	237	QChar::Direction last;
	238	QChar::Direction dir;
	239	};
	240
	241	enum { MaxBidiLevel = 61 };
	242
	243	struct QBidiControl {
	244	inline QBidiControl(bool rtl)
	245	: cCtx(0), base(rtl ? 1 : 0), level(rtl ? 1 : 0), override(false) {}
	246
	247	inline void embed(bool rtl, bool o = false) {
	248	unsigned int toAdd = 1;
	249	if((level%2 != 0) == rtl ) {
	250	++toAdd;
	251	}
	252	if (level + toAdd <= MaxBidiLevel) {
	253	ctx[cCtx].level = level;
	254	ctx[cCtx].override = override;
	255	cCtx++;
	256	override = o;
	257	level += toAdd;
	258	}
	259	}
	260	inline bool canPop() const { return cCtx != 0; }
	261	inline void pdf() {
	262	Q_ASSERT(cCtx);
	263	--cCtx;
	264	level = ctx[cCtx].level;
	265	override = ctx[cCtx].override;
	266	}
	267
	268	inline QChar::Direction basicDirection() const {
	269	return (base ? QChar::DirR : QChar:: DirL);
	270	}
	271	inline unsigned int baseLevel() const {
	272	return base;
	273	}
	274	inline QChar::Direction direction() const {
	275	return ((level%2) ? QChar::DirR : QChar:: DirL);
	276	}
	277
	278	struct {
	279	unsigned int level;
	280	bool override;
	281	} ctx[MaxBidiLevel];
	282	unsigned int cCtx;
	283	const unsigned int base;
	284	unsigned int level;
	285	bool override;
	286	};
	287
	288
	289	static void appendItems(QScriptAnalysis *analysis, int &start, int &stop, const QBidiControl &control, QChar::Direction dir)
	290	{
	291	if (start > stop)
	292	return;
	293
	294	int level = control.level;
	295
	296	if(dir != QChar::DirON && !control.override) {
	297	// add level of run (cases I1 & I2)
	298	if(level % 2) {
	299	if(dir == QChar::DirL \|\| dir == QChar::DirAN \|\| dir == QChar::DirEN)
	300	level++;
	301	} else {
	302	if(dir == QChar::DirR)
	303	level++;
	304	else if(dir == QChar::DirAN \|\| dir == QChar::DirEN)
	305	level += 2;
	306	}
	307	}
	308
	309	#if (BIDI_DEBUG >= 1)
	310	qDebug("new run: dir=%s from %d, to %d level = %d override=%d", directions[dir], start, stop, level, control.override);
	311	#endif
	312	QScriptAnalysis *s = analysis + start;
	313	const QScriptAnalysis *e = analysis + stop;
	314	while (s <= e) {
	315	s->bidiLevel = level;
	316	++s;
	317	}
	318	++stop;
	319	start = stop;
	320	}
	321
	322
	323	// creates the next QScript items.
	324	static bool bidiItemize(QTextEngine engine, QScriptAnalysis analysis, QBidiControl &control)
	325	{
	326	bool rightToLeft = (control.basicDirection() == 1);
	327	bool hasBidi = rightToLeft;
	328	#if BIDI_DEBUG >= 2
	329	qDebug() << "bidiItemize: rightToLeft=" << rightToLeft << engine->layoutData->string;
	330	#endif
	331
	332	int sor = 0;
	333	int eor = -1;
	334
	335
	336	int length = engine->layoutData->string.length();
	337
	338	const ushort unicode = (const ushort )engine->layoutData->string.unicode();
	339	int current = 0;
	340
	341	QChar::Direction dir = rightToLeft ? QChar::DirR : QChar::DirL;
	342	QBidiStatus status;
	343
	344	QChar::Direction sdir = QChar::direction(*unicode);
	345	if (sdir != QChar::DirL && sdir != QChar::DirR && sdir != QChar::DirEN && sdir != QChar::DirAN)
	346	sdir = QChar::DirON;
	347	else
	348	dir = QChar::DirON;
	349	status.eor = sdir;
	350	status.lastStrong = rightToLeft ? QChar::DirR : QChar::DirL;
	351	status.last = status.lastStrong;
	352	status.dir = sdir;
	353
	354
	355	while (current <= length) {
	356
	357	QChar::Direction dirCurrent;
	358	if (current == (int)length)
	359	dirCurrent = control.basicDirection();
	360	else
	361	dirCurrent = QChar::direction(unicode[current]);
	362
	363	#if (BIDI_DEBUG >= 2)
	364	// qDebug() << "pos=" << current << " dir=" << directions[dir]
	365	// << " current=" << directions[dirCurrent] << " last=" << directions[status.last]
[561]	366	// << " eor=" << eor << '/' << directions[status.eor]
[2]	367	// << " sor=" << sor << " lastStrong="
	368	// << directions[status.lastStrong]
	369	// << " level=" << (int)control.level << " override=" << (bool)control.override;
	370	#endif
	371
	372	switch(dirCurrent) {
	373
	374	// embedding and overrides (X1-X9 in the BiDi specs)
	375	case QChar::DirRLE:
	376	case QChar::DirRLO:
	377	case QChar::DirLRE:
	378	case QChar::DirLRO:
	379	{
	380	bool rtl = (dirCurrent == QChar::DirRLE \|\| dirCurrent == QChar::DirRLO);
	381	hasBidi \|= rtl;
	382	bool override = (dirCurrent == QChar::DirLRO \|\| dirCurrent == QChar::DirRLO);
	383
	384	unsigned int level = control.level+1;
	385	if ((level%2 != 0) == rtl) ++level;
	386	if(level < MaxBidiLevel) {
	387	eor = current-1;
	388	appendItems(analysis, sor, eor, control, dir);
	389	eor = current;
	390	control.embed(rtl, override);
	391	QChar::Direction edir = (rtl ? QChar::DirR : QChar::DirL);
	392	dir = status.eor = edir;
	393	status.lastStrong = edir;
	394	}
	395	break;
	396	}
	397	case QChar::DirPDF:
	398	{
	399	if (control.canPop()) {
	400	if (dir != control.direction()) {
	401	eor = current-1;
	402	appendItems(analysis, sor, eor, control, dir);
	403	dir = control.direction();
	404	}
	405	eor = current;
	406	appendItems(analysis, sor, eor, control, dir);
	407	control.pdf();
	408	dir = QChar::DirON; status.eor = QChar::DirON;
	409	status.last = control.direction();
	410	if (control.override)
	411	dir = control.direction();
	412	else
	413	dir = QChar::DirON;
	414	status.lastStrong = control.direction();
	415	}
	416	break;
	417	}
	418
	419	// strong types
	420	case QChar::DirL:
	421	if(dir == QChar::DirON)
	422	dir = QChar::DirL;
	423	switch(status.last)
	424	{
	425	case QChar::DirL:
	426	eor = current; status.eor = QChar::DirL; break;
	427	case QChar::DirR:
	428	case QChar::DirAL:
	429	case QChar::DirEN:
	430	case QChar::DirAN:
	431	if (eor >= 0) {
	432	appendItems(analysis, sor, eor, control, dir);
	433	dir = eor < length ? QChar::direction(unicode[eor]) : control.basicDirection();
	434	status.eor = dir;
	435	} else {
	436	eor = current; status.eor = dir;
	437	}
	438	break;
	439	case QChar::DirES:
	440	case QChar::DirET:
	441	case QChar::DirCS:
	442	case QChar::DirBN:
	443	case QChar::DirB:
	444	case QChar::DirS:
	445	case QChar::DirWS:
	446	case QChar::DirON:
	447	if(dir != QChar::DirL) {
	448	//last stuff takes embedding dir
	449	if(control.direction() == QChar::DirR) {
	450	if(status.eor != QChar::DirR) {
	451	// AN or EN
	452	appendItems(analysis, sor, eor, control, dir);
	453	status.eor = QChar::DirON;
	454	dir = QChar::DirR;
	455	}
	456	eor = current - 1;
	457	appendItems(analysis, sor, eor, control, dir);
	458	dir = eor < length ? QChar::direction(unicode[eor]) : control.basicDirection();
	459	status.eor = dir;
	460	} else {
	461	if(status.eor != QChar::DirL) {
	462	appendItems(analysis, sor, eor, control, dir);
	463	status.eor = QChar::DirON;
	464	dir = QChar::DirL;
	465	} else {
	466	eor = current; status.eor = QChar::DirL; break;
	467	}
	468	}
	469	} else {
	470	eor = current; status.eor = QChar::DirL;
	471	}
	472	default:
	473	break;
	474	}
	475	status.lastStrong = QChar::DirL;
	476	break;
	477	case QChar::DirAL:
	478	case QChar::DirR:
	479	hasBidi = true;
	480	if(dir == QChar::DirON) dir = QChar::DirR;
	481	switch(status.last)
	482	{
	483	case QChar::DirL:
	484	case QChar::DirEN:
	485	case QChar::DirAN:
	486	if (eor >= 0)
	487	appendItems(analysis, sor, eor, control, dir);
	488	// fall through
	489	case QChar::DirR:
	490	case QChar::DirAL:
	491	dir = QChar::DirR; eor = current; status.eor = QChar::DirR; break;
	492	case QChar::DirES:
	493	case QChar::DirET:
	494	case QChar::DirCS:
	495	case QChar::DirBN:
	496	case QChar::DirB:
	497	case QChar::DirS:
	498	case QChar::DirWS:
	499	case QChar::DirON:
	500	if(status.eor != QChar::DirR && status.eor != QChar::DirAL) {
	501	//last stuff takes embedding dir
	502	if(control.direction() == QChar::DirR
	503	\|\| status.lastStrong == QChar::DirR \|\| status.lastStrong == QChar::DirAL) {
	504	appendItems(analysis, sor, eor, control, dir);
	505	dir = QChar::DirR; status.eor = QChar::DirON;
	506	eor = current;
	507	} else {
	508	eor = current - 1;
	509	appendItems(analysis, sor, eor, control, dir);
	510	dir = QChar::DirR; status.eor = QChar::DirON;
	511	}
	512	} else {
	513	eor = current; status.eor = QChar::DirR;
	514	}
	515	default:
	516	break;
	517	}
	518	status.lastStrong = dirCurrent;
	519	break;
	520
	521	// weak types:
	522
	523	case QChar::DirNSM:
	524	if (eor == current-1)
	525	eor = current;
	526	break;
	527	case QChar::DirEN:
	528	// if last strong was AL change EN to AN
	529	if(status.lastStrong != QChar::DirAL) {
	530	if(dir == QChar::DirON) {
	531	if(status.lastStrong == QChar::DirL)
	532	dir = QChar::DirL;
	533	else
	534	dir = QChar::DirEN;
	535	}
	536	switch(status.last)
	537	{
	538	case QChar::DirET:
	539	if (status.lastStrong == QChar::DirR \|\| status.lastStrong == QChar::DirAL) {
	540	appendItems(analysis, sor, eor, control, dir);
	541	status.eor = QChar::DirON;
	542	dir = QChar::DirAN;
	543	}
	544	// fall through
	545	case QChar::DirEN:
	546	case QChar::DirL:
	547	eor = current;
	548	status.eor = dirCurrent;
	549	break;
	550	case QChar::DirR:
	551	case QChar::DirAL:
	552	case QChar::DirAN:
	553	if (eor >= 0)
	554	appendItems(analysis, sor, eor, control, dir);
	555	else
	556	eor = current;
	557	status.eor = QChar::DirEN;
	558	dir = QChar::DirAN; break;
	559	case QChar::DirES:
	560	case QChar::DirCS:
	561	if(status.eor == QChar::DirEN \|\| dir == QChar::DirAN) {
	562	eor = current; break;
	563	}
	564	case QChar::DirBN:
	565	case QChar::DirB:
	566	case QChar::DirS:
	567	case QChar::DirWS:
	568	case QChar::DirON:
	569	if(status.eor == QChar::DirR) {
	570	// neutrals go to R
	571	eor = current - 1;
	572	appendItems(analysis, sor, eor, control, dir);
	573	dir = QChar::DirON; status.eor = QChar::DirEN;
	574	dir = QChar::DirAN;
	575	}
	576	else if(status.eor == QChar::DirL \|\|
	577	(status.eor == QChar::DirEN && status.lastStrong == QChar::DirL)) {
	578	eor = current; status.eor = dirCurrent;
	579	} else {
	580	// numbers on both sides, neutrals get right to left direction
	581	if(dir != QChar::DirL) {
	582	appendItems(analysis, sor, eor, control, dir);
	583	dir = QChar::DirON; status.eor = QChar::DirON;
	584	eor = current - 1;
	585	dir = QChar::DirR;
	586	appendItems(analysis, sor, eor, control, dir);
	587	dir = QChar::DirON; status.eor = QChar::DirON;
	588	dir = QChar::DirAN;
	589	} else {
	590	eor = current; status.eor = dirCurrent;
	591	}
	592	}
	593	default:
	594	break;
	595	}
	596	break;
	597	}
	598	case QChar::DirAN:
	599	hasBidi = true;
	600	dirCurrent = QChar::DirAN;
	601	if(dir == QChar::DirON) dir = QChar::DirAN;
	602	switch(status.last)
	603	{
	604	case QChar::DirL:
	605	case QChar::DirAN:
	606	eor = current; status.eor = QChar::DirAN; break;
	607	case QChar::DirR:
	608	case QChar::DirAL:
	609	case QChar::DirEN:
	610	if (eor >= 0){
	611	appendItems(analysis, sor, eor, control, dir);
	612	} else {
	613	eor = current;
	614	}
	615	dir = QChar::DirON; status.eor = QChar::DirAN;
	616	break;
	617	case QChar::DirCS:
	618	if(status.eor == QChar::DirAN) {
	619	eor = current; break;
	620	}
	621	case QChar::DirES:
	622	case QChar::DirET:
	623	case QChar::DirBN:
	624	case QChar::DirB:
	625	case QChar::DirS:
	626	case QChar::DirWS:
	627	case QChar::DirON:
	628	if(status.eor == QChar::DirR) {
	629	// neutrals go to R
	630	eor = current - 1;
	631	appendItems(analysis, sor, eor, control, dir);
	632	status.eor = QChar::DirAN;
	633	dir = QChar::DirAN;
	634	} else if(status.eor == QChar::DirL \|\|
	635	(status.eor == QChar::DirEN && status.lastStrong == QChar::DirL)) {
	636	eor = current; status.eor = dirCurrent;
	637	} else {
	638	// numbers on both sides, neutrals get right to left direction
	639	if(dir != QChar::DirL) {
	640	appendItems(analysis, sor, eor, control, dir);
	641	status.eor = QChar::DirON;
	642	eor = current - 1;
	643	dir = QChar::DirR;
	644	appendItems(analysis, sor, eor, control, dir);
	645	status.eor = QChar::DirAN;
	646	dir = QChar::DirAN;
	647	} else {
	648	eor = current; status.eor = dirCurrent;
	649	}
	650	}
	651	default:
	652	break;
	653	}
	654	break;
	655	case QChar::DirES:
	656	case QChar::DirCS:
	657	break;
	658	case QChar::DirET:
	659	if(status.last == QChar::DirEN) {
	660	dirCurrent = QChar::DirEN;
	661	eor = current; status.eor = dirCurrent;
	662	}
	663	break;
	664
	665	// boundary neutrals should be ignored
	666	case QChar::DirBN:
	667	break;
	668	// neutrals
	669	case QChar::DirB:
	670	// ### what do we do with newline and paragraph separators that come to here?
	671	break;
	672	case QChar::DirS:
	673	// ### implement rule L1
	674	break;
	675	case QChar::DirWS:
	676	case QChar::DirON:
	677	break;
	678	default:
	679	break;
	680	}
	681
	682	//qDebug() << " after: dir=" << // dir << " current=" << dirCurrent << " last=" << status.last << " eor=" << status.eor << " lastStrong=" << status.lastStrong << " embedding=" << control.direction();
	683
	684	if(current >= (int)length) break;
	685
	686	// set status.last as needed.
	687	switch(dirCurrent) {
	688	case QChar::DirET:
	689	case QChar::DirES:
	690	case QChar::DirCS:
	691	case QChar::DirS:
	692	case QChar::DirWS:
	693	case QChar::DirON:
	694	switch(status.last)
	695	{
	696	case QChar::DirL:
	697	case QChar::DirR:
	698	case QChar::DirAL:
	699	case QChar::DirEN:
	700	case QChar::DirAN:
	701	status.last = dirCurrent;
	702	break;
	703	default:
	704	status.last = QChar::DirON;
	705	}
	706	break;
	707	case QChar::DirNSM:
	708	case QChar::DirBN:
	709	// ignore these
	710	break;
	711	case QChar::DirLRO:
	712	case QChar::DirLRE:
	713	status.last = QChar::DirL;
	714	break;
	715	case QChar::DirRLO:
	716	case QChar::DirRLE:
	717	status.last = QChar::DirR;
	718	break;
	719	case QChar::DirEN:
	720	if (status.last == QChar::DirL) {
	721	status.last = QChar::DirL;
	722	break;
	723	}
	724	// fall through
	725	default:
	726	status.last = dirCurrent;
	727	}
	728
	729	++current;
	730	}
	731
	732	#if (BIDI_DEBUG >= 1)
	733	qDebug() << "reached end of line current=" << current << ", eor=" << eor;
	734	#endif
	735	eor = current - 1; // remove dummy char
	736
	737	if (sor <= eor)
	738	appendItems(analysis, sor, eor, control, dir);
	739
	740	return hasBidi;
	741	}
	742
	743	void QTextEngine::bidiReorder(int numItems, const quint8 levels, int visualOrder)
	744	{
	745
	746	// first find highest and lowest levels
	747	quint8 levelLow = 128;
	748	quint8 levelHigh = 0;
	749	int i = 0;
	750	while (i < numItems) {
	751	//printf("level = %d\n", r->level);
	752	if (levels[i] > levelHigh)
	753	levelHigh = levels[i];
	754	if (levels[i] < levelLow)
	755	levelLow = levels[i];
	756	i++;
	757	}
	758
	759	// implements reordering of the line (L2 according to BiDi spec):
	760	// L2. From the highest level found in the text to the lowest odd level on each line,
	761	// reverse any contiguous sequence of characters that are at that level or higher.
	762
	763	// reversing is only done up to the lowest odd level
	764	if(!(levelLow%2)) levelLow++;
	765
	766	#if (BIDI_DEBUG >= 1)
	767	// qDebug() << "reorderLine: lineLow = " << (uint)levelLow << ", lineHigh = " << (uint)levelHigh;
	768	#endif
	769
	770	int count = numItems - 1;
	771	for (i = 0; i < numItems; i++)
	772	visualOrder[i] = i;
	773
	774	while(levelHigh >= levelLow) {
	775	int i = 0;
	776	while (i < count) {
	777	while(i < count && levels[i] < levelHigh) i++;
	778	int start = i;
	779	while(i <= count && levels[i] >= levelHigh) i++;
	780	int end = i-1;
	781
	782	if(start != end) {
	783	//qDebug() << "reversing from " << start << " to " << end;
	784	for(int j = 0; j < (end-start+1)/2; j++) {
	785	int tmp = visualOrder[start+j];
	786	visualOrder[start+j] = visualOrder[end-j];
	787	visualOrder[end-j] = tmp;
	788	}
	789	}
	790	i++;
	791	}
	792	levelHigh--;
	793	}
	794
	795	#if (BIDI_DEBUG >= 1)
	796	// qDebug() << "visual order is:";
	797	// for (i = 0; i < numItems; i++)
	798	// qDebug() << visualOrder[i];
	799	#endif
	800	}
	801
	802	QT_BEGIN_INCLUDE_NAMESPACE
	803
	804	#if defined(Q_WS_X11) \|\| defined (Q_WS_QWS)
	805	# include "qfontengine_ft_p.h"
	806	#elif defined(Q_WS_MAC)
	807	# include "qtextengine_mac.cpp"
	808	#endif
	809
	810	#include <private/qharfbuzz_p.h>
	811
	812	QT_END_INCLUDE_NAMESPACE
	813
	814	// ask the font engine to find out which glyphs (as an index in the specific font) to use for the text in one item.
	815	static bool stringToGlyphs(HB_ShaperItem item, QGlyphLayout glyphs, QFontEngine *fontEngine)
	816	{
	817	int nGlyphs = item->num_glyphs;
	818
	819	QTextEngine::ShaperFlags shaperFlags(QTextEngine::GlyphIndicesOnly);
	820	if (item->item.bidiLevel % 2)
	821	shaperFlags \|= QTextEngine::RightToLeft;
	822
	823	bool result = fontEngine->stringToCMap(reinterpret_cast<const QChar *>(item->string + item->item.pos), item->item.length, glyphs, &nGlyphs, shaperFlags);
	824	item->num_glyphs = nGlyphs;
	825	glyphs->numGlyphs = nGlyphs;
	826	return result;
	827	}
	828
	829	// shape all the items that intersect with the line, taking tab widths into account to find out what text actually fits in the line.
	830	void QTextEngine::shapeLine(const QScriptLine &line)
	831	{
	832	QFixed x;
	833	bool first = true;
	834	const int end = findItem(line.from + line.length - 1);
	835	int item = findItem(line.from);
	836	if (item == -1)
	837	return;
	838	for (item = findItem(line.from); item <= end; ++item) {
	839	QScriptItem &si = layoutData->items[item];
	840	if (si.analysis.flags == QScriptAnalysis::Tab) {
	841	ensureSpace(1);
	842	si.width = calculateTabWidth(item, x);
	843	} else {
	844	shape(item);
	845	}
	846	if (first && si.position != line.from) { // that means our x position has to be offset
	847	QGlyphLayout glyphs = shapedGlyphs(&si);
	848	Q_ASSERT(line.from > si.position);
	849	for (int i = line.from - si.position - 1; i >= 0; i--) {
	850	x -= glyphs.effectiveAdvance(i);
	851	}
	852	}
	853	first = false;
	854
	855	x += si.width;
	856	}
	857	}
	858
[769]	859	Q_GUI_EXPORT extern int qt_defaultDpiY(); // in qfont.cpp
[2]	860
	861	void QTextEngine::shapeText(int item) const
	862	{
	863	Q_ASSERT(item < layoutData->items.size());
	864	QScriptItem &si = layoutData->items[item];
	865
	866	if (si.num_glyphs)
	867	return;
	868
	869	#if defined(Q_WS_MAC)
	870	shapeTextMac(item);
[561]	871	#elif defined(Q_WS_WINCE)
[2]	872	shapeTextWithCE(item);
	873	#else
	874	shapeTextWithHarfbuzz(item);
	875	#endif
	876
	877	si.width = 0;
	878
	879	if (!si.num_glyphs)
	880	return;
	881	QGlyphLayout glyphs = shapedGlyphs(&si);
	882
	883	QFont font = this->font(si);
	884	bool letterSpacingIsAbsolute = font.d->letterSpacingIsAbsolute;
	885	QFixed letterSpacing = font.d->letterSpacing;
	886	QFixed wordSpacing = font.d->wordSpacing;
	887
[846]	888	if (letterSpacingIsAbsolute && letterSpacing.value())
[2]	889	letterSpacing *= font.d->dpi / qt_defaultDpiY();
	890
	891	if (letterSpacing != 0) {
	892	for (int i = 1; i < si.num_glyphs; ++i) {
	893	if (glyphs.attributes[i].clusterStart) {
	894	if (letterSpacingIsAbsolute)
	895	glyphs.advances_x[i-1] += letterSpacing;
	896	else {
[846]	897	QFixed &advance = glyphs.advances_x[i-1];
	898	advance += (letterSpacing - 100) * advance / 100;
[2]	899	}
	900	}
	901	}
	902	if (letterSpacingIsAbsolute)
	903	glyphs.advances_x[si.num_glyphs-1] += letterSpacing;
	904	else {
[846]	905	QFixed &advance = glyphs.advances_x[si.num_glyphs-1];
	906	advance += (letterSpacing - 100) * advance / 100;
[2]	907	}
	908	}
	909	if (wordSpacing != 0) {
	910	for (int i = 0; i < si.num_glyphs; ++i) {
	911	if (glyphs.attributes[i].justification == HB_Space
	912	\|\| glyphs.attributes[i].justification == HB_Arabic_Space) {
	913	// word spacing only gets added once to a consecutive run of spaces (see CSS spec)
	914	if (i + 1 == si.num_glyphs
	915	\|\|(glyphs.attributes[i+1].justification != HB_Space
	916	&& glyphs.attributes[i+1].justification != HB_Arabic_Space))
	917	glyphs.advances_x[i] += wordSpacing;
	918	}
	919	}
	920	}
	921
	922	for (int i = 0; i < si.num_glyphs; ++i)
	923	si.width += glyphs.advances_x[i];
	924	}
	925
[846]	926	static inline bool hasCaseChange(const QScriptItem &si)
	927	{
	928	return si.analysis.flags == QScriptAnalysis::SmallCaps \|\|
	929	si.analysis.flags == QScriptAnalysis::Uppercase \|\|
	930	si.analysis.flags == QScriptAnalysis::Lowercase;
	931	}
	932
[561]	933	#if defined(Q_WS_WINCE) //TODO
[2]	934	// set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs
	935	// and no reordering.
	936	// also computes logClusters heuristically
	937	static void heuristicSetGlyphAttributes(const QChar uc, int length, QGlyphLayout glyphs, unsigned short *logClusters, int num_glyphs)
	938	{
	939	// ### zeroWidth and justification are missing here!!!!!
	940
	941	Q_UNUSED(num_glyphs);
	942	Q_ASSERT(num_glyphs <= length);
	943
	944	// qDebug("QScriptEngine::heuristicSetGlyphAttributes, num_glyphs=%d", item->num_glyphs);
	945
	946	int glyph_pos = 0;
	947	for (int i = 0; i < length; i++) {
	948	if (uc[i].unicode() >= 0xd800 && uc[i].unicode() < 0xdc00 && i < length-1
	949	&& uc[i+1].unicode() >= 0xdc00 && uc[i+1].unicode() < 0xe000) {
	950	logClusters[i] = glyph_pos;
	951	logClusters[++i] = glyph_pos;
	952	} else {
	953	logClusters[i] = glyph_pos;
	954	}
	955	++glyph_pos;
	956	}
	957
	958	// first char in a run is never (treated as) a mark
	959	int cStart = 0;
	960
	961	const bool symbolFont = false; // ####
	962	glyphs->attributes[0].mark = false;
	963	glyphs->attributes[0].clusterStart = true;
	964	glyphs->attributes[0].dontPrint = (!symbolFont && uc[0].unicode() == 0x00ad) \|\| qIsControlChar(uc[0].unicode());
	965
	966	int pos = 0;
	967	int lastCat = QChar::category(uc[0].unicode());
	968	for (int i = 1; i < length; ++i) {
	969	if (logClusters[i] == pos)
	970	// same glyph
	971	continue;
	972	++pos;
	973	while (pos < logClusters[i]) {
	974	glyphs[pos].attributes = glyphs[pos-1].attributes;
	975	++pos;
	976	}
	977	// hide soft-hyphens by default
	978	if ((!symbolFont && uc[i].unicode() == 0x00ad) \|\| qIsControlChar(uc[i].unicode()))
	979	glyphs->attributes[pos].dontPrint = true;
	980	const QUnicodeTables::Properties *prop = QUnicodeTables::properties(uc[i].unicode());
	981	int cat = prop->category;
	982	if (cat != QChar::Mark_NonSpacing) {
	983	glyphs->attributes[pos].mark = false;
	984	glyphs->attributes[pos].clusterStart = true;
	985	glyphs->attributes[pos].combiningClass = 0;
	986	cStart = logClusters[i];
	987	} else {
	988	int cmb = prop->combiningClass;
	989
	990	if (cmb == 0) {
	991	// Fix 0 combining classes
	992	if ((uc[pos].unicode() & 0xff00) == 0x0e00) {
	993	// thai or lao
	994	unsigned char col = uc[pos].cell();
	995	if (col == 0x31 \|\|
	996	col == 0x34 \|\|
	997	col == 0x35 \|\|
	998	col == 0x36 \|\|
	999	col == 0x37 \|\|
	1000	col == 0x47 \|\|
	1001	col == 0x4c \|\|
	1002	col == 0x4d \|\|
	1003	col == 0x4e) {
	1004	cmb = QChar::Combining_AboveRight;
	1005	} else if (col == 0xb1 \|\|
	1006	col == 0xb4 \|\|
	1007	col == 0xb5 \|\|
	1008	col == 0xb6 \|\|
	1009	col == 0xb7 \|\|
	1010	col == 0xbb \|\|
	1011	col == 0xcc \|\|
	1012	col == 0xcd) {
	1013	cmb = QChar::Combining_Above;
	1014	} else if (col == 0xbc) {
	1015	cmb = QChar::Combining_Below;
	1016	}
	1017	}
	1018	}
	1019
	1020	glyphs->attributes[pos].mark = true;
	1021	glyphs->attributes[pos].clusterStart = false;
	1022	glyphs->attributes[pos].combiningClass = cmb;
	1023	logClusters[i] = cStart;
	1024	glyphs->advances_x[pos] = 0;
	1025	glyphs->advances_y[pos] = 0;
	1026	}
	1027
	1028	// one gets an inter character justification point if the current char is not a non spacing mark.
	1029	// as then the current char belongs to the last one and one gets a space justification point
	1030	// after the space char.
	1031	if (lastCat == QChar::Separator_Space)
	1032	glyphs->attributes[pos-1].justification = HB_Space;
	1033	else if (cat != QChar::Mark_NonSpacing)
	1034	glyphs->attributes[pos-1].justification = HB_Character;
	1035	else
	1036	glyphs->attributes[pos-1].justification = HB_NoJustification;
	1037
	1038	lastCat = cat;
	1039	}
	1040	pos = logClusters[length-1];
	1041	if (lastCat == QChar::Separator_Space)
	1042	glyphs->attributes[pos].justification = HB_Space;
	1043	else
	1044	glyphs->attributes[pos].justification = HB_Character;
	1045	}
	1046
	1047	void QTextEngine::shapeTextWithCE(int item) const
	1048	{
	1049	QScriptItem &si = layoutData->items[item];
	1050	si.glyph_data_offset = layoutData->used;
	1051
[561]	1052	QFontEngine *fe = fontEngine(si, &si.ascent, &si.descent, &si.leading);
[2]	1053
	1054	QTextEngine::ShaperFlags flags;
	1055	if (si.analysis.bidiLevel % 2)
	1056	flags \|= RightToLeft;
	1057	if (option.useDesignMetrics())
	1058	flags \|= DesignMetrics;
	1059
[846]	1060	// pre-initialize char attributes
	1061	if (! attributes())
	1062	return;
[2]	1063
	1064	const int len = length(item);
	1065	int num_glyphs = length(item);
	1066	const QChar *str = layoutData->string.unicode() + si.position;
	1067	ushort upperCased[256];
[846]	1068	if (hasCaseChange(si)) {
[2]	1069	ushort *uc = upperCased;
	1070	if (len > 256)
	1071	uc = new ushort[len];
	1072	for (int i = 0; i < len; ++i) {
	1073	if(si.analysis.flags == QScriptAnalysis::Lowercase)
	1074	uc[i] = str[i].toLower().unicode();
	1075	else
	1076	uc[i] = str[i].toUpper().unicode();
	1077	}
	1078	str = reinterpret_cast<const QChar *>(uc);
	1079	}
	1080
	1081	while (true) {
[846]	1082	if (! ensureSpace(num_glyphs)) {
	1083	// If str is converted to uppercase/lowercase form with a new buffer,
	1084	// we need to delete that buffer before return for error
	1085	const ushort uc = reinterpret_cast<const ushort >(str);
	1086	if (hasCaseChange(si) && uc != upperCased)
	1087	delete [] uc;
	1088	return;
	1089	}
[2]	1090	num_glyphs = layoutData->glyphLayout.numGlyphs - layoutData->used;
	1091
	1092	QGlyphLayout g = availableGlyphs(&si);
	1093	unsigned short *log_clusters = logClusters(&si);
	1094
	1095	if (fe->stringToCMap(str,
	1096	len,
	1097	&g,
	1098	&num_glyphs,
	1099	flags)) {
	1100	heuristicSetGlyphAttributes(str, len, &g, log_clusters, num_glyphs);
	1101	break;
	1102	}
	1103	}
	1104
	1105	si.num_glyphs = num_glyphs;
	1106
	1107	layoutData->used += si.num_glyphs;
	1108
	1109	const ushort uc = reinterpret_cast<const ushort >(str);
[846]	1110	if (hasCaseChange(si) && uc != upperCased)
[2]	1111	delete [] uc;
	1112	}
	1113	#endif
	1114
[561]	1115	static inline void moveGlyphData(const QGlyphLayout &destination, const QGlyphLayout &source, int num)
	1116	{
	1117	if (num > 0 && destination.glyphs != source.glyphs) {
	1118	memmove(destination.glyphs, source.glyphs, num * sizeof(HB_Glyph));
	1119	memmove(destination.attributes, source.attributes, num * sizeof(HB_GlyphAttributes));
	1120	memmove(destination.advances_x, source.advances_x, num * sizeof(HB_Fixed));
	1121	memmove(destination.offsets, source.offsets, num * sizeof(HB_FixedPoint));
	1122	}
	1123	}
	1124
[2]	1125	/// take the item from layoutData->items and
	1126	void QTextEngine::shapeTextWithHarfbuzz(int item) const
	1127	{
	1128	Q_ASSERT(sizeof(HB_Fixed) == sizeof(QFixed));
	1129	Q_ASSERT(sizeof(HB_FixedPoint) == sizeof(QFixedPoint));
	1130
	1131	QScriptItem &si = layoutData->items[item];
	1132
	1133	si.glyph_data_offset = layoutData->used;
	1134
[561]	1135	QFontEngine *font = fontEngine(si, &si.ascent, &si.descent, &si.leading);
[2]	1136
	1137	bool kerningEnabled = this->font(si).d->kerning;
	1138
	1139	HB_ShaperItem entire_shaper_item;
[846]	1140	qMemSet(&entire_shaper_item, 0, sizeof(entire_shaper_item));
[2]	1141	entire_shaper_item.string = reinterpret_cast<const HB_UChar16 *>(layoutData->string.constData());
	1142	entire_shaper_item.stringLength = layoutData->string.length();
	1143	entire_shaper_item.item.script = (HB_Script)si.analysis.script;
	1144	entire_shaper_item.item.pos = si.position;
	1145	entire_shaper_item.item.length = length(item);
	1146	entire_shaper_item.item.bidiLevel = si.analysis.bidiLevel;
	1147
	1148	HB_UChar16 upperCased[256]; // XXX what about making this 4096, so we don't have to extend it ever.
[846]	1149	if (hasCaseChange(si)) {
[2]	1150	HB_UChar16 *uc = upperCased;
	1151	if (entire_shaper_item.item.length > 256)
	1152	uc = new HB_UChar16[entire_shaper_item.item.length];
	1153	for (uint i = 0; i < entire_shaper_item.item.length; ++i) {
	1154	if(si.analysis.flags == QScriptAnalysis::Lowercase)
	1155	uc[i] = QChar::toLower(entire_shaper_item.string[si.position + i]);
	1156	else
	1157	uc[i] = QChar::toUpper(entire_shaper_item.string[si.position + i]);
	1158	}
	1159	entire_shaper_item.item.pos = 0;
	1160	entire_shaper_item.string = uc;
	1161	entire_shaper_item.stringLength = entire_shaper_item.item.length;
	1162	}
	1163
	1164	entire_shaper_item.shaperFlags = 0;
	1165	if (!kerningEnabled)
	1166	entire_shaper_item.shaperFlags \|= HB_ShaperFlag_NoKerning;
	1167	if (option.useDesignMetrics())
	1168	entire_shaper_item.shaperFlags \|= HB_ShaperFlag_UseDesignMetrics;
	1169
	1170	entire_shaper_item.num_glyphs = qMax(layoutData->glyphLayout.numGlyphs - layoutData->used, int(entire_shaper_item.item.length));
[846]	1171	if (! ensureSpace(entire_shaper_item.num_glyphs)) {
	1172	if (hasCaseChange(si))
	1173	delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
	1174	return;
	1175	}
[2]	1176	QGlyphLayout initialGlyphs = availableGlyphs(&si).mid(0, entire_shaper_item.num_glyphs);
	1177
	1178	if (!stringToGlyphs(&entire_shaper_item, &initialGlyphs, font)) {
[846]	1179	if (! ensureSpace(entire_shaper_item.num_glyphs)) {
	1180	if (hasCaseChange(si))
	1181	delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
	1182	return;
	1183	}
[2]	1184	initialGlyphs = availableGlyphs(&si).mid(0, entire_shaper_item.num_glyphs);
	1185
	1186	if (!stringToGlyphs(&entire_shaper_item, &initialGlyphs, font)) {
	1187	// ############ if this happens there's a bug in the fontengine
[846]	1188	if (hasCaseChange(si) && entire_shaper_item.string != upperCased)
[2]	1189	delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
	1190	return;
	1191	}
	1192	}
	1193
	1194	// split up the item into parts that come from different font engines.
	1195	QVarLengthArray<int> itemBoundaries(2);
	1196	// k * 2 entries, array[k] == index in string, array[k + 1] == index in glyphs
	1197	itemBoundaries[0] = entire_shaper_item.item.pos;
	1198	itemBoundaries[1] = 0;
	1199
	1200	if (font->type() == QFontEngine::Multi) {
	1201	uint lastEngine = 0;
	1202	int charIdx = entire_shaper_item.item.pos;
	1203	const int stringEnd = charIdx + entire_shaper_item.item.length;
	1204	for (quint32 i = 0; i < entire_shaper_item.num_glyphs; ++i, ++charIdx) {
	1205	uint engineIdx = initialGlyphs.glyphs[i] >> 24;
	1206	if (engineIdx != lastEngine && i > 0) {
	1207	itemBoundaries.append(charIdx);
	1208	itemBoundaries.append(i);
	1209	}
	1210	lastEngine = engineIdx;
	1211	if (HB_IsHighSurrogate(entire_shaper_item.string[charIdx])
	1212	&& charIdx < stringEnd - 1
	1213	&& HB_IsLowSurrogate(entire_shaper_item.string[charIdx + 1]))
	1214	++charIdx;
	1215	}
	1216	}
	1217
	1218
	1219
[561]	1220	int remaining_glyphs = entire_shaper_item.num_glyphs;
[2]	1221	int glyph_pos = 0;
	1222	// for each item shape using harfbuzz and store the results in our layoutData's glyphs array.
	1223	for (int k = 0; k < itemBoundaries.size(); k += 2) { // for the +2, see the comment at the definition of itemBoundaries
	1224
	1225	HB_ShaperItem shaper_item = entire_shaper_item;
	1226
	1227	shaper_item.item.pos = itemBoundaries[k];
	1228	if (k < itemBoundaries.size() - 3) {
	1229	shaper_item.item.length = itemBoundaries[k + 2] - shaper_item.item.pos;
	1230	shaper_item.num_glyphs = itemBoundaries[k + 3] - itemBoundaries[k + 1];
	1231	} else { // last combo in the list, avoid out of bounds access.
	1232	shaper_item.item.length -= shaper_item.item.pos - entire_shaper_item.item.pos;
	1233	shaper_item.num_glyphs -= itemBoundaries[k + 1];
	1234	}
	1235	shaper_item.initialGlyphCount = shaper_item.num_glyphs;
	1236
	1237	QFontEngine *actualFontEngine = font;
	1238	uint engineIdx = 0;
	1239	if (font->type() == QFontEngine::Multi) {
[561]	1240	engineIdx = uint(availableGlyphs(&si).glyphs[glyph_pos] >> 24);
[2]	1241
	1242	actualFontEngine = static_cast<QFontEngineMulti *>(font)->engine(engineIdx);
	1243	}
	1244
	1245	shaper_item.font = actualFontEngine->harfbuzzFont();
	1246	shaper_item.face = actualFontEngine->harfbuzzFace();
	1247
	1248	shaper_item.glyphIndicesPresent = true;
	1249
[561]	1250	remaining_glyphs -= shaper_item.initialGlyphCount;
	1251
[2]	1252	do {
[846]	1253	if (! ensureSpace(glyph_pos + shaper_item.num_glyphs + remaining_glyphs)) {
	1254	if (hasCaseChange(si))
	1255	delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
	1256	return;
	1257	}
[2]	1258
[561]	1259	const QGlyphLayout g = availableGlyphs(&si).mid(glyph_pos);
	1260	moveGlyphData(g.mid(shaper_item.num_glyphs), g.mid(shaper_item.initialGlyphCount), remaining_glyphs);
[2]	1261
[561]	1262	shaper_item.glyphs = g.glyphs;
	1263	shaper_item.attributes = g.attributes;
	1264	shaper_item.advances = reinterpret_cast<HB_Fixed *>(g.advances_x);
	1265	shaper_item.offsets = reinterpret_cast<HB_FixedPoint *>(g.offsets);
	1266
[2]	1267	if (shaper_item.glyphIndicesPresent) {
	1268	for (hb_uint32 i = 0; i < shaper_item.initialGlyphCount; ++i)
	1269	shaper_item.glyphs[i] &= 0x00ffffff;
	1270	}
	1271
	1272	shaper_item.log_clusters = logClusters(&si) + shaper_item.item.pos - entire_shaper_item.item.pos;
	1273
	1274	// qDebug(" .. num_glyphs=%d, used=%d, item.num_glyphs=%d", num_glyphs, used, shaper_item.num_glyphs);
	1275	} while (!qShapeItem(&shaper_item)); // this does the actual shaping via harfbuzz.
	1276
	1277	QGlyphLayout g = availableGlyphs(&si).mid(glyph_pos, shaper_item.num_glyphs);
[561]	1278	moveGlyphData(g.mid(shaper_item.num_glyphs), g.mid(shaper_item.initialGlyphCount), remaining_glyphs);
[2]	1279
[561]	1280	for (hb_uint32 i = 0; i < shaper_item.num_glyphs; ++i)
[2]	1281	g.glyphs[i] = g.glyphs[i] \| (engineIdx << 24);
[561]	1282
	1283	for (hb_uint32 i = 0; i < shaper_item.item.length; ++i)
[2]	1284	shaper_item.log_clusters[i] += glyph_pos;
	1285
	1286	if (kerningEnabled && !shaper_item.kerning_applied)
	1287	font->doKerning(&g, option.useDesignMetrics() ? QFlag(QTextEngine::DesignMetrics) : QFlag(0));
	1288
	1289	glyph_pos += shaper_item.num_glyphs;
	1290	}
	1291
	1292	// qDebug(" -> item: script=%d num_glyphs=%d", shaper_item.script, shaper_item.num_glyphs);
	1293	si.num_glyphs = glyph_pos;
	1294
	1295	layoutData->used += si.num_glyphs;
	1296
[846]	1297	if (hasCaseChange(si) && entire_shaper_item.string != upperCased)
[2]	1298	delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
	1299	}
	1300
	1301	static void init(QTextEngine *e)
	1302	{
	1303	e->ignoreBidi = false;
	1304	e->cacheGlyphs = false;
	1305	e->forceJustification = false;
	1306
	1307	e->layoutData = 0;
	1308
	1309	e->minWidth = 0;
	1310	e->maxWidth = 0;
	1311
	1312	e->underlinePositions = 0;
	1313	e->specialData = 0;
	1314	e->stackEngine = false;
	1315	}
	1316
	1317	QTextEngine::QTextEngine()
	1318	{
	1319	init(this);
	1320	}
	1321
	1322	QTextEngine::QTextEngine(const QString &str, const QFont &f)
[846]	1323	: text(str),
	1324	fnt(f)
[2]	1325	{
	1326	init(this);
	1327	}
	1328
	1329	QTextEngine::~QTextEngine()
	1330	{
	1331	if (!stackEngine)
	1332	delete layoutData;
	1333	delete specialData;
	1334	}
	1335
	1336	const HB_CharAttributes *QTextEngine::attributes() const
	1337	{
	1338	if (layoutData && layoutData->haveCharAttributes)
	1339	return (HB_CharAttributes *) layoutData->memory;
	1340
	1341	itemize();
[846]	1342	if (! ensureSpace(layoutData->string.length()))
	1343	return NULL;
[2]	1344
	1345	QVarLengthArray<HB_ScriptItem> hbScriptItems(layoutData->items.size());
	1346
	1347	for (int i = 0; i < layoutData->items.size(); ++i) {
	1348	const QScriptItem &si = layoutData->items[i];
	1349	hbScriptItems[i].pos = si.position;
	1350	hbScriptItems[i].length = length(i);
	1351	hbScriptItems[i].bidiLevel = si.analysis.bidiLevel;
	1352	hbScriptItems[i].script = (HB_Script)si.analysis.script;
	1353	}
	1354
	1355	qGetCharAttributes(reinterpret_cast<const HB_UChar16 *>(layoutData->string.constData()),
	1356	layoutData->string.length(),
	1357	hbScriptItems.data(), hbScriptItems.size(),
	1358	(HB_CharAttributes *)layoutData->memory);
	1359
	1360
	1361	layoutData->haveCharAttributes = true;
	1362	return (HB_CharAttributes *) layoutData->memory;
	1363	}
	1364
	1365	void QTextEngine::shape(int item) const
	1366	{
	1367	if (layoutData->items[item].analysis.flags == QScriptAnalysis::Object) {
	1368	ensureSpace(1);
	1369	if (block.docHandle()) {
	1370	QTextFormat format = formats()->format(formatIndex(&layoutData->items[item]));
	1371	docLayout()->resizeInlineObject(QTextInlineObject(item, const_cast<QTextEngine *>(this)),
	1372	layoutData->items[item].position + block.position(), format);
	1373	}
	1374	} else if (layoutData->items[item].analysis.flags == QScriptAnalysis::Tab) {
[561]	1375	// set up at least the ascent/descent/leading of the script item for the tab
	1376	fontEngine(layoutData->items[item],
	1377	&layoutData->items[item].ascent,
	1378	&layoutData->items[item].descent,
	1379	&layoutData->items[item].leading);
[2]	1380	} else {
	1381	shapeText(item);
	1382	}
	1383	}
	1384
	1385	void QTextEngine::invalidate()
	1386	{
	1387	freeMemory();
	1388	minWidth = 0;
	1389	maxWidth = 0;
	1390	if (specialData)
	1391	specialData->resolvedFormatIndices.clear();
	1392	}
	1393
	1394	void QTextEngine::clearLineData()
	1395	{
	1396	lines.clear();
	1397	}
	1398
	1399	void QTextEngine::validate() const
	1400	{
	1401	if (layoutData)
	1402	return;
	1403	layoutData = new LayoutData();
	1404	if (block.docHandle()) {
	1405	layoutData->string = block.text();
	1406	if (option.flags() & QTextOption::ShowLineAndParagraphSeparators)
	1407	layoutData->string += QLatin1Char(block.next().isValid() ? 0xb6 : 0x20);
	1408	} else {
	1409	layoutData->string = text;
	1410	}
	1411	if (specialData && specialData->preeditPosition != -1)
	1412	layoutData->string.insert(specialData->preeditPosition, specialData->preeditText);
	1413	}
	1414
	1415	void QTextEngine::itemize() const
	1416	{
	1417	validate();
	1418	if (layoutData->items.size())
	1419	return;
	1420
	1421	int length = layoutData->string.length();
	1422	if (!length)
	1423	return;
[561]	1424	#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
	1425	// ATSUI requires RTL flags to correctly identify the character stops.
	1426	bool ignore = false;
	1427	#else
[2]	1428	bool ignore = ignoreBidi;
[561]	1429	#endif
[846]	1430
	1431	bool rtl = isRightToLeft();
	1432
	1433	if (!ignore && !rtl) {
[2]	1434	ignore = true;
	1435	const QChar *start = layoutData->string.unicode();
	1436	const QChar * const end = start + length;
	1437	while (start < end) {
	1438	if (start->unicode() >= 0x590) {
	1439	ignore = false;
	1440	break;
	1441	}
	1442	++start;
	1443	}
	1444	}
	1445
	1446	QVarLengthArray<QScriptAnalysis, 4096> scriptAnalysis(length);
	1447	QScriptAnalysis *analysis = scriptAnalysis.data();
	1448
[846]	1449	QBidiControl control(rtl);
[2]	1450
	1451	if (ignore) {
	1452	memset(analysis, 0, length*sizeof(QScriptAnalysis));
	1453	if (option.textDirection() == Qt::RightToLeft) {
	1454	for (int i = 0; i < length; ++i)
	1455	analysis[i].bidiLevel = 1;
	1456	layoutData->hasBidi = true;
	1457	}
	1458	} else {
	1459	layoutData->hasBidi = bidiItemize(const_cast<QTextEngine *>(this), analysis, control);
	1460	}
	1461
[769]	1462	const ushort uc = reinterpret_cast<const ushort >(layoutData->string.unicode());
[2]	1463	const ushort *e = uc + length;
	1464	int lastScript = QUnicodeTables::Common;
	1465	while (uc < e) {
	1466	int script = QUnicodeTables::script(*uc);
	1467	if (script == QUnicodeTables::Inherited)
	1468	script = lastScript;
	1469	analysis->flags = QScriptAnalysis::None;
	1470	if (*uc == QChar::ObjectReplacementCharacter) {
	1471	if (analysis->bidiLevel % 2)
	1472	--analysis->bidiLevel;
	1473	analysis->script = QUnicodeTables::Common;
	1474	analysis->flags = QScriptAnalysis::Object;
	1475	} else if (*uc == QChar::LineSeparator) {
	1476	if (analysis->bidiLevel % 2)
	1477	--analysis->bidiLevel;
	1478	analysis->script = QUnicodeTables::Common;
	1479	analysis->flags = QScriptAnalysis::LineOrParagraphSeparator;
	1480	if (option.flags() & QTextOption::ShowLineAndParagraphSeparators)
	1481	const_cast<ushort>(uc) = 0x21B5; // visual line separator
	1482	} else if (*uc == 9) {
	1483	analysis->script = QUnicodeTables::Common;
	1484	analysis->flags = QScriptAnalysis::Tab;
	1485	analysis->bidiLevel = control.baseLevel();
	1486	} else if ((uc == 32 \|\| uc == QChar::Nbsp)
	1487	&& (option.flags() & QTextOption::ShowTabsAndSpaces)) {
	1488	analysis->script = QUnicodeTables::Common;
	1489	analysis->flags = QScriptAnalysis::Space;
	1490	analysis->bidiLevel = control.baseLevel();
	1491	} else {
	1492	analysis->script = script;
	1493	}
	1494	lastScript = analysis->script;
	1495	++uc;
	1496	++analysis;
	1497	}
	1498	if (option.flags() & QTextOption::ShowLineAndParagraphSeparators) {
	1499	(analysis-1)->flags = QScriptAnalysis::LineOrParagraphSeparator; // to exclude it from width
	1500	}
	1501
	1502	Itemizer itemizer(layoutData->string, scriptAnalysis.data(), layoutData->items);
	1503
	1504	const QTextDocumentPrivate *p = block.docHandle();
	1505	if (p) {
	1506	SpecialData *s = specialData;
	1507
	1508	QTextDocumentPrivate::FragmentIterator it = p->find(block.position());
	1509	QTextDocumentPrivate::FragmentIterator end = p->find(block.position() + block.length() - 1); // -1 to omit the block separator char
	1510	int format = it.value()->format;
	1511
	1512	int prevPosition = 0;
	1513	int position = prevPosition;
	1514	while (1) {
	1515	const QTextFragmentData * const frag = it.value();
	1516	if (it == end \|\| format != frag->format) {
	1517	if (s && position >= s->preeditPosition) {
	1518	position += s->preeditText.length();
	1519	s = 0;
	1520	}
	1521	Q_ASSERT(position <= length);
	1522	itemizer.generate(prevPosition, position - prevPosition,
	1523	formats()->charFormat(format).fontCapitalization());
	1524	if (it == end) {
	1525	if (position < length)
	1526	itemizer.generate(position, length - position,
	1527	formats()->charFormat(format).fontCapitalization());
	1528	break;
	1529	}
	1530	format = frag->format;
	1531	prevPosition = position;
	1532	}
	1533	position += frag->size_array[0];
	1534	++it;
	1535	}
	1536	} else {
	1537	itemizer.generate(0, length, static_cast<QFont::Capitalization> (fnt.d->capital));
	1538	}
	1539
	1540	addRequiredBoundaries();
	1541	resolveAdditionalFormats();
	1542	}
	1543
[846]	1544	bool QTextEngine::isRightToLeft() const
	1545	{
	1546	switch (option.textDirection()) {
	1547	case Qt::LeftToRight:
	1548	return false;
	1549	case Qt::RightToLeft:
	1550	return true;
	1551	default:
	1552	break;
	1553	}
	1554	// this places the cursor in the right position depending on the keyboard layout
	1555	if (layoutData->string.isEmpty())
	1556	return QApplication::keyboardInputDirection() == Qt::RightToLeft;
	1557	return layoutData->string.isRightToLeft();
	1558	}
	1559
	1560
[2]	1561	int QTextEngine::findItem(int strPos) const
	1562	{
	1563	itemize();
[846]	1564	int left = 0;
	1565	int right = layoutData->items.size()-1;
	1566	while(left <= right) {
	1567	int middle = ((right-left)/2)+left;
	1568	if (strPos > layoutData->items[middle].position)
	1569	left = middle+1;
	1570	else if(strPos < layoutData->items[middle].position)
	1571	right = middle-1;
	1572	else {
	1573	return middle;
	1574	}
[2]	1575	}
[846]	1576	return right;
[2]	1577	}
	1578
	1579	QFixed QTextEngine::width(int from, int len) const
	1580	{
	1581	itemize();
	1582
	1583	QFixed w = 0;
	1584
	1585	// qDebug("QTextEngine::width(from = %d, len = %d), numItems=%d, strleng=%d", from, len, items.size(), string.length());
	1586	for (int i = 0; i < layoutData->items.size(); i++) {
	1587	const QScriptItem *si = layoutData->items.constData() + i;
	1588	int pos = si->position;
	1589	int ilen = length(i);
	1590	// qDebug("item %d: from %d len %d", i, pos, ilen);
	1591	if (pos >= from + len)
	1592	break;
	1593	if (pos + ilen > from) {
	1594	if (!si->num_glyphs)
	1595	shape(i);
	1596
	1597	if (si->analysis.flags == QScriptAnalysis::Object) {
	1598	w += si->width;
	1599	continue;
	1600	} else if (si->analysis.flags == QScriptAnalysis::Tab) {
	1601	w += calculateTabWidth(i, w);
	1602	continue;
	1603	}
	1604
	1605
	1606	QGlyphLayout glyphs = shapedGlyphs(si);
	1607	unsigned short *logClusters = this->logClusters(si);
	1608
	1609	// fprintf(stderr, " logclusters:");
	1610	// for (int k = 0; k < ilen; k++)
	1611	// fprintf(stderr, " %d", logClusters[k]);
	1612	// fprintf(stderr, "\n");
	1613	// do the simple thing for now and give the first glyph in a cluster the full width, all other ones 0.
	1614	int charFrom = from - pos;
	1615	if (charFrom < 0)
	1616	charFrom = 0;
	1617	int glyphStart = logClusters[charFrom];
	1618	if (charFrom > 0 && logClusters[charFrom-1] == glyphStart)
	1619	while (charFrom < ilen && logClusters[charFrom] == glyphStart)
	1620	charFrom++;
	1621	if (charFrom < ilen) {
	1622	glyphStart = logClusters[charFrom];
	1623	int charEnd = from + len - 1 - pos;
	1624	if (charEnd >= ilen)
	1625	charEnd = ilen-1;
	1626	int glyphEnd = logClusters[charEnd];
	1627	while (charEnd < ilen && logClusters[charEnd] == glyphEnd)
	1628	charEnd++;
	1629	glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd];
	1630
	1631	// qDebug("char: start=%d end=%d / glyph: start = %d, end = %d", charFrom, charEnd, glyphStart, glyphEnd);
	1632	for (int i = glyphStart; i < glyphEnd; i++)
	1633	w += glyphs.advances_x[i] * !glyphs.attributes[i].dontPrint;
	1634	}
	1635	}
	1636	}
	1637	// qDebug(" --> w= %d ", w);
	1638	return w;
	1639	}
	1640
	1641	glyph_metrics_t QTextEngine::boundingBox(int from, int len) const
	1642	{
	1643	itemize();
	1644
	1645	glyph_metrics_t gm;
	1646
	1647	for (int i = 0; i < layoutData->items.size(); i++) {
	1648	const QScriptItem *si = layoutData->items.constData() + i;
[561]	1649
[2]	1650	int pos = si->position;
	1651	int ilen = length(i);
	1652	if (pos > from + len)
	1653	break;
[561]	1654	if (pos + ilen > from) {
[2]	1655	if (!si->num_glyphs)
	1656	shape(i);
	1657
	1658	if (si->analysis.flags == QScriptAnalysis::Object) {
	1659	gm.width += si->width;
	1660	continue;
	1661	} else if (si->analysis.flags == QScriptAnalysis::Tab) {
	1662	gm.width += calculateTabWidth(i, gm.width);
	1663	continue;
	1664	}
	1665
	1666	unsigned short *logClusters = this->logClusters(si);
	1667	QGlyphLayout glyphs = shapedGlyphs(si);
	1668
	1669	// do the simple thing for now and give the first glyph in a cluster the full width, all other ones 0.
	1670	int charFrom = from - pos;
	1671	if (charFrom < 0)
	1672	charFrom = 0;
	1673	int glyphStart = logClusters[charFrom];
	1674	if (charFrom > 0 && logClusters[charFrom-1] == glyphStart)
	1675	while (charFrom < ilen && logClusters[charFrom] == glyphStart)
	1676	charFrom++;
	1677	if (charFrom < ilen) {
[846]	1678	QFontEngine fe = fontEngine(si);
[2]	1679	glyphStart = logClusters[charFrom];
	1680	int charEnd = from + len - 1 - pos;
	1681	if (charEnd >= ilen)
	1682	charEnd = ilen-1;
	1683	int glyphEnd = logClusters[charEnd];
	1684	while (charEnd < ilen && logClusters[charEnd] == glyphEnd)
	1685	charEnd++;
	1686	glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd];
	1687	if (glyphStart <= glyphEnd ) {
	1688	glyph_metrics_t m = fe->boundingBox(glyphs.mid(glyphStart, glyphEnd - glyphStart));
	1689	gm.x = qMin(gm.x, m.x + gm.xoff);
	1690	gm.y = qMin(gm.y, m.y + gm.yoff);
	1691	gm.width = qMax(gm.width, m.width+gm.xoff);
	1692	gm.height = qMax(gm.height, m.height+gm.yoff);
	1693	gm.xoff += m.xoff;
	1694	gm.yoff += m.yoff;
	1695	}
	1696	}
	1697	}
	1698	}
	1699	return gm;
	1700	}
	1701
	1702	glyph_metrics_t QTextEngine::tightBoundingBox(int from, int len) const
	1703	{
	1704	itemize();
	1705
	1706	glyph_metrics_t gm;
	1707
	1708	for (int i = 0; i < layoutData->items.size(); i++) {
	1709	const QScriptItem *si = layoutData->items.constData() + i;
	1710	int pos = si->position;
	1711	int ilen = length(i);
	1712	if (pos > from + len)
	1713	break;
	1714	if (pos + len > from) {
	1715	if (!si->num_glyphs)
	1716	shape(i);
	1717	unsigned short *logClusters = this->logClusters(si);
	1718	QGlyphLayout glyphs = shapedGlyphs(si);
	1719
	1720	// do the simple thing for now and give the first glyph in a cluster the full width, all other ones 0.
	1721	int charFrom = from - pos;
	1722	if (charFrom < 0)
	1723	charFrom = 0;
	1724	int glyphStart = logClusters[charFrom];
	1725	if (charFrom > 0 && logClusters[charFrom-1] == glyphStart)
	1726	while (charFrom < ilen && logClusters[charFrom] == glyphStart)
	1727	charFrom++;
	1728	if (charFrom < ilen) {
	1729	glyphStart = logClusters[charFrom];
	1730	int charEnd = from + len - 1 - pos;
	1731	if (charEnd >= ilen)
	1732	charEnd = ilen-1;
	1733	int glyphEnd = logClusters[charEnd];
	1734	while (charEnd < ilen && logClusters[charEnd] == glyphEnd)
	1735	charEnd++;
	1736	glyphEnd = (charEnd == ilen) ? si->num_glyphs : logClusters[charEnd];
	1737	if (glyphStart <= glyphEnd ) {
	1738	QFontEngine fe = fontEngine(si);
	1739	glyph_metrics_t m = fe->tightBoundingBox(glyphs.mid(glyphStart, glyphEnd - glyphStart));
	1740	gm.x = qMin(gm.x, m.x + gm.xoff);
	1741	gm.y = qMin(gm.y, m.y + gm.yoff);
	1742	gm.width = qMax(gm.width, m.width+gm.xoff);
	1743	gm.height = qMax(gm.height, m.height+gm.yoff);
	1744	gm.xoff += m.xoff;
	1745	gm.yoff += m.yoff;
	1746	}
	1747	}
	1748	}
	1749	}
	1750	return gm;
	1751	}
	1752
	1753	QFont QTextEngine::font(const QScriptItem &si) const
	1754	{
	1755	QFont font = fnt;
	1756	if (hasFormats()) {
	1757	QTextCharFormat f = format(&si);
	1758	font = f.font();
	1759
	1760	if (block.docHandle() && block.docHandle()->layout()) {
	1761	// Make sure we get the right dpi on printers
	1762	QPaintDevice *pdev = block.docHandle()->layout()->paintDevice();
	1763	if (pdev)
	1764	font = QFont(font, pdev);
	1765	} else {
	1766	font = font.resolve(fnt);
	1767	}
	1768	QTextCharFormat::VerticalAlignment valign = f.verticalAlignment();
	1769	if (valign == QTextCharFormat::AlignSuperScript \|\| valign == QTextCharFormat::AlignSubScript) {
	1770	if (font.pointSize() != -1)
	1771	font.setPointSize((font.pointSize() * 2) / 3);
	1772	else
	1773	font.setPixelSize((font.pixelSize() * 2) / 3);
	1774	}
	1775	}
	1776
	1777	if (si.analysis.flags == QScriptAnalysis::SmallCaps)
	1778	font = font.d->smallCapsFont();
	1779
	1780	return font;
	1781	}
	1782
[561]	1783	QFontEngine QTextEngine::fontEngine(const QScriptItem &si, QFixed ascent, QFixed descent, QFixed leading) const
[2]	1784	{
	1785	QFontEngine *engine = 0;
	1786	QFontEngine *scaledEngine = 0;
	1787	int script = si.analysis.script;
	1788
	1789	QFont font = fnt;
	1790	if (hasFormats()) {
	1791	QTextCharFormat f = format(&si);
	1792	font = f.font();
	1793
	1794	if (block.docHandle() && block.docHandle()->layout()) {
	1795	// Make sure we get the right dpi on printers
	1796	QPaintDevice *pdev = block.docHandle()->layout()->paintDevice();
	1797	if (pdev)
	1798	font = QFont(font, pdev);
	1799	} else {
	1800	font = font.resolve(fnt);
	1801	}
	1802	engine = font.d->engineForScript(script);
	1803	QTextCharFormat::VerticalAlignment valign = f.verticalAlignment();
	1804	if (valign == QTextCharFormat::AlignSuperScript \|\| valign == QTextCharFormat::AlignSubScript) {
	1805	if (font.pointSize() != -1)
	1806	font.setPointSize((font.pointSize() * 2) / 3);
	1807	else
	1808	font.setPixelSize((font.pixelSize() * 2) / 3);
	1809	scaledEngine = font.d->engineForScript(script);
	1810	}
	1811	} else {
	1812	engine = font.d->engineForScript(script);
	1813	}
	1814
	1815	if (si.analysis.flags == QScriptAnalysis::SmallCaps) {
	1816	QFontPrivate *p = font.d->smallCapsFontPrivate();
	1817	scaledEngine = p->engineForScript(script);
	1818	}
	1819
	1820	if (ascent) {
	1821	*ascent = engine->ascent();
	1822	*descent = engine->descent();
[561]	1823	*leading = engine->leading();
[2]	1824	}
	1825
	1826	if (scaledEngine)
	1827	return scaledEngine;
	1828	return engine;
	1829	}
	1830
	1831	struct QJustificationPoint {
	1832	int type;
	1833	QFixed kashidaWidth;
	1834	QGlyphLayout glyph;
	1835	QFontEngine *fontEngine;
	1836	};
	1837
	1838	Q_DECLARE_TYPEINFO(QJustificationPoint, Q_PRIMITIVE_TYPE);
	1839
	1840	static void set(QJustificationPoint point, int type, const QGlyphLayout &glyph, QFontEngine fe)
	1841	{
	1842	point->type = type;
	1843	point->glyph = glyph;
	1844	point->fontEngine = fe;
	1845
	1846	if (type >= HB_Arabic_Normal) {
	1847	QChar ch(0x640); // Kashida character
	1848	QGlyphLayoutArray<8> glyphs;
	1849	int nglyphs = 7;
	1850	fe->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);
	1851	if (glyphs.glyphs[0] && glyphs.advances_x[0] != 0) {
	1852	point->kashidaWidth = glyphs.advances_x[0];
	1853	} else {
	1854	point->type = HB_NoJustification;
	1855	point->kashidaWidth = 0;
	1856	}
	1857	}
	1858	}
	1859
	1860
	1861	void QTextEngine::justify(const QScriptLine &line)
	1862	{
	1863	// qDebug("justify: line.gridfitted = %d, line.justified=%d", line.gridfitted, line.justified);
	1864	if (line.gridfitted && line.justified)
	1865	return;
	1866
	1867	if (!line.gridfitted) {
	1868	// redo layout in device metrics, then adjust
	1869	const_cast<QScriptLine &>(line).gridfitted = true;
	1870	}
	1871
	1872	if ((option.alignment() & Qt::AlignHorizontal_Mask) != Qt::AlignJustify)
	1873	return;
	1874
	1875	itemize();
	1876
	1877	if (!forceJustification) {
	1878	int end = line.from + (int)line.length;
	1879	if (end == layoutData->string.length())
	1880	return; // no justification at end of paragraph
	1881	if (end && layoutData->items[findItem(end-1)].analysis.flags == QScriptAnalysis::LineOrParagraphSeparator)
[846]	1882	return; // no justification at the end of an explicitly separated line
[2]	1883	}
	1884
	1885	// justify line
	1886	int maxJustify = 0;
	1887
	1888	// don't include trailing white spaces when doing justification
	1889	int line_length = line.length;
[846]	1890	const HB_CharAttributes *a = attributes();
	1891	if (! a)
	1892	return;
	1893	a += line.from;
[2]	1894	while (line_length && a[line_length-1].whiteSpace)
	1895	--line_length;
	1896	// subtract one char more, as we can't justfy after the last character
	1897	--line_length;
	1898
	1899	if (!line_length)
	1900	return;
	1901
	1902	int firstItem = findItem(line.from);
	1903	int nItems = findItem(line.from + line_length - 1) - firstItem + 1;
	1904
	1905	QVarLengthArray<QJustificationPoint> justificationPoints;
	1906	int nPoints = 0;
	1907	// 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());
	1908	QFixed minKashida = 0x100000;
	1909
	1910	// we need to do all shaping before we go into the next loop, as we there
	1911	// store pointers to the glyph data that could get reallocated by the shaping
	1912	// process.
	1913	for (int i = 0; i < nItems; ++i) {
	1914	QScriptItem &si = layoutData->items[firstItem + i];
	1915	if (!si.num_glyphs)
	1916	shape(firstItem + i);
	1917	}
	1918
	1919	for (int i = 0; i < nItems; ++i) {
	1920	QScriptItem &si = layoutData->items[firstItem + i];
	1921
	1922	int kashida_type = HB_Arabic_Normal;
	1923	int kashida_pos = -1;
	1924
	1925	int start = qMax(line.from - si.position, 0);
	1926	int end = qMin(line.from + line_length - (int)si.position, length(firstItem+i));
	1927
	1928	unsigned short *log_clusters = logClusters(&si);
	1929
	1930	int gs = log_clusters[start];
	1931	int ge = (end == length(firstItem+i) ? si.num_glyphs : log_clusters[end]);
	1932
	1933	const QGlyphLayout g = shapedGlyphs(&si);
	1934
	1935	for (int i = gs; i < ge; ++i) {
	1936	g.justifications[i].type = QGlyphJustification::JustifyNone;
	1937	g.justifications[i].nKashidas = 0;
	1938	g.justifications[i].space_18d6 = 0;
	1939
	1940	justificationPoints.resize(nPoints+3);
	1941	int justification = g.attributes[i].justification;
	1942
	1943	switch(justification) {
	1944	case HB_NoJustification:
	1945	break;
	1946	case HB_Space :
	1947	// fall through
	1948	case HB_Arabic_Space :
	1949	if (kashida_pos >= 0) {
	1950	// qDebug("kashida position at %d in word", kashida_pos);
	1951	set(&justificationPoints[nPoints], kashida_type, g.mid(kashida_pos), fontEngine(si));
[846]	1952	if (justificationPoints[nPoints].kashidaWidth > 0) {
	1953	minKashida = qMin(minKashida, justificationPoints[nPoints].kashidaWidth);
	1954	maxJustify = qMax(maxJustify, justificationPoints[nPoints].type);
	1955	++nPoints;
	1956	}
[2]	1957	}
	1958	kashida_pos = -1;
	1959	kashida_type = HB_Arabic_Normal;
	1960	// fall through
	1961	case HB_Character :
	1962	set(&justificationPoints[nPoints++], justification, g.mid(i), fontEngine(si));
	1963	maxJustify = qMax(maxJustify, justification);
	1964	break;
	1965	case HB_Arabic_Normal :
	1966	case HB_Arabic_Waw :
	1967	case HB_Arabic_BaRa :
	1968	case HB_Arabic_Alef :
	1969	case HB_Arabic_HaaDal :
	1970	case HB_Arabic_Seen :
	1971	case HB_Arabic_Kashida :
	1972	if (justification >= kashida_type) {
	1973	kashida_pos = i;
	1974	kashida_type = justification;
	1975	}
	1976	}
	1977	}
	1978	if (kashida_pos >= 0) {
	1979	set(&justificationPoints[nPoints], kashida_type, g.mid(kashida_pos), fontEngine(si));
[846]	1980	if (justificationPoints[nPoints].kashidaWidth > 0) {
	1981	minKashida = qMin(minKashida, justificationPoints[nPoints].kashidaWidth);
	1982	maxJustify = qMax(maxJustify, justificationPoints[nPoints].type);
	1983	++nPoints;
	1984	}
[2]	1985	}
	1986	}
	1987
	1988	QFixed need = line.width - line.textWidth;
	1989	if (need < 0) {
	1990	// line overflows already!
	1991	const_cast<QScriptLine &>(line).justified = true;
	1992	return;
	1993	}
	1994
	1995	// qDebug("doing justification: textWidth=%x, requested=%x, maxJustify=%d", line.textWidth.value(), line.width.value(), maxJustify);
	1996	// qDebug(" minKashida=%f, need=%f", minKashida.toReal(), need.toReal());
	1997
	1998	// distribute in priority order
	1999	if (maxJustify >= HB_Arabic_Normal) {
	2000	while (need >= minKashida) {
	2001	for (int type = maxJustify; need >= minKashida && type >= HB_Arabic_Normal; --type) {
	2002	for (int i = 0; need >= minKashida && i < nPoints; ++i) {
	2003	if (justificationPoints[i].type == type && justificationPoints[i].kashidaWidth <= need) {
	2004	justificationPoints[i].glyph.justifications->nKashidas++;
	2005	// ############
	2006	justificationPoints[i].glyph.justifications->space_18d6 += justificationPoints[i].kashidaWidth.value();
	2007	need -= justificationPoints[i].kashidaWidth;
	2008	// qDebug("adding kashida type %d with width %x, neednow %x", type, justificationPoints[i].kashidaWidth, need.value());
	2009	}
	2010	}
	2011	}
	2012	}
	2013	}
	2014	Q_ASSERT(need >= 0);
	2015	if (!need)
	2016	goto end;
	2017
	2018	maxJustify = qMin(maxJustify, (int)HB_Space);
	2019	for (int type = maxJustify; need != 0 && type > 0; --type) {
	2020	int n = 0;
	2021	for (int i = 0; i < nPoints; ++i) {
	2022	if (justificationPoints[i].type == type)
	2023	++n;
	2024	}
	2025	// qDebug("number of points for justification type %d: %d", type, n);
	2026
	2027
	2028	if (!n)
	2029	continue;
	2030
	2031	for (int i = 0; i < nPoints; ++i) {
	2032	if (justificationPoints[i].type == type) {
	2033	QFixed add = need/n;
	2034	// qDebug("adding %x to glyph %x", add.value(), justificationPoints[i].glyph->glyph);
	2035	justificationPoints[i].glyph.justifications[0].space_18d6 = add.value();
	2036	need -= add;
	2037	--n;
	2038	}
	2039	}
	2040
	2041	Q_ASSERT(!need);
	2042	}
	2043	end:
	2044	const_cast<QScriptLine &>(line).justified = true;
	2045	}
	2046
	2047	void QScriptLine::setDefaultHeight(QTextEngine *eng)
	2048	{
	2049	QFont f;
	2050	QFontEngine *e;
	2051
	2052	if (eng->block.docHandle() && eng->block.docHandle()->layout()) {
	2053	f = eng->block.charFormat().font();
	2054	// Make sure we get the right dpi on printers
	2055	QPaintDevice *pdev = eng->block.docHandle()->layout()->paintDevice();
	2056	if (pdev)
	2057	f = QFont(f, pdev);
	2058	e = f.d->engineForScript(QUnicodeTables::Common);
	2059	} else {
	2060	e = eng->fnt.d->engineForScript(QUnicodeTables::Common);
	2061	}
	2062
[561]	2063	QFixed other_ascent = e->ascent();
	2064	QFixed other_descent = e->descent();
	2065	QFixed other_leading = e->leading();
	2066	leading = qMax(leading + ascent, other_leading + other_ascent) - qMax(ascent, other_ascent);
	2067	ascent = qMax(ascent, other_ascent);
	2068	descent = qMax(descent, other_descent);
[2]	2069	}
	2070
	2071	QTextEngine::LayoutData::LayoutData()
	2072	{
	2073	memory = 0;
	2074	allocated = 0;
	2075	memory_on_stack = false;
	2076	used = 0;
	2077	hasBidi = false;
[846]	2078	layoutState = LayoutEmpty;
[2]	2079	haveCharAttributes = false;
	2080	logClustersPtr = 0;
	2081	available_glyphs = 0;
	2082	}
	2083
	2084	QTextEngine::LayoutData::LayoutData(const QString &str, void **stack_memory, int _allocated)
	2085	: string(str)
	2086	{
	2087	allocated = _allocated;
	2088
	2089	int space_charAttributes = sizeof(HB_CharAttributes)string.length()/sizeof(void) + 1;
	2090	int space_logClusters = sizeof(unsigned short)string.length()/sizeof(void) + 1;
	2091	available_glyphs = ((int)allocated - space_charAttributes - space_logClusters)(int)sizeof(void)/(int)QGlyphLayout::spaceNeededForGlyphLayout(1);
	2092
	2093	if (available_glyphs < str.length()) {
	2094	// need to allocate on the heap
	2095	allocated = 0;
	2096
	2097	memory_on_stack = false;
	2098	memory = 0;
	2099	logClustersPtr = 0;
	2100	} else {
	2101	memory_on_stack = true;
	2102	memory = stack_memory;
	2103	logClustersPtr = (unsigned short *)(memory + space_charAttributes);
	2104
	2105	void *m = memory + space_charAttributes + space_logClusters;
	2106	glyphLayout = QGlyphLayout(reinterpret_cast<char *>(m), str.length());
	2107	glyphLayout.clear();
	2108	memset(memory, 0, space_charAttributessizeof(void ));
	2109	}
	2110	used = 0;
	2111	hasBidi = false;
[846]	2112	layoutState = LayoutEmpty;
[2]	2113	haveCharAttributes = false;
	2114	}
	2115
	2116	QTextEngine::LayoutData::~LayoutData()
	2117	{
	2118	if (!memory_on_stack)
	2119	free(memory);
	2120	memory = 0;
	2121	}
	2122
[846]	2123	bool QTextEngine::LayoutData::reallocate(int totalGlyphs)
[2]	2124	{
	2125	Q_ASSERT(totalGlyphs >= glyphLayout.numGlyphs);
	2126	if (memory_on_stack && available_glyphs >= totalGlyphs) {
	2127	glyphLayout.grow(glyphLayout.data(), totalGlyphs);
[846]	2128	return true;
[2]	2129	}
	2130
	2131	int space_charAttributes = sizeof(HB_CharAttributes)string.length()/sizeof(void) + 1;
	2132	int space_logClusters = sizeof(unsigned short)string.length()/sizeof(void) + 1;
	2133	int space_glyphs = QGlyphLayout::spaceNeededForGlyphLayout(totalGlyphs)/sizeof(void*) + 2;
	2134
	2135	int newAllocated = space_charAttributes + space_glyphs + space_logClusters;
[846]	2136	// These values can be negative if the length of string/glyphs causes overflow,
	2137	// we can't layout such a long string all at once, so return false here to
	2138	// indicate there is a failure
	2139	if (space_charAttributes < 0 \|\| space_logClusters < 0 \|\| space_glyphs < 0 \|\| newAllocated < allocated) {
	2140	layoutState = LayoutFailed;
	2141	return false;
	2142	}
	2143
[561]	2144	void **newMem = memory;
	2145	newMem = (void *)::realloc(memory_on_stack ? 0 : memory, newAllocatedsizeof(void *));
[846]	2146	if (!newMem) {
	2147	layoutState = LayoutFailed;
	2148	return false;
	2149	}
	2150	if (memory_on_stack)
[561]	2151	memcpy(newMem, memory, allocatedsizeof(void ));
	2152	memory = newMem;
[2]	2153	memory_on_stack = false;
	2154
	2155	void **m = memory;
	2156	m += space_charAttributes;
	2157	logClustersPtr = (unsigned short *) m;
	2158	m += space_logClusters;
	2159
	2160	const int space_preGlyphLayout = space_charAttributes + space_logClusters;
	2161	if (allocated < space_preGlyphLayout)
	2162	memset(memory + allocated, 0, (space_preGlyphLayout - allocated)sizeof(void ));
	2163
	2164	glyphLayout.grow(reinterpret_cast<char *>(m), totalGlyphs);
	2165
	2166	allocated = newAllocated;
[846]	2167	return true;
[2]	2168	}
	2169
	2170	// grow to the new size, copying the existing data to the new layout
	2171	void QGlyphLayout::grow(char *address, int totalGlyphs)
	2172	{
	2173	QGlyphLayout oldLayout(address, numGlyphs);
	2174	QGlyphLayout newLayout(address, totalGlyphs);
	2175
	2176	if (numGlyphs) {
	2177	// move the existing data
	2178	memmove(newLayout.attributes, oldLayout.attributes, numGlyphs * sizeof(HB_GlyphAttributes));
	2179	memmove(newLayout.justifications, oldLayout.justifications, numGlyphs * sizeof(QGlyphJustification));
	2180	memmove(newLayout.advances_y, oldLayout.advances_y, numGlyphs * sizeof(QFixed));
	2181	memmove(newLayout.advances_x, oldLayout.advances_x, numGlyphs * sizeof(QFixed));
	2182	memmove(newLayout.glyphs, oldLayout.glyphs, numGlyphs * sizeof(HB_Glyph));
	2183	}
	2184
	2185	// clear the new data
	2186	newLayout.clear(numGlyphs);
	2187
	2188	*this = newLayout;
	2189	}
	2190
	2191	void QTextEngine::freeMemory()
	2192	{
	2193	if (!stackEngine) {
	2194	delete layoutData;
	2195	layoutData = 0;
	2196	} else {
	2197	layoutData->used = 0;
	2198	layoutData->hasBidi = false;
[846]	2199	layoutData->layoutState = LayoutEmpty;
[2]	2200	layoutData->haveCharAttributes = false;
	2201	}
	2202	for (int i = 0; i < lines.size(); ++i) {
	2203	lines[i].justified = 0;
	2204	lines[i].gridfitted = 0;
	2205	}
	2206	}
	2207
	2208	int QTextEngine::formatIndex(const QScriptItem *si) const
	2209	{
	2210	if (specialData && !specialData->resolvedFormatIndices.isEmpty())
	2211	return specialData->resolvedFormatIndices.at(si - &layoutData->items[0]);
	2212	QTextDocumentPrivate *p = block.docHandle();
	2213	if (!p)
	2214	return -1;
	2215	int pos = si->position;
	2216	if (specialData && si->position >= specialData->preeditPosition) {
	2217	if (si->position < specialData->preeditPosition + specialData->preeditText.length())
	2218	pos = qMax(specialData->preeditPosition - 1, 0);
	2219	else
	2220	pos -= specialData->preeditText.length();
	2221	}
	2222	QTextDocumentPrivate::FragmentIterator it = p->find(block.position() + pos);
	2223	return it.value()->format;
	2224	}
	2225
	2226
	2227	QTextCharFormat QTextEngine::format(const QScriptItem *si) const
	2228	{
	2229	QTextCharFormat format;
	2230	const QTextFormatCollection *formats = 0;
	2231	if (block.docHandle()) {
	2232	formats = this->formats();
	2233	format = formats->charFormat(formatIndex(si));
	2234	}
	2235	if (specialData && specialData->resolvedFormatIndices.isEmpty()) {
	2236	int end = si->position + length(si);
	2237	for (int i = 0; i < specialData->addFormats.size(); ++i) {
	2238	const QTextLayout::FormatRange &r = specialData->addFormats.at(i);
	2239	if (r.start <= si->position && r.start + r.length >= end) {
	2240	if (!specialData->addFormatIndices.isEmpty())
	2241	format.merge(formats->format(specialData->addFormatIndices.at(i)));
	2242	else
	2243	format.merge(r.format);
	2244	}
	2245	}
	2246	}
	2247	return format;
	2248	}
	2249
	2250	void QTextEngine::addRequiredBoundaries() const
	2251	{
	2252	if (specialData) {
	2253	for (int i = 0; i < specialData->addFormats.size(); ++i) {
	2254	const QTextLayout::FormatRange &r = specialData->addFormats.at(i);
	2255	setBoundary(r.start);
	2256	setBoundary(r.start + r.length);
	2257	//qDebug("adding boundaries %d %d", r.start, r.start+r.length);
	2258	}
	2259	}
	2260	}
	2261
	2262	bool QTextEngine::atWordSeparator(int position) const
	2263	{
	2264	const QChar c = layoutData->string.at(position);
	2265	switch (c.toLatin1()) {
	2266	case '.':
	2267	case ',':
	2268	case '?':
	2269	case '!':
[846]	2270	case '@':
	2271	case '#':
	2272	case '$':
[2]	2273	case ':':
	2274	case ';':
	2275	case '-':
	2276	case '<':
	2277	case '>':
	2278	case '[':
	2279	case ']':
	2280	case '(':
	2281	case ')':
	2282	case '{':
	2283	case '}':
	2284	case '=':
	2285	case '/':
	2286	case '+':
	2287	case '%':
	2288	case '&':
	2289	case '^':
	2290	case '*':
	2291	case '\'':
	2292	case '"':
[846]	2293	case '`':
[2]	2294	case '~':
[561]	2295	case '\|':
[2]	2296	return true;
	2297	default:
	2298	return false;
	2299	}
	2300	}
	2301
	2302	bool QTextEngine::atSpace(int position) const
	2303	{
	2304	const QChar c = layoutData->string.at(position);
	2305
	2306	return c == QLatin1Char(' ')
	2307	\|\| c == QChar::Nbsp
	2308	\|\| c == QChar::LineSeparator
	2309	\|\| c == QLatin1Char('\t')
	2310	;
	2311	}
	2312
	2313
	2314	void QTextEngine::indexAdditionalFormats()
	2315	{
	2316	if (!block.docHandle())
	2317	return;
	2318
	2319	specialData->addFormatIndices.resize(specialData->addFormats.count());
	2320	QTextFormatCollection * const formats = this->formats();
	2321
	2322	for (int i = 0; i < specialData->addFormats.count(); ++i) {
	2323	specialData->addFormatIndices[i] = formats->indexForFormat(specialData->addFormats.at(i).format);
	2324	specialData->addFormats[i].format = QTextCharFormat();
	2325	}
	2326	}
	2327
[561]	2328	/* These two helper functions are used to determine whether we need to insert a ZWJ character
	2329	between the text that gets truncated and the ellipsis. This is important to get
	2330	correctly shaped results for arabic text.
	2331	*/
	2332	static bool nextCharJoins(const QString &string, int pos)
	2333	{
	2334	while (pos < string.length() && string.at(pos).category() == QChar::Mark_NonSpacing)
	2335	++pos;
	2336	if (pos == string.length())
	2337	return false;
	2338	return string.at(pos).joining() != QChar::OtherJoining;
	2339	}
	2340
	2341	static bool prevCharJoins(const QString &string, int pos)
	2342	{
	2343	while (pos > 0 && string.at(pos - 1).category() == QChar::Mark_NonSpacing)
	2344	--pos;
	2345	if (pos == 0)
	2346	return false;
	2347	return (string.at(pos - 1).joining() == QChar::Dual \|\| string.at(pos - 1).joining() == QChar::Center);
	2348	}
	2349
[2]	2350	QString QTextEngine::elidedText(Qt::TextElideMode mode, const QFixed &width, int flags) const
	2351	{
	2352	// qDebug() << "elidedText; available width" << width.toReal() << "text width:" << this->width(0, layoutData->string.length()).toReal();
	2353
	2354	if (flags & Qt::TextShowMnemonic) {
	2355	itemize();
	2356	for (int i = 0; i < layoutData->items.size(); ++i) {
	2357	QScriptItem &si = layoutData->items[i];
	2358	if (!si.num_glyphs)
	2359	shape(i);
	2360
	2361	HB_CharAttributes attributes = const_cast<HB_CharAttributes >(this->attributes());
[846]	2362	if (!attributes)
	2363	return QString();
	2364
[2]	2365	unsigned short *logClusters = this->logClusters(&si);
	2366	QGlyphLayout glyphs = shapedGlyphs(&si);
	2367
	2368	const int end = si.position + length(&si);
	2369	for (int i = si.position; i < end - 1; ++i)
	2370	if (layoutData->string.at(i) == QLatin1Char('&')) {
	2371	const int gp = logClusters[i - si.position];
	2372	glyphs.attributes[gp].dontPrint = true;
	2373	attributes[i + 1].charStop = false;
	2374	attributes[i + 1].whiteSpace = false;
	2375	attributes[i + 1].lineBreakType = HB_NoBreak;
	2376	if (i < end - 1
	2377	&& layoutData->string.at(i + 1) == QLatin1Char('&'))
	2378	++i;
	2379	}
	2380	}
	2381	}
	2382
	2383	validate();
	2384
	2385	if (mode == Qt::ElideNone
	2386	\|\| this->width(0, layoutData->string.length()) <= width
	2387	\|\| layoutData->string.length() <= 1)
	2388	return layoutData->string;
	2389
	2390	QFixed ellipsisWidth;
	2391	QString ellipsisText;
	2392	{
	2393	QChar ellipsisChar(0x2026);
	2394
	2395	QFontEngine *fe = fnt.d->engineForScript(QUnicodeTables::Common);
	2396
	2397	QGlyphLayoutArray<1> ellipsisGlyph;
	2398	{
	2399	QFontEngine *feForEllipsis = (fe->type() == QFontEngine::Multi)
	2400	? static_cast<QFontEngineMulti *>(fe)->engine(0)
	2401	: fe;
	2402
	2403	if (feForEllipsis->type() == QFontEngine::Mac)
	2404	feForEllipsis = fe;
	2405
	2406	// the lookup can be really slow when we use XLFD fonts
	2407	if (feForEllipsis->type() != QFontEngine::XLFD
	2408	&& feForEllipsis->canRender(&ellipsisChar, 1)) {
	2409	int nGlyphs = 1;
	2410	feForEllipsis->stringToCMap(&ellipsisChar, 1, &ellipsisGlyph, &nGlyphs, 0);
	2411	}
	2412	}
	2413
	2414	if (ellipsisGlyph.glyphs[0]) {
	2415	ellipsisWidth = ellipsisGlyph.advances_x[0];
	2416	ellipsisText = ellipsisChar;
	2417	} else {
	2418	QString dotDotDot(QLatin1String("..."));
	2419
	2420	QGlyphLayoutArray<3> glyphs;
	2421	int nGlyphs = 3;
	2422	if (!fe->stringToCMap(dotDotDot.constData(), 3, &glyphs, &nGlyphs, 0))
	2423	// should never happen...
	2424	return layoutData->string;
	2425	for (int i = 0; i < nGlyphs; ++i)
	2426	ellipsisWidth += glyphs.advances_x[i];
	2427	ellipsisText = dotDotDot;
	2428	}
	2429	}
	2430
	2431	const QFixed availableWidth = width - ellipsisWidth;
	2432	if (availableWidth < 0)
	2433	return QString();
	2434
	2435	const HB_CharAttributes *attributes = this->attributes();
[846]	2436	if (!attributes)
	2437	return QString();
[2]	2438
	2439	if (mode == Qt::ElideRight) {
	2440	QFixed currentWidth;
	2441	int pos = 0;
	2442	int nextBreak = 0;
	2443
	2444	do {
	2445	pos = nextBreak;
	2446
	2447	++nextBreak;
	2448	while (nextBreak < layoutData->string.length() && !attributes[nextBreak].charStop)
	2449	++nextBreak;
	2450
	2451	currentWidth += this->width(pos, nextBreak - pos);
	2452	} while (nextBreak < layoutData->string.length()
	2453	&& currentWidth < availableWidth);
	2454
[561]	2455	if (nextCharJoins(layoutData->string, pos))
	2456	ellipsisText.prepend(QChar(0x200d) /* ZWJ */);
	2457
[2]	2458	return layoutData->string.left(pos) + ellipsisText;
	2459	} else if (mode == Qt::ElideLeft) {
	2460	QFixed currentWidth;
	2461	int pos = layoutData->string.length();
	2462	int nextBreak = layoutData->string.length();
	2463
	2464	do {
	2465	pos = nextBreak;
	2466
	2467	--nextBreak;
	2468	while (nextBreak > 0 && !attributes[nextBreak].charStop)
	2469	--nextBreak;
	2470
	2471	currentWidth += this->width(nextBreak, pos - nextBreak);
	2472	} while (nextBreak > 0
	2473	&& currentWidth < availableWidth);
	2474
[561]	2475	if (prevCharJoins(layoutData->string, pos))
	2476	ellipsisText.append(QChar(0x200d) /* ZWJ */);
	2477
[2]	2478	return ellipsisText + layoutData->string.mid(pos);
	2479	} else if (mode == Qt::ElideMiddle) {
	2480	QFixed leftWidth;
	2481	QFixed rightWidth;
	2482
	2483	int leftPos = 0;
	2484	int nextLeftBreak = 0;
	2485
	2486	int rightPos = layoutData->string.length();
	2487	int nextRightBreak = layoutData->string.length();
	2488
	2489	do {
	2490	leftPos = nextLeftBreak;
	2491	rightPos = nextRightBreak;
	2492
	2493	++nextLeftBreak;
	2494	while (nextLeftBreak < layoutData->string.length() && !attributes[nextLeftBreak].charStop)
	2495	++nextLeftBreak;
	2496
	2497	--nextRightBreak;
	2498	while (nextRightBreak > 0 && !attributes[nextRightBreak].charStop)
	2499	--nextRightBreak;
	2500
	2501	leftWidth += this->width(leftPos, nextLeftBreak - leftPos);
	2502	rightWidth += this->width(nextRightBreak, rightPos - nextRightBreak);
	2503	} while (nextLeftBreak < layoutData->string.length()
	2504	&& nextRightBreak > 0
	2505	&& leftWidth + rightWidth < availableWidth);
	2506
[561]	2507	if (nextCharJoins(layoutData->string, leftPos))
	2508	ellipsisText.prepend(QChar(0x200d) /* ZWJ */);
	2509	if (prevCharJoins(layoutData->string, rightPos))
	2510	ellipsisText.append(QChar(0x200d) /* ZWJ */);
	2511
[2]	2512	return layoutData->string.left(leftPos) + ellipsisText + layoutData->string.mid(rightPos);
	2513	}
	2514
	2515	return layoutData->string;
	2516	}
	2517
	2518	void QTextEngine::setBoundary(int strPos) const
	2519	{
	2520	if (strPos <= 0 \|\| strPos >= layoutData->string.length())
	2521	return;
	2522
	2523	int itemToSplit = 0;
[846]	2524	while (itemToSplit < layoutData->items.size() && layoutData->items.at(itemToSplit).position <= strPos)
[2]	2525	itemToSplit++;
	2526	itemToSplit--;
[846]	2527	if (layoutData->items.at(itemToSplit).position == strPos) {
[2]	2528	// already a split at the requested position
	2529	return;
	2530	}
[846]	2531	splitItem(itemToSplit, strPos - layoutData->items.at(itemToSplit).position);
[2]	2532	}
	2533
	2534	void QTextEngine::splitItem(int item, int pos) const
	2535	{
	2536	if (pos <= 0)
	2537	return;
	2538
[846]	2539	layoutData->items.insert(item + 1, layoutData->items[item]);
[2]	2540	QScriptItem &oldItem = layoutData->items[item];
	2541	QScriptItem &newItem = layoutData->items[item+1];
	2542	newItem.position += pos;
	2543
	2544	if (oldItem.num_glyphs) {
	2545	// already shaped, break glyphs aswell
	2546	int breakGlyph = logClusters(&oldItem)[pos];
	2547
	2548	newItem.num_glyphs = oldItem.num_glyphs - breakGlyph;
	2549	oldItem.num_glyphs = breakGlyph;
	2550	newItem.glyph_data_offset = oldItem.glyph_data_offset + breakGlyph;
	2551
	2552	for (int i = 0; i < newItem.num_glyphs; i++)
	2553	logClusters(&newItem)[i] -= breakGlyph;
	2554
	2555	QFixed w = 0;
	2556	const QGlyphLayout g = shapedGlyphs(&oldItem);
	2557	for(int j = 0; j < breakGlyph; ++j)
	2558	w += g.advances_x[j];
	2559
	2560	newItem.width = oldItem.width - w;
	2561	oldItem.width = w;
	2562	}
	2563
	2564	// qDebug("split at position %d itempos=%d", pos, item);
	2565	}
	2566
[769]	2567	Q_GUI_EXPORT extern int qt_defaultDpiY();
[2]	2568
	2569	QFixed QTextEngine::calculateTabWidth(int item, QFixed x) const
	2570	{
	2571	const QScriptItem &si = layoutData->items[item];
	2572
	2573	QFixed dpiScale = 1;
	2574	if (block.docHandle() && block.docHandle()->layout()) {
	2575	QPaintDevice *pdev = block.docHandle()->layout()->paintDevice();
	2576	if (pdev)
	2577	dpiScale = QFixed::fromReal(pdev->logicalDpiY() / qreal(qt_defaultDpiY()));
	2578	} else {
	2579	dpiScale = QFixed::fromReal(fnt.d->dpi / qreal(qt_defaultDpiY()));
	2580	}
	2581
	2582	QList<QTextOption::Tab> tabArray = option.tabs();
	2583	if (!tabArray.isEmpty()) {
[846]	2584	if (isRightToLeft()) { // rebase the tabArray positions.
[2]	2585	QList<QTextOption::Tab> newTabs;
	2586	QList<QTextOption::Tab>::Iterator iter = tabArray.begin();
	2587	while(iter != tabArray.end()) {
	2588	QTextOption::Tab tab = *iter;
	2589	if (tab.type == QTextOption::LeftTab)
	2590	tab.type = QTextOption::RightTab;
	2591	else if (tab.type == QTextOption::RightTab)
	2592	tab.type = QTextOption::LeftTab;
	2593	newTabs << tab;
	2594	++iter;
	2595	}
	2596	tabArray = newTabs;
	2597	}
	2598	for (int i = 0; i < tabArray.size(); ++i) {
	2599	QFixed tab = QFixed::fromReal(tabArray[i].position) * dpiScale;
	2600	if (tab > x) { // this is the tab we need.
	2601	QTextOption::Tab tabSpec = tabArray[i];
	2602	int tabSectionEnd = layoutData->string.count();
	2603	if (tabSpec.type == QTextOption::RightTab \|\| tabSpec.type == QTextOption::CenterTab) {
	2604	// find next tab to calculate the width required.
	2605	tab = QFixed::fromReal(tabSpec.position);
	2606	for (int i=item + 1; i < layoutData->items.count(); i++) {
	2607	const QScriptItem &item = layoutData->items[i];
	2608	if (item.analysis.flags == QScriptAnalysis::TabOrObject) { // found it.
	2609	tabSectionEnd = item.position;
	2610	break;
	2611	}
	2612	}
	2613	}
	2614	else if (tabSpec.type == QTextOption::DelimiterTab)
	2615	// find delimitor character to calculate the width required
	2616	tabSectionEnd = qMax(si.position, layoutData->string.indexOf(tabSpec.delimiter, si.position) + 1);
	2617
	2618	if (tabSectionEnd > si.position) {
	2619	QFixed length;
	2620	// Calculate the length of text between this tab and the tabSectionEnd
	2621	for (int i=item; i < layoutData->items.count(); i++) {
	2622	QScriptItem &item = layoutData->items[i];
	2623	if (item.position > tabSectionEnd \|\| item.position <= si.position)
	2624	continue;
	2625	shape(i); // first, lets make sure relevant text is already shaped
	2626	QGlyphLayout glyphs = this->shapedGlyphs(&item);
	2627	const int end = qMin(item.position + item.num_glyphs, tabSectionEnd) - item.position;
	2628	for (int i=0; i < end; i++)
	2629	length += glyphs.advances_x[i] * !glyphs.attributes[i].dontPrint;
	2630	if (end + item.position == tabSectionEnd && tabSpec.type == QTextOption::DelimiterTab) // remove half of matching char
	2631	length -= glyphs.advances_x[end] / 2 * !glyphs.attributes[end].dontPrint;
	2632	}
	2633
	2634	switch (tabSpec.type) {
	2635	case QTextOption::CenterTab:
	2636	length /= 2;
	2637	// fall through
	2638	case QTextOption::DelimiterTab:
	2639	// fall through
	2640	case QTextOption::RightTab:
	2641	tab = QFixed::fromReal(tabSpec.position) * dpiScale - length;
	2642	if (tab < 0) // default to tab taking no space
	2643	return QFixed();
	2644	break;
	2645	case QTextOption::LeftTab:
	2646	break;
	2647	}
	2648	}
	2649	return tab - x;
	2650	}
	2651	}
	2652	}
	2653	QFixed tab = QFixed::fromReal(option.tabStop());
	2654	if (tab <= 0)
	2655	tab = 80; // default
	2656	tab *= dpiScale;
	2657	QFixed nextTabPos = ((x / tab).truncate() + 1) * tab;
	2658	QFixed tabWidth = nextTabPos - x;
	2659
	2660	return tabWidth;
	2661	}
	2662
	2663	void QTextEngine::resolveAdditionalFormats() const
	2664	{
	2665	if (!specialData \|\| specialData->addFormats.isEmpty()
	2666	\|\| !block.docHandle()
	2667	\|\| !specialData->resolvedFormatIndices.isEmpty())
	2668	return;
	2669
	2670	QTextFormatCollection *collection = this->formats();
	2671
	2672	specialData->resolvedFormatIndices.clear();
	2673	QVector<int> indices(layoutData->items.count());
	2674	for (int i = 0; i < layoutData->items.count(); ++i) {
	2675	QTextCharFormat f = format(&layoutData->items.at(i));
	2676	indices[i] = collection->indexForFormat(f);
	2677	}
	2678	specialData->resolvedFormatIndices = indices;
	2679	}
	2680
	2681	QStackTextEngine::QStackTextEngine(const QString &string, const QFont &f)
[846]	2682	: QTextEngine(string, f),
	2683	_layoutData(string, _memory, MemSize)
[2]	2684	{
	2685	stackEngine = true;
	2686	layoutData = &_layoutData;
	2687	}
	2688
	2689	QTextItemInt::QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFormat &format)
	2690	: justified(false), underlineStyle(QTextCharFormat::NoUnderline), charFormat(format),
	2691	num_chars(0), chars(0), logClusters(0), f(0), fontEngine(0)
	2692	{
	2693	// explicitly initialize flags so that initFontAttributes can be called
	2694	// multiple times on the same TextItem
	2695	flags = 0;
	2696	if (si.analysis.bidiLevel %2)
	2697	flags \|= QTextItem::RightToLeft;
	2698	ascent = si.ascent;
	2699	descent = si.descent;
	2700	f = font;
	2701	fontEngine = f->d->engineForScript(si.analysis.script);
	2702	Q_ASSERT(fontEngine);
	2703
	2704	if (format.hasProperty(QTextFormat::TextUnderlineStyle)) {
	2705	underlineStyle = format.underlineStyle();
	2706	} else if (format.boolProperty(QTextFormat::FontUnderline)
	2707	\|\| f->d->underline) {
	2708	underlineStyle = QTextCharFormat::SingleUnderline;
	2709	}
	2710
	2711	// compat
	2712	if (underlineStyle == QTextCharFormat::SingleUnderline)
	2713	flags \|= QTextItem::Underline;
	2714
	2715	if (f->d->overline \|\| format.fontOverline())
	2716	flags \|= QTextItem::Overline;
	2717	if (f->d->strikeOut \|\| format.fontStrikeOut())
	2718	flags \|= QTextItem::StrikeOut;
	2719	}
	2720
[846]	2721	QTextItemInt::QTextItemInt(const QGlyphLayout &g, QFont font, const QChar chars_, int numChars, QFontEngine *fe)
	2722	: flags(0), justified(false), underlineStyle(QTextCharFormat::NoUnderline),
	2723	num_chars(numChars), chars(chars_), logClusters(0), f(font), glyphs(g), fontEngine(fe)
	2724	{
	2725	}
	2726
[2]	2727	QTextItemInt QTextItemInt::midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const
	2728	{
	2729	QTextItemInt ti = *this;
	2730	const int end = firstGlyphIndex + numGlyphs;
	2731	ti.glyphs = glyphs.mid(firstGlyphIndex, numGlyphs);
	2732	ti.fontEngine = fontEngine;
	2733
	2734	if (logClusters && chars) {
	2735	const int logClusterOffset = logClusters[0];
	2736	while (logClusters[ti.chars - chars] - logClusterOffset < firstGlyphIndex)
	2737	++ti.chars;
	2738
	2739	ti.logClusters += (ti.chars - chars);
	2740
	2741	ti.num_chars = 0;
	2742	int char_start = ti.chars - chars;
	2743	while (char_start + ti.num_chars < num_chars && ti.logClusters[ti.num_chars] - logClusterOffset < end)
	2744	++ti.num_chars;
	2745	}
	2746	return ti;
	2747	}
	2748
	2749
	2750	QTransform qt_true_matrix(qreal w, qreal h, QTransform x)
	2751	{
	2752	QRectF rect = x.mapRect(QRectF(0, 0, w, h));
	2753	return x * QTransform::fromTranslate(-rect.x(), -rect.y());
	2754	}
	2755
	2756
	2757	glyph_metrics_t glyph_metrics_t::transformed(const QTransform &matrix) const
	2758	{
	2759	if (matrix.type() < QTransform::TxTranslate)
	2760	return *this;
	2761
	2762	glyph_metrics_t m = *this;
	2763
	2764	qreal w = width.toReal();
	2765	qreal h = height.toReal();
	2766	QTransform xform = qt_true_matrix(w, h, matrix);
	2767
	2768	QRectF rect(0, 0, w, h);
	2769	rect = xform.mapRect(rect);
	2770	m.width = QFixed::fromReal(rect.width());
	2771	m.height = QFixed::fromReal(rect.height());
	2772
	2773	QLineF l = xform.map(QLineF(x.toReal(), y.toReal(), xoff.toReal(), yoff.toReal()));
	2774
	2775	m.x = QFixed::fromReal(l.x1());
	2776	m.y = QFixed::fromReal(l.y1());
	2777
	2778	// The offset is relative to the baseline which is why we use dx/dy of the line
	2779	m.xoff = QFixed::fromReal(l.dx());
	2780	m.yoff = QFixed::fromReal(l.dy());
	2781
	2782	return m;
	2783	}
	2784
	2785
	2786	QT_END_NAMESPACE

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/gui/text/qtextengine.cpp

Download in other formats: