/* | |
* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) | |
* | |
* This is part of HarfBuzz, an OpenType Layout engine library. | |
* | |
* Permission is hereby granted, without written agreement and without | |
* license or royalty fees, to use, copy, modify, and distribute this | |
* software and its documentation for any purpose, provided that the | |
* above copyright notice and the following two paragraphs appear in | |
* all copies of this software. | |
* | |
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR | |
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES | |
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN | |
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH | |
* DAMAGE. | |
* | |
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, | |
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND | |
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS | |
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO | |
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. | |
*/ | |
#include "harfbuzz-shaper.h" | |
#include "harfbuzz-shaper-private.h" | |
#include <assert.h> | |
static const HB_UChar16 ReplacementCharacter = 0xfffd; | |
typedef struct { | |
unsigned char shape; | |
unsigned char justification; | |
} HB_ArabicProperties; | |
typedef enum { | |
XIsolated, | |
XFinal, | |
XInitial, | |
XMedial, | |
/* intermediate state */ | |
XCausing | |
} ArabicShape; | |
/* | |
// these groups correspond to the groups defined in the Unicode standard. | |
// Some of these groups are equal with 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. | |
*/ | |
typedef enum { | |
/* 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 | |
} ArabicGroup; | |
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 ArabicGroup arabicGroup(unsigned short uc) | |
{ | |
if (uc >= 0x0600 && uc < 0x750) | |
return (ArabicGroup) arabic_group[uc-0x600]; | |
else if (uc == 0x200d) | |
return Center; | |
else if (HB_GetUnicodeCharCategory(uc) == HB_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 HB_UChar16::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. | |
*/ | |
typedef enum { | |
JNone, | |
JCausing, | |
JDual, | |
JRight, | |
JTransparent | |
} Joining; | |
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 */ | |
}; | |
typedef struct { | |
ArabicShape form1; | |
ArabicShape form2; | |
} JoiningPair; | |
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. | |
*/ | |
static void getArabicProperties(const unsigned short *chars, int len, HB_ArabicProperties *properties) | |
{ | |
/* qDebug("arabicSyriacOpenTypeShape: properties:"); */ | |
int lastPos = 0; | |
int lastGroup = ArabicNone; | |
int i = 0; | |
ArabicGroup group = arabicGroup(chars[0]); | |
Joining j = joining_for_group[group]; | |
ArabicShape shape = joining_table[XIsolated][j].form2; | |
properties[0].justification = HB_NoJustification; | |
for (i = 1; i < len; ++i) { | |
/* #### fix handling for spaces and punktuation */ | |
properties[i].justification = HB_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 = HB_Arabic_Seen; | |
break; | |
case Hah: | |
if (properties[lastPos].shape == XFinal) | |
properties[lastPos-1].justification = HB_Arabic_HaaDal; | |
break; | |
case Alef: | |
if (properties[lastPos].shape == XFinal) | |
properties[lastPos-1].justification = HB_Arabic_Alef; | |
break; | |
case Ain: | |
if (properties[lastPos].shape == XFinal) | |
properties[lastPos-1].justification = HB_Arabic_Waw; | |
break; | |
case Noon: | |
if (properties[lastPos].shape == XFinal) | |
properties[lastPos-1].justification = HB_Arabic_Normal; | |
break; | |
case ArabicNone: | |
break; | |
default: | |
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 = HB_Arabic_Space; | |
break; | |
case Kashida: | |
properties[i].justification = HB_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 = HB_Arabic_BaRa; | |
break; | |
case Ain: | |
case Waw: | |
lastGroup = Ain; | |
break; | |
case Noon: | |
case Beh: | |
case HamzaOnHehGoal: | |
lastGroup = Noon; | |
break; | |
case ArabicGroupsEnd: | |
assert(FALSE); | |
} | |
lastPos = i; | |
} | |
properties[lastPos].shape = joining_table[shape][JNone].form1; | |
/* | |
for (int i = 0; i < len; ++i) | |
qDebug("arabic properties(%d): uc=%x shape=%d, justification=%d", i, chars[i], properties[i].shape, properties[i].justification); | |
*/ | |
} | |
static Joining getNkoJoining(unsigned short uc) | |
{ | |
if (uc < 0x7ca) | |
return JNone; | |
if (uc <= 0x7ea) | |
return JDual; | |
if (uc <= 0x7f3) | |
return JTransparent; | |
if (uc <= 0x7f9) | |
return JNone; | |
if (uc == 0x7fa) | |
return JCausing; | |
return JNone; | |
} | |
static void getNkoProperties(const unsigned short *chars, int len, HB_ArabicProperties *properties) | |
{ | |
int lastPos = 0; | |
int i = 0; | |
Joining j = getNkoJoining(chars[0]); | |
ArabicShape shape = joining_table[XIsolated][j].form2; | |
properties[0].justification = HB_NoJustification; | |
for (i = 1; i < len; ++i) { | |
properties[i].justification = (HB_GetUnicodeCharCategory(chars[i]) == HB_Separator_Space) ? | |
ArabicSpace : ArabicNone; | |
j = getNkoJoining(chars[i]); | |
if (j == JTransparent) { | |
properties[i].shape = XIsolated; | |
continue; | |
} | |
properties[lastPos].shape = joining_table[shape][j].form1; | |
shape = joining_table[shape][j].form2; | |
lastPos = i; | |
} | |
properties[lastPos].shape = joining_table[shape][JNone].form1; | |
/* | |
for (int i = 0; i < len; ++i) | |
qDebug("nko 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 hb_uint16 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 QAF */ | |
{ 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 hb_uint16 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 hb_uint16 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 int getShape(hb_uint8 cell, int shape) | |
{ | |
/* the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, handle this here */ | |
int ch = (cell != 0x49) | |
? (shape ? arabicUnicodeMapping[cell][0] + shape : 0x600+cell) | |
: alefMaksura[shape] ; | |
return ch; | |
} | |
/* | |
Two small helper functions for arabic shaping. | |
*/ | |
static HB_UChar16 prevChar(const HB_UChar16 *str, int pos) | |
{ | |
/*qDebug("leftChar: pos=%d", pos); */ | |
const HB_UChar16 *ch = str + pos - 1; | |
pos--; | |
while(pos > -1) { | |
if(HB_GetUnicodeCharCategory(*ch) != HB_Mark_NonSpacing) | |
return *ch; | |
pos--; | |
ch--; | |
} | |
return ReplacementCharacter; | |
} | |
static HB_UChar16 nextChar(const HB_UChar16 *str, hb_uint32 len, hb_uint32 pos) | |
{ | |
const HB_UChar16 *ch = str + pos + 1; | |
pos++; | |
while(pos < len) { | |
/*qDebug("rightChar: %d isLetter=%d, joining=%d", pos, ch.isLetter(), ch.joining()); */ | |
if(HB_GetUnicodeCharCategory(*ch) != HB_Mark_NonSpacing) | |
return *ch; | |
/* assume it's a transparent char, this might not be 100% correct */ | |
pos++; | |
ch++; | |
} | |
return ReplacementCharacter; | |
} | |
static void shapedString(const HB_UChar16 *uc, hb_uint32 stringLength, hb_uint32 from, hb_uint32 len, HB_UChar16 *shapeBuffer, int *shapedLength, | |
HB_Bool reverse, HB_GlyphAttributes *attributes, unsigned short *logClusters) | |
{ | |
HB_ArabicProperties *properties; | |
hb_int32 f = from; | |
hb_uint32 l = len; | |
const HB_UChar16 *ch; | |
HB_UChar16 *data; | |
int clusterStart; | |
hb_uint32 i; | |
HB_STACKARRAY(HB_ArabicProperties, props, len + 2); | |
properties = props; | |
assert(stringLength >= from + len); | |
if(len == 0) { | |
*shapedLength = 0; | |
return; | |
} | |
if (from > 0) { | |
--f; | |
++l; | |
++properties; | |
} | |
if (f + l < stringLength) | |
++l; | |
getArabicProperties(uc+f, l, props); | |
ch = uc + from; | |
data = shapeBuffer; | |
clusterStart = 0; | |
for (i = 0; i < len; i++) { | |
hb_uint8 r = *ch >> 8; | |
int gpos = data - shapeBuffer; | |
if (r != 0x06) { | |
if (r == 0x20) { | |
if (*ch == 0x200c || *ch == 0x200d) | |
/* remove ZWJ and ZWNJ */ | |
goto skip; | |
} | |
if (reverse) | |
*data = HB_GetMirroredChar(*ch); | |
else | |
*data = *ch; | |
} else { | |
hb_uint8 c = *ch & 0xff; | |
int pos = i + from; | |
int shape = properties[i].shape; | |
/* qDebug("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) */ | |
hb_uint16 map; | |
switch (c) { | |
case 0x44: { /* lam */ | |
const HB_UChar16 pch = nextChar(uc, stringLength, pos); | |
if ((pch >> 8) == 0x06) { | |
switch (pch & 0xff) { | |
case 0x22: | |
case 0x23: | |
case 0x25: | |
case 0x27: | |
/* qDebug(" lam of lam-alef ligature"); */ | |
map = arabicUnicodeLamAlefMapping[(pch & 0xff) - 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) == 0x0644) { | |
/* have a lam alef ligature */ | |
/*qDebug(" alef of lam-alef ligature"); */ | |
goto skip; | |
} | |
default: | |
break; | |
} | |
map = getShape(c, shape); | |
next: | |
*data = map; | |
} | |
/* ##### Fixme */ | |
/*glyphs[gpos].attributes.zeroWidth = zeroWidth; */ | |
if (HB_GetUnicodeCharCategory(*ch) == HB_Mark_NonSpacing) { | |
attributes[gpos].mark = TRUE; | |
/* qDebug("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 = HB_GetUnicodeCharCombiningClass(*ch); | |
attributes[gpos].justification = properties[i].justification; | |
/* qDebug("data[%d] = %x (from %x)", gpos, (uint)data->unicode(), ch->unicode());*/ | |
data++; | |
skip: | |
ch++; | |
logClusters[i] = clusterStart; | |
} | |
*shapedLength = data - shapeBuffer; | |
HB_FREE_STACKARRAY(props); | |
} | |
#ifndef NO_OPENTYPE | |
static const HB_OpenTypeFeature arabic_features[] = { | |
{ HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty }, | |
{ HB_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty }, | |
{ HB_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty }, | |
{ HB_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty }, | |
{ HB_MAKE_TAG('i', 'n', 'i', 't'), InitProperty }, | |
{ HB_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty }, | |
{ HB_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty }, | |
{ HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty }, | |
{ HB_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty }, | |
{ HB_MAKE_TAG('c', 's', 'w', 'h'), CswhProperty }, | |
/* mset is used in old Win95 fonts that don't have a 'mark' positioning table. */ | |
{ HB_MAKE_TAG('m', 's', 'e', 't'), MsetProperty }, | |
{0, 0} | |
}; | |
static const HB_OpenTypeFeature syriac_features[] = { | |
{ HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty }, | |
{ HB_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty }, | |
{ HB_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty }, | |
{ HB_MAKE_TAG('f', 'i', 'n', '2'), FinaProperty }, | |
{ HB_MAKE_TAG('f', 'i', 'n', '3'), FinaProperty }, | |
{ HB_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty }, | |
{ HB_MAKE_TAG('m', 'e', 'd', '2'), MediProperty }, | |
{ HB_MAKE_TAG('i', 'n', 'i', 't'), InitProperty }, | |
{ HB_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty }, | |
{ HB_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty }, | |
{ HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty }, | |
{ HB_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty }, | |
{0, 0} | |
}; | |
static HB_Bool arabicSyriacOpenTypeShape(HB_ShaperItem *item, HB_Bool *ot_ok) | |
{ | |
const HB_UChar16 *uc; | |
const int nglyphs = item->num_glyphs; | |
hb_int32 f; | |
hb_uint32 l; | |
HB_ArabicProperties *properties; | |
HB_DECLARE_STACKARRAY(HB_ArabicProperties, props) | |
HB_DECLARE_STACKARRAY(hb_uint32, apply) | |
HB_Bool shaped; | |
int i = 0; | |
*ot_ok = TRUE; | |
if (!HB_ConvertStringToGlyphIndices(item)) | |
return FALSE; | |
HB_HeuristicSetGlyphAttributes(item); | |
HB_INIT_STACKARRAY(HB_ArabicProperties, props, item->item.length + 2); | |
HB_INIT_STACKARRAY(hb_uint32, apply, item->num_glyphs); | |
uc = item->string + item->item.pos; | |
properties = props; | |
f = 0; | |
l = item->item.length; | |
if (item->item.pos > 0) { | |
--f; | |
++l; | |
++properties; | |
} | |
if (f + l + item->item.pos < item->stringLength) { | |
++l; | |
} | |
if (item->item.script == HB_Script_Nko) | |
getNkoProperties(uc+f, l, props); | |
else | |
getArabicProperties(uc+f, l, props); | |
for (i = 0; i < (int)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; | |
item->attributes[i].justification = properties[i].justification; | |
} | |
HB_FREE_STACKARRAY(props); | |
shaped = HB_OpenTypeShape(item, apply); | |
HB_FREE_STACKARRAY(apply); | |
if (!shaped) { | |
*ot_ok = FALSE; | |
return FALSE; | |
} | |
return HB_OpenTypePosition(item, nglyphs, /*doLogClusters*/TRUE); | |
} | |
#endif | |
/* #### stil missing: identify invalid character combinations */ | |
HB_Bool HB_ArabicShape(HB_ShaperItem *item) | |
{ | |
int slen; | |
HB_Bool haveGlyphs; | |
HB_STACKARRAY(HB_UChar16, shapedChars, item->item.length); | |
assert(item->item.script == HB_Script_Arabic || item->item.script == HB_Script_Syriac | |
|| item->item.script == HB_Script_Nko); | |
#ifndef NO_OPENTYPE | |
if (HB_SelectScript(item, item->item.script == HB_Script_Arabic ? arabic_features : syriac_features)) { | |
HB_Bool ot_ok; | |
if (arabicSyriacOpenTypeShape(item, &ot_ok)) | |
return TRUE; | |
if (ot_ok) | |
return FALSE; | |
/* fall through to the non OT code*/ | |
} | |
#endif | |
if (item->item.script != HB_Script_Arabic) | |
return HB_BasicShape(item); | |
shapedString(item->string, item->stringLength, item->item.pos, item->item.length, shapedChars, &slen, | |
item->item.bidiLevel % 2, | |
item->attributes, item->log_clusters); | |
haveGlyphs = item->font->klass | |
->convertStringToGlyphIndices(item->font, | |
shapedChars, slen, | |
item->glyphs, &item->num_glyphs, | |
item->item.bidiLevel % 2); | |
HB_FREE_STACKARRAY(shapedChars); | |
if (!haveGlyphs) | |
return FALSE; | |
HB_HeuristicPosition(item); | |
return TRUE; | |
} | |