1151 lines
37 KiB
C
1151 lines
37 KiB
C
/*
|
|
* 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)) {
|
|
HB_FREE_STACKARRAY(shapedChars);
|
|
return TRUE;
|
|
}
|
|
if (ot_ok) {
|
|
HB_FREE_STACKARRAY(shapedChars);
|
|
return FALSE;
|
|
/* fall through to the non OT code*/
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (item->item.script != HB_Script_Arabic) {
|
|
HB_FREE_STACKARRAY(shapedChars);
|
|
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;
|
|
}
|
|
|
|
|