TDE
/
tqt3
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tqt3
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
tqt3/src/kernel/qscriptengine.cpp

1625 lines
53 KiB
Raw Permalink Blame History

/****************************************************************************
**
** Copyright (C) 2003-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the kernel module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file. Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "qscriptengine_p.h"
#include "ntqstring.h"
#include "ntqrect.h"
#include "ntqfont.h"
#include <private/qunicodetables_p.h>
#include "qtextengine_p.h"
#include "qfontengine_p.h"
#include <stdlib.h>
#undef None
#undef Pre
#undef Above
#undef Below
const int Prealloc = 256;
template<class T>
class TQVarLengthArray
{
public:
inline explicit TQVarLengthArray(int size = 0);
inline ~TQVarLengthArray() {
if (ptr != reinterpret_cast<T *>(array))
free(ptr);
}
inline int size() const { return s; }
inline int count() const { return s; }
inline bool isEmpty() const { return (s == 0); }
inline void resize(int size);
inline void clear() { resize(0); }
inline int capacity() const { return a; }
inline void reserve(int size);
inline T &operator[](int idx) {
Q_ASSERT(idx >= 0 && idx < s);
return ptr[idx];
}
inline const T &operator[](int idx) const {
Q_ASSERT(idx >= 0 && idx < s);
return ptr[idx];
}
inline void append(const T &t) {
const int idx = s;
resize(idx + 1);
ptr[idx] = t;
}
inline T *data() { return ptr; }
inline const T *data() const { return ptr; }
inline const T * constData() const { return ptr; }
private:
void realloc(int size, int alloc);
int a;
int s;
T *ptr;
TQ_UINT64 array[((Prealloc * sizeof(T)) / sizeof(TQ_UINT64)) + 1];
};
template <class T>
TQ_INLINE_TEMPLATES TQVarLengthArray<T>::TQVarLengthArray(int asize)
: s(asize) {
if (s > Prealloc) {
ptr = reinterpret_cast<T *>(malloc(s * sizeof(T)));
a = s;
} else {
ptr = reinterpret_cast<T *>(array);
a = Prealloc;
}
}
// --------------------------------------------------------------------------------------------------------------------------------------------
//
// Basic processing
//
// --------------------------------------------------------------------------------------------------------------------------------------------
static inline void positionCluster(TQShaperItem *item, int gfrom, int glast)
{
int nmarks = glast - gfrom;
if (nmarks <= 0) {
tqWarning("positionCluster: no marks to position!");
return;
}
TQFontEngine *f = item->font;
glyph_metrics_t baseInfo = f->boundingBox(item->glyphs[gfrom]);
if (item->script == TQFont::Hebrew)
// we need to attach below the baseline, because of the hebrew iud.
baseInfo.height = TQMAX(baseInfo.height, -baseInfo.y);
TQRect baseRect(baseInfo.x, baseInfo.y, baseInfo.width, baseInfo.height);
// tqDebug("---> positionCluster: cluster from %d to %d", gfrom, glast);
// tqDebug("baseInfo: %f/%f (%f/%f) off=%f/%f", baseInfo.x, baseInfo.y, baseInfo.width, baseInfo.height, baseInfo.xoff, baseInfo.yoff);
int size = (f->ascent()/10);
int offsetBase = (size - 4) / 4 + TQMIN(size, 4) + 1;
// tqDebug("offset = %f", offsetBase);
bool rightToLeft = item->flags & TQTextEngine::RightToLeft;
int i;
unsigned char lastCmb = 0;
TQRect attachmentRect;
for(i = 1; i <= nmarks; i++) {
glyph_t mark = item->glyphs[gfrom+i];
TQPoint p;
glyph_metrics_t markInfo = f->boundingBox(mark);
TQRect markRect(markInfo.x, markInfo.y, markInfo.width, markInfo.height);
// tqDebug("markInfo: %f/%f (%f/%f) off=%f/%f", markInfo.x, markInfo.y, markInfo.width, markInfo.height, markInfo.xoff, markInfo.yoff);
int offset = offsetBase;
unsigned char cmb = item->attributes[gfrom+i].combiningClass;
// ### maybe the whole position determination should move down to heuristicSetGlyphAttributes. Would save some
// bits in the glyphAttributes structure.
if (cmb < 200) {
// fixed position classes. We approximate by mapping to one of the others.
// currently I added only the ones for arabic, hebrew, lao and thai.
// for Lao and Thai marks with class 0, see below (heuristicSetGlyphAttributes)
// add a bit more offset to arabic, a bit hacky
if (cmb >= 27 && cmb <= 36 && offset < 3)
offset +=1;
// below
if ((cmb >= 10 && cmb <= 18) ||
cmb == 20 || cmb == 22 ||
cmb == 29 || cmb == 32)
cmb = TQChar::Combining_Below;
// above
else if (cmb == 23 || cmb == 27 || cmb == 28 ||
cmb == 30 || cmb == 31 || (cmb >= 33 && cmb <= 36))
cmb = TQChar::Combining_Above;
//below-right
else if (cmb == 9 || cmb == 103 || cmb == 118)
cmb = TQChar::Combining_BelowRight;
// above-right
else if (cmb == 24 || cmb == 107 || cmb == 122)
cmb = TQChar::Combining_AboveRight;
else if (cmb == 25)
cmb = TQChar::Combining_AboveLeft;
// fixed:
// 19 21
}
// combining marks of different class don't interact. Reset the rectangle.
if (cmb != lastCmb) {
//tqDebug("resetting rect");
attachmentRect = baseRect;
}
switch(cmb) {
case TQChar::Combining_DoubleBelow:
// ### wrong in rtl context!
case TQChar::Combining_BelowLeft:
p += TQPoint(0, offset);
case TQChar::Combining_BelowLeftAttached:
p += attachmentRect.bottomLeft() - markRect.topLeft();
break;
case TQChar::Combining_Below:
p += TQPoint(0, offset);
case TQChar::Combining_BelowAttached:
p += attachmentRect.bottomLeft() - markRect.topLeft();
p += TQPoint((attachmentRect.width() - markRect.width())/2 , 0);
break;
case TQChar::Combining_BelowRight:
p += TQPoint(0, offset);
case TQChar::Combining_BelowRightAttached:
p += attachmentRect.bottomRight() - markRect.topRight();
break;
case TQChar::Combining_Left:
p += TQPoint(-offset, 0);
case TQChar::Combining_LeftAttached:
break;
case TQChar::Combining_Right:
p += TQPoint(offset, 0);
case TQChar::Combining_RightAttached:
break;
case TQChar::Combining_DoubleAbove:
// ### wrong in RTL context!
case TQChar::Combining_AboveLeft:
p += TQPoint(0, -offset);
case TQChar::Combining_AboveLeftAttached:
p += attachmentRect.topLeft() - markRect.bottomLeft();
break;
case TQChar::Combining_Above:
p += TQPoint(0, -offset);
case TQChar::Combining_AboveAttached:
p += attachmentRect.topLeft() - markRect.bottomLeft();
p += TQPoint((attachmentRect.width() - markRect.width())/2 , 0);
break;
case TQChar::Combining_AboveRight:
p += TQPoint(0, -offset);
case TQChar::Combining_AboveRightAttached:
p += attachmentRect.topRight() - markRect.bottomRight();
break;
case TQChar::Combining_IotaSubscript:
default:
break;
}
// tqDebug("char=%x combiningClass = %d offset=%d/%d", mark, cmb, p.x(), p.y());
markRect.moveBy(p.x(), p.y());
attachmentRect |= markRect;
lastCmb = cmb;
if (rightToLeft) {
item->offsets[gfrom+i].x = p.x();
item->offsets[gfrom+i].y = p.y();
} else {
item->offsets[gfrom+i].x = p.x() - baseInfo.xoff;
item->offsets[gfrom+i].y = p.y() - baseInfo.yoff;
}
item->advances[gfrom+i] = 0;
}
item->has_positioning = TRUE;
}
void qt_heuristicPosition(TQShaperItem *item)
{
int cEnd = -1;
int i = item->num_glyphs;
while (i--) {
if (cEnd == -1 && item->attributes[i].mark) {
cEnd = i;
} else if (cEnd != -1 && !item->attributes[i].mark) {
positionCluster(item, i, cEnd);
cEnd = -1;
}
}
}
// set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs
// and no reordering.
// also computes logClusters heuristically
static void heuristicSetGlyphAttributes(TQShaperItem *item, const TQChar *uc, int length)
{
// justification is missing here!!!!!
if ( item->num_glyphs != length )
tqWarning("TQScriptEngine::heuristicSetGlyphAttributes: char length and num glyphs disagree" );
unsigned short *logClusters = item->log_clusters;
int i;
for (i = 0; i < length; ++i)
logClusters[i] = i;
// first char in a run is never (treated as) a mark
int cStart = 0;
item->attributes[0].mark = FALSE;
item->attributes[0].clusterStart = TRUE;
item->attributes[0].combiningClass = 0;
if (qIsZeroWidthChar(uc[0].unicode())) {
item->attributes[0].zeroWidth = TRUE;
item->advances[0] = 0;
item->has_positioning = TRUE;
} else {
item->attributes[0].zeroWidth = FALSE;
}
int lastCat = ::category(uc[0]);
for (i = 1; i < length; ++i) {
int cat = ::category(uc[i]);
if (qIsZeroWidthChar(uc[i].unicode())) {
item->attributes[i].mark = FALSE;
item->attributes[i].clusterStart = TRUE;
item->attributes[i].zeroWidth = TRUE;
item->attributes[i].combiningClass = 0;
cStart = i;
item->advances[i] = 0;
item->has_positioning = TRUE;
} else if (cat != TQChar::Mark_NonSpacing) {
item->attributes[i].mark = FALSE;
item->attributes[i].clusterStart = TRUE;
item->attributes[i].combiningClass = 0;
cStart = i;
} else {
int cmb = ::combiningClass(uc[i]);
if (cmb == 0) {
// Fix 0 combining classes
if ((uc[i].unicode() & 0xff00) == 0x0e00) {
// thai or lao
unsigned char col = uc[i].cell();
if (col == 0x31 ||
col == 0x34 ||
col == 0x35 ||
col == 0x36 ||
col == 0x37 ||
col == 0x47 ||
col == 0x4c ||
col == 0x4d ||
col == 0x4e) {
cmb = TQChar::Combining_AboveRight;
} else if (col == 0xb1 ||
col == 0xb4 ||
col == 0xb5 ||
col == 0xb6 ||
col == 0xb7 ||
col == 0xbb ||
col == 0xcc ||
col == 0xcd) {
cmb = TQChar::Combining_Above;
} else if (col == 0xbc) {
cmb = TQChar::Combining_Below;
}
}
}
item->attributes[i].mark = TRUE;
item->attributes[i].clusterStart = FALSE;
item->attributes[i].combiningClass = cmb;
logClusters[i] = cStart;
item->advances[i] = 0;
item->has_positioning = TRUE;
}
if (lastCat == TQChar::Separator_Space)
item->attributes[i-1].justification = GlyphAttributes::Space;
else if (cat != TQChar::Mark_NonSpacing)
item->attributes[i-1].justification = GlyphAttributes::Character;
else
item->attributes[i-1].justification = GlyphAttributes::NoJustification;
lastCat = cat;
}
}
static void heuristicSetGlyphAttributes(TQShaperItem *item)
{
heuristicSetGlyphAttributes(item, item->string->unicode() + item->from, item->length);
}
static bool basic_shape(TQShaperItem *item)
{
if (item->font->stringToCMap(item->string->unicode()+item->from, item->length, item->glyphs, item->advances,
&item->num_glyphs, item->flags & TQTextEngine::RightToLeft) != TQFontEngine::NoError)
return FALSE;
heuristicSetGlyphAttributes(item);
qt_heuristicPosition(item);
return TRUE;
}
// --------------------------------------------------------------------------------------------------------------------------------------------
//
// Middle eastern languages
//
// --------------------------------------------------------------------------------------------------------------------------------------------
// Uniscribe also defines dlig for Hebrew, but we leave this out for now, as it's mostly
// ligatures one does not want in modern Hebrew (as lam-alef ligatures).
enum {
CcmpProperty = 0x1
};
#if defined(TQ_WS_X11) && !defined(TQT_NO_XFTFREETYPE)
static const TQOpenType::Features hebrew_features[] = {
{ FT_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
{0, 0}
};
#endif
/* Hebrew shaping. In the non opentype case we try to use the
presentation forms specified for Hebrew. Especially for the
ligatures with Dagesh this gives much better results than we could
achieve manually.
*/
static bool hebrew_shape(TQShaperItem *item)
{
Q_ASSERT(item->script == TQFont::Hebrew);
#if defined(TQ_WS_X11) && !defined(TQT_NO_XFTFREETYPE)
TQOpenType *openType = item->font->openType();
if (openType && openType->supportsScript(item->script)) {
openType->selectScript(item->script, hebrew_features);
if (item->font->stringToCMap(item->string->unicode()+item->from, item->length, item->glyphs, item->advances,
&item->num_glyphs, item->flags & TQTextEngine::RightToLeft) != TQFontEngine::NoError)
return FALSE;
heuristicSetGlyphAttributes(item);
openType->shape(item);
return openType->positionAndAdd(item);
}
#endif
enum {
Dagesh = 0x5bc,
ShinDot = 0x5c1,
SinDot = 0x5c2,
Patah = 0x5b7,
Qamats = 0x5b8,
Holam = 0x5b9,
Rafe = 0x5bf
};
unsigned short chars[512];
TQChar *shapedChars = item->length > 256 ? (TQChar *)::malloc(2*item->length * sizeof(TQChar)) : (TQChar *)chars;
const TQChar *uc = item->string->unicode() + item->from;
unsigned short *logClusters = item->log_clusters;
*shapedChars = *uc;
logClusters[0] = 0;
int slen = 1;
int cluster_start = 0;
int i;
for (i = 1; i < item->length; ++i) {
ushort base = shapedChars[slen-1].unicode();
ushort shaped = 0;
bool invalid = FALSE;
if (uc[i].unicode() == Dagesh) {
if (base >= 0x5d0
&& base <= 0x5ea
&& base != 0x5d7
&& base != 0x5dd
&& base != 0x5df
&& base != 0x5e2
&& base != 0x5e5) {
shaped = base - 0x5d0 + 0xfb30;
} else if (base == 0xfb2a || base == 0xfb2b /* Shin with Shin or Sin dot */) {
shaped = base + 2;
} else {
invalid = TRUE;
}
} else if (uc[i].unicode() == ShinDot) {
if (base == 0x05e9)
shaped = 0xfb2a;
else if (base == 0xfb49)
shaped = 0xfb2c;
else
invalid = TRUE;
} else if (uc[i].unicode() == SinDot) {
if (base == 0x05e9)
shaped = 0xfb2b;
else if (base == 0xfb49)
shaped = 0xfb2d;
else
invalid = TRUE;
} else if (uc[i].unicode() == Patah) {
if (base == 0x5d0)
shaped = 0xfb2e;
} else if (uc[i].unicode() == Qamats) {
if (base == 0x5d0)
shaped = 0xfb2f;
} else if (uc[i].unicode() == Holam) {
if (base == 0x5d5)
shaped = 0xfb4b;
} else if (uc[i].unicode() == Rafe) {
if (base == 0x5d1)
shaped = 0xfb4c;
else if (base == 0x5db)
shaped = 0xfb4d;
else if (base == 0x5e4)
shaped = 0xfb4e;
}
if (invalid) {
shapedChars[slen] = 0x25cc;
item->attributes[slen].clusterStart = TRUE;
item->attributes[slen].mark = FALSE;
item->attributes[slen].combiningClass = 0;
cluster_start = slen;
++slen;
}
if (shaped) {
if (item->font->canRender((TQChar *)&shaped, 1)) {
shapedChars[slen-1] = TQChar(shaped);
} else
shaped = 0;
}
if (!shaped) {
shapedChars[slen] = uc[i];
if (::category(uc[i]) != TQChar::Mark_NonSpacing) {
item->attributes[slen].clusterStart = TRUE;
item->attributes[slen].mark = FALSE;
item->attributes[slen].combiningClass = 0;
cluster_start = slen;
} else {
item->attributes[slen].clusterStart = FALSE;
item->attributes[slen].mark = TRUE;
item->attributes[slen].combiningClass = ::combiningClass(uc[i]);
}
++slen;
}
logClusters[i] = cluster_start;
}
if (item->font->stringToCMap(shapedChars, slen, item->glyphs, item->advances,
&item->num_glyphs, item->flags & TQTextEngine::RightToLeft) != TQFontEngine::NoError)
return FALSE;
for (i = 0; i < item->num_glyphs; ++i) {
if (item->attributes[i].mark)
item->advances[i] = 0;
}
qt_heuristicPosition(item);
if (item->length > 256)
::free(shapedChars);
return TRUE;
}
// these groups correspond to the groups defined in the Unicode standard.
// Some of these groups are equal whith regards to both joining and line breaking behaviour,
// and thus have the same enum value
//
// I'm not sure the mapping of syriac to arabic enums is correct with regards to justification, but as
// I couldn't find any better document I'll hope for the best.
enum ArabicGroup {
// NonJoining
ArabicNone,
ArabicSpace,
// Transparent
Transparent,
// Causing
Center,
Kashida,
// Arabic
// Dual
Beh,
Noon,
Meem = Noon,
Heh = Noon,
KnottedHeh = Noon,
HehGoal = Noon,
SwashKaf = Noon,
Yeh,
Hah,
Seen,
Sad = Seen,
Tah,
Kaf = Tah,
Gaf = Tah,
Lam = Tah,
Ain,
Feh = Ain,
Qaf = Ain,
// Right
Alef,
Waw,
Dal,
TehMarbuta = Dal,
Reh,
HamzaOnHehGoal,
YehWithTail = HamzaOnHehGoal,
YehBarre = HamzaOnHehGoal,
// Syriac
// Dual
Beth = Beh,
Gamal = Ain,
Heth = Noon,
Teth = Hah,
Yudh = Noon,
Kaph = Noon,
Lamadh = Lam,
Mim = Noon,
Nun = Noon,
Semakh = Noon,
FinalSemakh = Noon,
SyriacE = Ain,
Pe = Ain,
ReversedPe = Hah,
Qaph = Noon,
Shin = Noon,
Fe = Ain,
// Right
Alaph = Alef,
Dalath = Dal,
He = Dal,
SyriacWaw = Waw,
Zain = Alef,
YudhHe = Waw,
Sadhe = HamzaOnHehGoal,
Taw = Dal,
// Compiler bug? Otherwise ArabicGroupsEnd would be equal to Dal + 1.
Dummy = HamzaOnHehGoal,
ArabicGroupsEnd
};
static const unsigned char arabic_group[0x150] = {
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, Alef, Alef,
Waw, Alef, Yeh, Alef,
Beh, TehMarbuta, Beh, Beh,
Hah, Hah, Hah, Dal,
Dal, Reh, Reh, Seen,
Seen, Sad, Sad, Tah,
Tah, Ain, Ain, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
// 0x640
Kashida, Feh, Qaf, Kaf,
Lam, Meem, Noon, Heh,
Waw, Yeh, Yeh, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, Beh, Qaf,
Transparent, Alef, Alef, Alef,
ArabicNone, Alef, Waw, Waw,
Yeh, Beh, Beh, Beh,
Beh, Beh, Beh, Beh,
// 0x680
Beh, Hah, Hah, Hah,
Hah, Hah, Hah, Hah,
Dal, Dal, Dal, Dal,
Dal, Dal, Dal, Dal,
Dal, Reh, Reh, Reh,
Reh, Reh, Reh, Reh,
Reh, Reh, Seen, Seen,
Seen, Sad, Sad, Tah,
Ain, Feh, Feh, Feh,
Feh, Feh, Feh, Qaf,
Qaf, Gaf, SwashKaf, Gaf,
Kaf, Kaf, Kaf, Gaf,
Gaf, Gaf, Gaf, Gaf,
Gaf, Lam, Lam, Lam,
Lam, Noon, Noon, Noon,
Noon, Noon, KnottedHeh, Hah,
// 0x6c0
TehMarbuta, HehGoal, HamzaOnHehGoal, HamzaOnHehGoal,
Waw, Waw, Waw, Waw,
Waw, Waw, Waw, Waw,
Yeh, YehWithTail, Yeh, Waw,
Yeh, Yeh, YehBarre, YehBarre,
ArabicNone, TehMarbuta, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, ArabicNone, ArabicNone, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, ArabicNone, ArabicNone, Transparent,
Transparent, ArabicNone, Transparent, Transparent,
Transparent, Transparent, Dal, Reh,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, Seen, Sad,
Ain, ArabicNone, ArabicNone, KnottedHeh,
// 0x700
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
ArabicNone, ArabicNone, ArabicNone, ArabicNone,
Alaph, Transparent, Beth, Gamal,
Gamal, Dalath, Dalath, He,
SyriacWaw, Zain, Heth, Teth,
Teth, Yudh, YudhHe, Kaph,
Lamadh, Mim, Nun, Semakh,
FinalSemakh, SyriacE, Pe, ReversedPe,
Sadhe, Qaph, Dalath, Shin,
Taw, Beth, Gamal, Dalath,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, Transparent,
Transparent, Transparent, Transparent, ArabicNone,
ArabicNone, Zain, Kaph, Fe,
};
static inline ArabicGroup arabicGroup(unsigned short uc)
{
if (uc >= 0x0600 && uc < 0x750)
return (ArabicGroup) arabic_group[uc-0x600];
else if (uc == 0x200d)
return Center;
else if (::category(uc) == TQChar::Separator_Space)
return ArabicSpace;
else
return ArabicNone;
}
/*
Arabic shaping obeys a number of rules according to the joining classes (see Unicode book, section on
arabic).
Each unicode char has a joining class (right, dual (left&right), center (joincausing) or transparent).
transparent joining is not encoded in TQChar::joining(), but applies to all combining marks and format marks.
Right join-causing: dual + center
Left join-causing: dual + right + center
Rules are as follows (for a string already in visual order, as we have it here):
R1 Transparent characters do not affect joining behaviour.
R2 A right joining character, that has a right join-causing char on the right will get form XRight
(R3 A left joining character, that has a left join-causing char on the left will get form XLeft)
Note: the above rule is meaningless, as there are no pure left joining characters defined in Unicode
R4 A dual joining character, that has a left join-causing char on the left and a right join-causing char on
the right will get form XMedial
R5 A dual joining character, that has a right join causing char on the right, and no left join causing char on the left
will get form XRight
R6 A dual joining character, that has a left join causing char on the left, and no right join causing char on the right
will get form XLeft
R7 Otherwise the character will get form XIsolated
Additionally we have to do the minimal ligature support for lam-alef ligatures:
L1 Transparent characters do not affect ligature behaviour.
L2 Any sequence of Alef(XRight) + Lam(XMedial) will form the ligature Alef.Lam(XLeft)
L3 Any sequence of Alef(XRight) + Lam(XLeft) will form the ligature Alef.Lam(XIsolated)
The state table below handles rules R1-R7.
*/
enum Shape {
XIsolated,
XFinal,
XInitial,
XMedial,
// intermediate state
XCausing
};
enum Joining {
JNone,
JCausing,
JDual,
JRight,
JTransparent
};
static const Joining joining_for_group[ArabicGroupsEnd] = {
// NonJoining
JNone, // ArabicNone
JNone, // ArabicSpace
// Transparent
JTransparent, // Transparent
// Causing
JCausing, // Center
JCausing, // Kashida
// Dual
JDual, // Beh
JDual, // Noon
JDual, // Yeh
JDual, // Hah
JDual, // Seen
JDual, // Tah
JDual, // Ain
// Right
JRight, // Alef
JRight, // Waw
JRight, // Dal
JRight, // Reh
JRight // HamzaOnHehGoal
};
struct JoiningPair {
Shape form1;
Shape form2;
};
static const JoiningPair joining_table[5][4] =
// None, Causing, Dual, Right
{
{ { XIsolated, XIsolated }, { XIsolated, XCausing }, { XIsolated, XInitial }, { XIsolated, XIsolated } }, // XIsolated
{ { XFinal, XIsolated }, { XFinal, XCausing }, { XFinal, XInitial }, { XFinal, XIsolated } }, // XFinal
{ { XIsolated, XIsolated }, { XInitial, XCausing }, { XInitial, XMedial }, { XInitial, XFinal } }, // XInitial
{ { XFinal, XIsolated }, { XMedial, XCausing }, { XMedial, XMedial }, { XMedial, XFinal } }, // XMedial
{ { XIsolated, XIsolated }, { XIsolated, XCausing }, { XIsolated, XMedial }, { XIsolated, XFinal } }, // XCausing
};
/*
According to http://www.microsoft.com/middleeast/Arabicdev/IE6/KBase.asp
1. Find the priority of the connecting opportunities in each word
2. Add expansion at the highest priority connection opportunity
3. If more than one connection opportunity have the same highest value,
use the opportunity closest to the end of the word.
Following is a chart that provides the priority for connection
opportunities and where expansion occurs. The character group names
are those in table 6.6 of the UNICODE 2.0 book.
PrioritY Glyph Condition Kashida Location
Arabic_Kashida User inserted Kashida The user entered a Kashida in a position. After the user
(Shift+j or Shift+[E with hat]) Thus, it is the highest priority to insert an inserted kashida
automatic kashida.
Arabic_Seen Seen, Sad Connecting to the next character. After the character.
(Initial or medial form).
Arabic_HaaDal Teh Marbutah, Haa, Dal Connecting to previous character. Before the final form
of these characters.
Arabic_Alef Alef, Tah, Lam, Connecting to previous character. Before the final form
Kaf and Gaf of these characters.
Arabic_BaRa Reh, Yeh Connected to medial Beh Before preceding medial Baa
Arabic_Waw Waw, Ain, Qaf, Feh Connecting to previous character. Before the final form of
these characters.
Arabic_Normal Other connecting Connecting to previous character. Before the final form
characters of these characters.
This seems to imply that we have at most one kashida point per arabic word.
*/
struct TQArabicProperties {
unsigned char shape;
unsigned char justification;
};
static void getArabicProperties(const unsigned short *chars, int len, TQArabicProperties *properties)
{
// tqDebug("arabicSyriacOpenTypeShape: properties:");
int lastPos = 0;
int lastGroup = ArabicNone;
ArabicGroup group = arabicGroup(chars[0]);
Joining j = joining_for_group[group];
Shape shape = joining_table[XIsolated][j].form2;
properties[0].justification = GlyphAttributes::NoJustification;
for (int i = 1; i < len; ++i) {
// #### fix handling for spaces and punktuation
properties[i].justification = GlyphAttributes::NoJustification;
group = arabicGroup(chars[i]);
j = joining_for_group[group];
if (j == JTransparent) {
properties[i].shape = XIsolated;
continue;
}
properties[lastPos].shape = joining_table[shape][j].form1;
shape = joining_table[shape][j].form2;
switch(lastGroup) {
case Seen:
if (properties[lastPos].shape == XInitial || properties[lastPos].shape == XMedial)
properties[i-1].justification = GlyphAttributes::Arabic_Seen;
break;
case Hah:
if (properties[lastPos].shape == XFinal)
properties[lastPos-1].justification = GlyphAttributes::Arabic_HaaDal;
break;
case Alef:
if (properties[lastPos].shape == XFinal)
properties[lastPos-1].justification = GlyphAttributes::Arabic_Alef;
break;
case Ain:
if (properties[lastPos].shape == XFinal)
properties[lastPos-1].justification = GlyphAttributes::Arabic_Waw;
break;
case Noon:
if (properties[lastPos].shape == XFinal)
properties[lastPos-1].justification = GlyphAttributes::Arabic_Normal;
break;
case ArabicNone:
break;
default:
Q_ASSERT(FALSE);
}
lastGroup = ArabicNone;
switch(group) {
case ArabicNone:
case Transparent:
// ### Center should probably be treated as transparent when it comes to justification.
case Center:
break;
case ArabicSpace:
properties[i].justification = GlyphAttributes::Arabic_Space;
break;
case Kashida:
properties[i].justification = GlyphAttributes::Arabic_Kashida;
break;
case Seen:
lastGroup = Seen;
break;
case Hah:
case Dal:
lastGroup = Hah;
break;
case Alef:
case Tah:
lastGroup = Alef;
break;
case Yeh:
case Reh:
if (properties[lastPos].shape == XMedial && arabicGroup(chars[lastPos]) == Beh)
properties[lastPos-1].justification = GlyphAttributes::Arabic_BaRa;
break;
case Ain:
case Waw:
lastGroup = Ain;
break;
case Noon:
case Beh:
case HamzaOnHehGoal:
lastGroup = Noon;
break;
case ArabicGroupsEnd:
Q_ASSERT(FALSE);
}
lastPos = i;
}
properties[lastPos].shape = joining_table[shape][JNone].form1;
// for (int i = 0; i < len; ++i)
// tqDebug("arabic properties(%d): uc=%x shape=%d, justification=%d", i, chars[i], properties[i].shape, properties[i].justification);
}
// The unicode to unicode shaping codec.
// does only presentation forms B at the moment, but that should be enough for
// simple display
static const ushort arabicUnicodeMapping[256][2] = {
// base of shaped forms, and number-1 of them (0 for non shaping,
// 1 for right binding and 3 for dual binding
// These are just the glyphs available in Unicode,
// some characters are in R class, but have no glyphs in Unicode.
{ 0x0600, 0 }, // 0x0600
{ 0x0601, 0 }, // 0x0601
{ 0x0602, 0 }, // 0x0602
{ 0x0603, 0 }, // 0x0603
{ 0x0604, 0 }, // 0x0604
{ 0x0605, 0 }, // 0x0605
{ 0x0606, 0 }, // 0x0606
{ 0x0607, 0 }, // 0x0607
{ 0x0608, 0 }, // 0x0608
{ 0x0609, 0 }, // 0x0609
{ 0x060A, 0 }, // 0x060A
{ 0x060B, 0 }, // 0x060B
{ 0x060C, 0 }, // 0x060C
{ 0x060D, 0 }, // 0x060D
{ 0x060E, 0 }, // 0x060E
{ 0x060F, 0 }, // 0x060F
{ 0x0610, 0 }, // 0x0610
{ 0x0611, 0 }, // 0x0611
{ 0x0612, 0 }, // 0x0612
{ 0x0613, 0 }, // 0x0613
{ 0x0614, 0 }, // 0x0614
{ 0x0615, 0 }, // 0x0615
{ 0x0616, 0 }, // 0x0616
{ 0x0617, 0 }, // 0x0617
{ 0x0618, 0 }, // 0x0618
{ 0x0619, 0 }, // 0x0619
{ 0x061A, 0 }, // 0x061A
{ 0x061B, 0 }, // 0x061B
{ 0x061C, 0 }, // 0x061C
{ 0x061D, 0 }, // 0x061D
{ 0x061E, 0 }, // 0x061E
{ 0x061F, 0 }, // 0x061F
{ 0x0620, 0 }, // 0x0620
{ 0xFE80, 0 }, // 0x0621 HAMZA
{ 0xFE81, 1 }, // 0x0622 R ALEF WITH MADDA ABOVE
{ 0xFE83, 1 }, // 0x0623 R ALEF WITH HAMZA ABOVE
{ 0xFE85, 1 }, // 0x0624 R WAW WITH HAMZA ABOVE
{ 0xFE87, 1 }, // 0x0625 R ALEF WITH HAMZA BELOW
{ 0xFE89, 3 }, // 0x0626 D YEH WITH HAMZA ABOVE
{ 0xFE8D, 1 }, // 0x0627 R ALEF
{ 0xFE8F, 3 }, // 0x0628 D BEH
{ 0xFE93, 1 }, // 0x0629 R TEH MARBUTA
{ 0xFE95, 3 }, // 0x062A D TEH
{ 0xFE99, 3 }, // 0x062B D THEH
{ 0xFE9D, 3 }, // 0x062C D JEEM
{ 0xFEA1, 3 }, // 0x062D D HAH
{ 0xFEA5, 3 }, // 0x062E D KHAH
{ 0xFEA9, 1 }, // 0x062F R DAL
{ 0xFEAB, 1 }, // 0x0630 R THAL
{ 0xFEAD, 1 }, // 0x0631 R REH
{ 0xFEAF, 1 }, // 0x0632 R ZAIN
{ 0xFEB1, 3 }, // 0x0633 D SEEN
{ 0xFEB5, 3 }, // 0x0634 D SHEEN
{ 0xFEB9, 3 }, // 0x0635 D SAD
{ 0xFEBD, 3 }, // 0x0636 D DAD
{ 0xFEC1, 3 }, // 0x0637 D TAH
{ 0xFEC5, 3 }, // 0x0638 D ZAH
{ 0xFEC9, 3 }, // 0x0639 D AIN
{ 0xFECD, 3 }, // 0x063A D GHAIN
{ 0x063B, 0 }, // 0x063B
{ 0x063C, 0 }, // 0x063C
{ 0x063D, 0 }, // 0x063D
{ 0x063E, 0 }, // 0x063E
{ 0x063F, 0 }, // 0x063F
{ 0x0640, 0 }, // 0x0640 C TATWEEL // ### Join Causing, only one glyph
{ 0xFED1, 3 }, // 0x0641 D FEH
{ 0xFED5, 3 }, // 0x0642 D TQAF
{ 0xFED9, 3 }, // 0x0643 D KAF
{ 0xFEDD, 3 }, // 0x0644 D LAM
{ 0xFEE1, 3 }, // 0x0645 D MEEM
{ 0xFEE5, 3 }, // 0x0646 D NOON
{ 0xFEE9, 3 }, // 0x0647 D HEH
{ 0xFEED, 1 }, // 0x0648 R WAW
{ 0x0649, 3 }, // 0x0649 ALEF MAKSURA // ### Dual, glyphs not consecutive, handle in code.
{ 0xFEF1, 3 }, // 0x064A D YEH
{ 0x064B, 0 }, // 0x064B
{ 0x064C, 0 }, // 0x064C
{ 0x064D, 0 }, // 0x064D
{ 0x064E, 0 }, // 0x064E
{ 0x064F, 0 }, // 0x064F
{ 0x0650, 0 }, // 0x0650
{ 0x0651, 0 }, // 0x0651
{ 0x0652, 0 }, // 0x0652
{ 0x0653, 0 }, // 0x0653
{ 0x0654, 0 }, // 0x0654
{ 0x0655, 0 }, // 0x0655
{ 0x0656, 0 }, // 0x0656
{ 0x0657, 0 }, // 0x0657
{ 0x0658, 0 }, // 0x0658
{ 0x0659, 0 }, // 0x0659
{ 0x065A, 0 }, // 0x065A
{ 0x065B, 0 }, // 0x065B
{ 0x065C, 0 }, // 0x065C
{ 0x065D, 0 }, // 0x065D
{ 0x065E, 0 }, // 0x065E
{ 0x065F, 0 }, // 0x065F
{ 0x0660, 0 }, // 0x0660
{ 0x0661, 0 }, // 0x0661
{ 0x0662, 0 }, // 0x0662
{ 0x0663, 0 }, // 0x0663
{ 0x0664, 0 }, // 0x0664
{ 0x0665, 0 }, // 0x0665
{ 0x0666, 0 }, // 0x0666
{ 0x0667, 0 }, // 0x0667
{ 0x0668, 0 }, // 0x0668
{ 0x0669, 0 }, // 0x0669
{ 0x066A, 0 }, // 0x066A
{ 0x066B, 0 }, // 0x066B
{ 0x066C, 0 }, // 0x066C
{ 0x066D, 0 }, // 0x066D
{ 0x066E, 0 }, // 0x066E
{ 0x066F, 0 }, // 0x066F
{ 0x0670, 0 }, // 0x0670
{ 0xFB50, 1 }, // 0x0671 R ALEF WASLA
{ 0x0672, 0 }, // 0x0672
{ 0x0673, 0 }, // 0x0673
{ 0x0674, 0 }, // 0x0674
{ 0x0675, 0 }, // 0x0675
{ 0x0676, 0 }, // 0x0676
{ 0x0677, 0 }, // 0x0677
{ 0x0678, 0 }, // 0x0678
{ 0xFB66, 3 }, // 0x0679 D TTEH
{ 0xFB5E, 3 }, // 0x067A D TTEHEH
{ 0xFB52, 3 }, // 0x067B D BEEH
{ 0x067C, 0 }, // 0x067C
{ 0x067D, 0 }, // 0x067D
{ 0xFB56, 3 }, // 0x067E D PEH
{ 0xFB62, 3 }, // 0x067F D TEHEH
{ 0xFB5A, 3 }, // 0x0680 D BEHEH
{ 0x0681, 0 }, // 0x0681
{ 0x0682, 0 }, // 0x0682
{ 0xFB76, 3 }, // 0x0683 D NYEH
{ 0xFB72, 3 }, // 0x0684 D DYEH
{ 0x0685, 0 }, // 0x0685
{ 0xFB7A, 3 }, // 0x0686 D TCHEH
{ 0xFB7E, 3 }, // 0x0687 D TCHEHEH
{ 0xFB88, 1 }, // 0x0688 R DDAL
{ 0x0689, 0 }, // 0x0689
{ 0x068A, 0 }, // 0x068A
{ 0x068B, 0 }, // 0x068B
{ 0xFB84, 1 }, // 0x068C R DAHAL
{ 0xFB82, 1 }, // 0x068D R DDAHAL
{ 0xFB86, 1 }, // 0x068E R DUL
{ 0x068F, 0 }, // 0x068F
{ 0x0690, 0 }, // 0x0690
{ 0xFB8C, 1 }, // 0x0691 R RREH
{ 0x0692, 0 }, // 0x0692
{ 0x0693, 0 }, // 0x0693
{ 0x0694, 0 }, // 0x0694
{ 0x0695, 0 }, // 0x0695
{ 0x0696, 0 }, // 0x0696
{ 0x0697, 0 }, // 0x0697
{ 0xFB8A, 1 }, // 0x0698 R JEH
{ 0x0699, 0 }, // 0x0699
{ 0x069A, 0 }, // 0x069A
{ 0x069B, 0 }, // 0x069B
{ 0x069C, 0 }, // 0x069C
{ 0x069D, 0 }, // 0x069D
{ 0x069E, 0 }, // 0x069E
{ 0x069F, 0 }, // 0x069F
{ 0x06A0, 0 }, // 0x06A0
{ 0x06A1, 0 }, // 0x06A1
{ 0x06A2, 0 }, // 0x06A2
{ 0x06A3, 0 }, // 0x06A3
{ 0xFB6A, 3 }, // 0x06A4 D VEH
{ 0x06A5, 0 }, // 0x06A5
{ 0xFB6E, 3 }, // 0x06A6 D PEHEH
{ 0x06A7, 0 }, // 0x06A7
{ 0x06A8, 0 }, // 0x06A8
{ 0xFB8E, 3 }, // 0x06A9 D KEHEH
{ 0x06AA, 0 }, // 0x06AA
{ 0x06AB, 0 }, // 0x06AB
{ 0x06AC, 0 }, // 0x06AC
{ 0xFBD3, 3 }, // 0x06AD D NG
{ 0x06AE, 0 }, // 0x06AE
{ 0xFB92, 3 }, // 0x06AF D GAF
{ 0x06B0, 0 }, // 0x06B0
{ 0xFB9A, 3 }, // 0x06B1 D NGOEH
{ 0x06B2, 0 }, // 0x06B2
{ 0xFB96, 3 }, // 0x06B3 D GUEH
{ 0x06B4, 0 }, // 0x06B4
{ 0x06B5, 0 }, // 0x06B5
{ 0x06B6, 0 }, // 0x06B6
{ 0x06B7, 0 }, // 0x06B7
{ 0x06B8, 0 }, // 0x06B8
{ 0x06B9, 0 }, // 0x06B9
{ 0xFB9E, 1 }, // 0x06BA R NOON GHUNNA
{ 0xFBA0, 3 }, // 0x06BB D RNOON
{ 0x06BC, 0 }, // 0x06BC
{ 0x06BD, 0 }, // 0x06BD
{ 0xFBAA, 3 }, // 0x06BE D HEH DOACHASHMEE
{ 0x06BF, 0 }, // 0x06BF
{ 0xFBA4, 1 }, // 0x06C0 R HEH WITH YEH ABOVE
{ 0xFBA6, 3 }, // 0x06C1 D HEH GOAL
{ 0x06C2, 0 }, // 0x06C2
{ 0x06C3, 0 }, // 0x06C3
{ 0x06C4, 0 }, // 0x06C4
{ 0xFBE0, 1 }, // 0x06C5 R KIRGHIZ OE
{ 0xFBD9, 1 }, // 0x06C6 R OE
{ 0xFBD7, 1 }, // 0x06C7 R U
{ 0xFBDB, 1 }, // 0x06C8 R YU
{ 0xFBE2, 1 }, // 0x06C9 R KIRGHIZ YU
{ 0x06CA, 0 }, // 0x06CA
{ 0xFBDE, 1 }, // 0x06CB R VE
{ 0xFBFC, 3 }, // 0x06CC D FARSI YEH
{ 0x06CD, 0 }, // 0x06CD
{ 0x06CE, 0 }, // 0x06CE
{ 0x06CF, 0 }, // 0x06CF
{ 0xFBE4, 3 }, // 0x06D0 D E
{ 0x06D1, 0 }, // 0x06D1
{ 0xFBAE, 1 }, // 0x06D2 R YEH BARREE
{ 0xFBB0, 1 }, // 0x06D3 R YEH BARREE WITH HAMZA ABOVE
{ 0x06D4, 0 }, // 0x06D4
{ 0x06D5, 0 }, // 0x06D5
{ 0x06D6, 0 }, // 0x06D6
{ 0x06D7, 0 }, // 0x06D7
{ 0x06D8, 0 }, // 0x06D8
{ 0x06D9, 0 }, // 0x06D9
{ 0x06DA, 0 }, // 0x06DA
{ 0x06DB, 0 }, // 0x06DB
{ 0x06DC, 0 }, // 0x06DC
{ 0x06DD, 0 }, // 0x06DD
{ 0x06DE, 0 }, // 0x06DE
{ 0x06DF, 0 }, // 0x06DF
{ 0x06E0, 0 }, // 0x06E0
{ 0x06E1, 0 }, // 0x06E1
{ 0x06E2, 0 }, // 0x06E2
{ 0x06E3, 0 }, // 0x06E3
{ 0x06E4, 0 }, // 0x06E4
{ 0x06E5, 0 }, // 0x06E5
{ 0x06E6, 0 }, // 0x06E6
{ 0x06E7, 0 }, // 0x06E7
{ 0x06E8, 0 }, // 0x06E8
{ 0x06E9, 0 }, // 0x06E9
{ 0x06EA, 0 }, // 0x06EA
{ 0x06EB, 0 }, // 0x06EB
{ 0x06EC, 0 }, // 0x06EC
{ 0x06ED, 0 }, // 0x06ED
{ 0x06EE, 0 }, // 0x06EE
{ 0x06EF, 0 }, // 0x06EF
{ 0x06F0, 0 }, // 0x06F0
{ 0x06F1, 0 }, // 0x06F1
{ 0x06F2, 0 }, // 0x06F2
{ 0x06F3, 0 }, // 0x06F3
{ 0x06F4, 0 }, // 0x06F4
{ 0x06F5, 0 }, // 0x06F5
{ 0x06F6, 0 }, // 0x06F6
{ 0x06F7, 0 }, // 0x06F7
{ 0x06F8, 0 }, // 0x06F8
{ 0x06F9, 0 }, // 0x06F9
{ 0x06FA, 0 }, // 0x06FA
{ 0x06FB, 0 }, // 0x06FB
{ 0x06FC, 0 }, // 0x06FC
{ 0x06FD, 0 }, // 0x06FD
{ 0x06FE, 0 }, // 0x06FE
{ 0x06FF, 0 } // 0x06FF
};
// the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, this table does
static const ushort alefMaksura[4] = {0xFEEF, 0xFEF0, 0xFBE8, 0xFBE9};
// this is a bit tricky. Alef always binds to the right, so the second parameter descibing the shape
// of the lam can be either initial of medial. So initial maps to the isolated form of the ligature,
// medial to the final form
static const ushort arabicUnicodeLamAlefMapping[6][4] = {
{ 0xfffd, 0xfffd, 0xfef5, 0xfef6 }, // 0x622 R Alef with Madda above
{ 0xfffd, 0xfffd, 0xfef7, 0xfef8 }, // 0x623 R Alef with Hamza above
{ 0xfffd, 0xfffd, 0xfffd, 0xfffd }, // 0x624 // Just to fill the table ;-)
{ 0xfffd, 0xfffd, 0xfef9, 0xfefa }, // 0x625 R Alef with Hamza below
{ 0xfffd, 0xfffd, 0xfffd, 0xfffd }, // 0x626 // Just to fill the table ;-)
{ 0xfffd, 0xfffd, 0xfefb, 0xfefc } // 0x627 R Alef
};
static inline int getShape(uchar cell, int shape)
{
// the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, handle this here
uint ch = (cell != 0x49)
? (shape ? arabicUnicodeMapping[cell][0] + shape : 0x600+cell)
: alefMaksura[shape] ;
return ch;
}
/*
Two small helper functions for arabic shaping.
*/
static inline const TQChar prevChar(const TQString *str, int pos)
{
//tqDebug("leftChar: pos=%d", pos);
pos--;
const TQChar *ch = str->unicode() + pos;
while(pos > -1) {
if(::category(*ch) != TQChar::Mark_NonSpacing)
return *ch;
pos--;
ch--;
}
return TQChar::replacement;
}
static inline const TQChar nextChar(const TQString *str, int pos)
{
pos++;
int len = str->length();
const TQChar *ch = str->unicode() + pos;
while(pos < len) {
//tqDebug("rightChar: %d isLetter=%d, joining=%d", pos, ch.isLetter(), ch.joining());
if(::category(*ch) != TQChar::Mark_NonSpacing)
return *ch;
// assume it's a transparent char, this might not be 100% correct
pos++;
ch++;
}
return TQChar::replacement;
}
static void shapedString(const TQString *uc, int from, int len, TQChar *shapeBuffer, int *shapedLength,
bool reverse, GlyphAttributes *attributes, unsigned short *logClusters)
{
Q_ASSERT((int)uc->length() >= from + len);
if(len == 0) {
*shapedLength = 0;
return;
}
TQVarLengthArray<TQArabicProperties> props(len + 2);
TQArabicProperties *properties = props.data();
int f = from;
int l = len;
if (from > 0) {
--f;
++l;
++properties;
}
if (f + l < (int)uc->length()) {
++l;
}
getArabicProperties((const unsigned short *)(uc->unicode()+f), l, props.data());
const TQChar *ch = uc->unicode() + from;
TQChar *data = shapeBuffer;
int clusterStart = 0;
for (int i = 0; i < len; i++) {
uchar r = ch->row();
int gpos = data - shapeBuffer;
if (r != 0x06) {
if (r == 0x20) {
uchar c = ch->cell();
if (c == 0x0c || c == 0x0d)
// remove ZWJ and ZWNJ
goto skip;
}
if (reverse)
*data = mirroredChar(*ch);
else
*data = *ch;
} else {
uchar c = ch->cell();
int pos = i + from;
int shape = properties[i].shape;
// tqDebug("mapping U+%x to shape %d glyph=0x%x", ch->unicode(), shape, getShape(c, shape));
// take care of lam-alef ligatures (lam right of alef)
ushort map;
switch (c) {
case 0x44: { // lam
const TQChar pch = nextChar(uc, pos);
if (pch.row() == 0x06) {
switch (pch.cell()) {
case 0x22:
case 0x23:
case 0x25:
case 0x27:
// tqDebug(" lam of lam-alef ligature");
map = arabicUnicodeLamAlefMapping[pch.cell() - 0x22][shape];
goto next;
default:
break;
}
}
break;
}
case 0x22: // alef with madda
case 0x23: // alef with hamza above
case 0x25: // alef with hamza below
case 0x27: // alef
if (prevChar(uc, pos).unicode() == 0x0644) {
// have a lam alef ligature
//tqDebug(" alef of lam-alef ligature");
goto skip;
}
default:
break;
}
map = getShape(c, shape);
next:
*data = map;
}
// ##### Fixme
//attributes[gpos].zeroWidth = zeroWidth;
if (::category(*ch) == TQChar::Mark_NonSpacing) {
attributes[gpos].mark = TRUE;
// tqDebug("glyph %d (char %d) is mark!", gpos, i);
} else {
attributes[gpos].mark = FALSE;
clusterStart = data - shapeBuffer;
}
attributes[gpos].clusterStart = !attributes[gpos].mark;
attributes[gpos].combiningClass = combiningClass(*ch);
attributes[gpos].justification = properties[i].justification;
// tqDebug("data[%d] = %x (from %x)", gpos, (uint)data->unicode(), ch->unicode());
data++;
skip:
ch++;
logClusters[i] = clusterStart;
}
*shapedLength = data - shapeBuffer;
}
#if defined(TQ_WS_X11) && !defined(TQT_NO_XFTFREETYPE)
enum {
InitProperty = 0x2,
IsolProperty = 0x4,
FinaProperty = 0x8,
MediProperty = 0x10,
RligProperty = 0x20,
CaltProperty = 0x40,
LigaProperty = 0x80,
DligProperty = 0x100,
CswhProperty = 0x200,
MsetProperty = 0x400
};
static const TQOpenType::Features arabic_features[] = {
{ FT_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
{ FT_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty },
{ FT_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty },
{ FT_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty },
{ FT_MAKE_TAG('i', 'n', 'i', 't'), InitProperty },
{ FT_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty },
{ FT_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty },
{ FT_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty },
{ FT_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty },
{ FT_MAKE_TAG('c', 's', 'w', 'h'), CswhProperty },
// mset is used in old Win95 fonts that don't have a 'mark' positioning table.
{ FT_MAKE_TAG('m', 's', 'e', 't'), MsetProperty },
{0, 0}
};
static const TQOpenType::Features syriac_features[] = {
{ FT_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
{ FT_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty },
{ FT_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty },
{ FT_MAKE_TAG('f', 'i', 'n', '2'), FinaProperty },
{ FT_MAKE_TAG('f', 'i', 'n', '3'), FinaProperty },
{ FT_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty },
{ FT_MAKE_TAG('m', 'e', 'd', '2'), MediProperty },
{ FT_MAKE_TAG('i', 'n', 'i', 't'), InitProperty },
{ FT_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty },
{ FT_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty },
{ FT_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty },
{ FT_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty },
{0, 0}
};
static bool arabicSyriacOpenTypeShape(TQOpenType *openType, TQShaperItem *item, bool *ot_ok)
{
*ot_ok = true;
openType->selectScript(item->script, item->script == TQFont::Arabic ? arabic_features : syriac_features);
int nglyphs = item->num_glyphs;
if (item->font->stringToCMap(item->string->unicode()+item->from, item->length, item->glyphs, item->advances,
&item->num_glyphs, item->flags & TQTextEngine::RightToLeft) != TQFontEngine::NoError)
return FALSE;
heuristicSetGlyphAttributes(item);
unsigned short *logClusters = item->log_clusters;
const unsigned short *uc = (const unsigned short *)item->string->unicode() + item->from;
TQVarLengthArray<TQArabicProperties> props(item->length+2);
TQArabicProperties *properties = props.data();
int f = 0;
int l = item->length;
if (item->from > 0) {
--f;
++l;
++properties;
}
if (f + l < (int)item->string->length()) {
++l;
}
getArabicProperties((const unsigned short *)(uc+f), l, props.data());
TQVarLengthArray<uint> apply(item->num_glyphs);
// Hack to remove ZWJ and ZWNJ from rendered output.
int j = 0;
for (int i = 0; i < item->num_glyphs; i++) {
if (uc[i] == 0x200c || uc[i] == 0x200d)
continue;
item->glyphs[j] = item->glyphs[i];
item->attributes[j] = item->attributes[i];
item->advances[j] = item->advances[i];
item->offsets[j] = item->offsets[i];
properties[j] = properties[i];
item->attributes[j].justification = properties[i].justification;
logClusters[i] = logClusters[j];
++j;
}
item->num_glyphs = j;
for (int i = 0; i < item->num_glyphs; i++) {
apply[i] = 0;
if (properties[i].shape == XIsolated)
apply[i] |= MediProperty|FinaProperty|InitProperty;
else if (properties[i].shape == XMedial)
apply[i] |= IsolProperty|FinaProperty|InitProperty;
else if (properties[i].shape == XFinal)
apply[i] |= IsolProperty|MediProperty|InitProperty;
else if (properties[i].shape == XInitial)
apply[i] |= IsolProperty|MediProperty|FinaProperty;
}
if (!openType->shape(item, apply.data())) {
*ot_ok = false;
return false;
}
item->num_glyphs = nglyphs;
return openType->positionAndAdd(item);
}
#endif
// #### stil missing: identify invalid character combinations
static bool arabic_shape(TQShaperItem *item)
{
Q_ASSERT(item->script == TQFont::Arabic);
#if defined(TQ_WS_X11) && !defined(TQT_NO_XFTFREETYPE)
TQOpenType *openType = item->font->openType();
if (openType && openType->supportsScript(TQFont::Arabic)) {
bool ot_ok;
if (arabicSyriacOpenTypeShape(openType, item, &ot_ok))
return true;
if (ot_ok)
return false;
// fall through to the non OT code
}
#endif
TQVarLengthArray<ushort> shapedChars(item->length);
int slen;
shapedString(item->string, item->from, item->length, (TQChar *)shapedChars.data(), &slen,
item->flags & TQTextEngine::RightToLeft,
item->attributes, item->log_clusters);
if (item->font->stringToCMap((TQChar *)shapedChars.data(), slen, item->glyphs, item->advances,
&item->num_glyphs, item->flags & TQTextEngine::RightToLeft) != TQFontEngine::NoError)
return FALSE;
for (int i = 0; i < slen; ++i)
if (item->attributes[i].mark)
item->advances[i] = 0;
qt_heuristicPosition(item);
return TRUE;
}
#if defined(TQ_WS_X11)
# include "qscriptengine_x11.cpp"
#elif defined(TQ_WS_WIN)
# include "qscriptengine_win.cpp"
#elif defined(TQ_WS_MAC)
# include "qscriptengine_mac.cpp"
#elif defined(TQ_WS_QWS)
# include "qscriptengine_qws.cpp"
#endif
View Git Blame Copy Permalink