?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usp10: In Arabic only fallback to presentation form B for isolated glyphs.
[wine.git] / dlls / usp10 / shape.c
blobbd383b99d6e22af2d84f0e93d09efcd31d7d15d6
1 /*
2 * Implementation of Shaping for the Uniscribe Script Processor (usp10.dll)
3 *
4 * Copyright 2010 CodeWeavers, Aric Stewart
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 */
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "wingdi.h"
26 #include "winuser.h"
27 #include "winnls.h"
28 #include "usp10.h"
29 #include "winternl.h"
30
31 #include "usp10_internal.h"
32
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
36
37 #define FIRST_ARABIC_CHAR 0x0600
38 #define LAST_ARABIC_CHAR 0x06ff
39
40 typedef VOID (*ContextualShapingProc)(HDC, ScriptCache*, SCRIPT_ANALYSIS*,
41 WCHAR*, INT, WORD*, INT*, INT, WORD*);
42
43 static void ContextualShape_Arabic(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
44 static void ContextualShape_Syriac(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
45 static void ContextualShape_Phags_pa(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
46 static void ContextualShape_Sinhala(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
47 static void ContextualShape_Devanagari(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
48 static void ContextualShape_Bengali(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
49 static void ContextualShape_Gurmukhi(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
50 static void ContextualShape_Gujarati(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
51 static void ContextualShape_Oriya(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
52 static void ContextualShape_Tamil(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
53 static void ContextualShape_Telugu(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
54 static void ContextualShape_Kannada(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
55 static void ContextualShape_Malayalam(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
56
57 typedef VOID (*ShapeCharGlyphPropProc)( HDC , ScriptCache*, SCRIPT_ANALYSIS*, const WCHAR*, const INT, const WORD*, const INT, WORD*, SCRIPT_CHARPROP*, SCRIPT_GLYPHPROP*);
58
59 static void ShapeCharGlyphProp_Default( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp);
60 static void ShapeCharGlyphProp_Arabic( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
61 static void ShapeCharGlyphProp_Thai( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
62 static void ShapeCharGlyphProp_None( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
63 static void ShapeCharGlyphProp_Tibet( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
64 static void ShapeCharGlyphProp_Sinhala( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
65 static void ShapeCharGlyphProp_Devanagari( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
66 static void ShapeCharGlyphProp_Bengali( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
67 static void ShapeCharGlyphProp_Gurmukhi( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
68 static void ShapeCharGlyphProp_Gujarati( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
69 static void ShapeCharGlyphProp_Oriya( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
70 static void ShapeCharGlyphProp_Tamil( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
71 static void ShapeCharGlyphProp_Telugu( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
72 static void ShapeCharGlyphProp_Kannada( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
73 static void ShapeCharGlyphProp_Malayalam( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
74
75 extern const unsigned short indic_syllabic_table[];
76 extern const unsigned short wine_shaping_table[];
77 extern const unsigned short wine_shaping_forms[LAST_ARABIC_CHAR - FIRST_ARABIC_CHAR + 1][4];
78
79 enum joining_types {
80 jtU,
81 jtT,
82 jtR,
83 jtL,
84 jtD,
85 jtC
86 };
87
88 enum joined_forms {
89 Xn=0,
90 Xr,
91 Xl,
92 Xm,
93 /* Syriac Alaph */
94 Afj,
95 Afn,
96 Afx
97 };
98
99 #ifdef WORDS_BIGENDIAN
100 #define GET_BE_WORD(x) (x)
101 #else
102 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
103 #endif
104
105 /* These are all structures needed for the GSUB table */
106 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
107 #define GSUB_E_NOFEATURE -2
108 #define GSUB_E_NOGLYPH -1
109
110 typedef struct {
111 DWORD version;
112 WORD ScriptList;
113 WORD FeatureList;
114 WORD LookupList;
115 } GSUB_Header;
116
117 typedef struct {
118 CHAR ScriptTag[4];
119 WORD Script;
120 } GSUB_ScriptRecord;
121
122 typedef struct {
123 WORD ScriptCount;
124 GSUB_ScriptRecord ScriptRecord[1];
125 } GSUB_ScriptList;
126
127 typedef struct {
128 CHAR LangSysTag[4];
129 WORD LangSys;
130 } GSUB_LangSysRecord;
131
132 typedef struct {
133 WORD DefaultLangSys;
134 WORD LangSysCount;
135 GSUB_LangSysRecord LangSysRecord[1];
136 } GSUB_Script;
137
138 typedef struct {
139 WORD LookupOrder; /* Reserved */
140 WORD ReqFeatureIndex;
141 WORD FeatureCount;
142 WORD FeatureIndex[1];
143 } GSUB_LangSys;
144
145 typedef struct {
146 CHAR FeatureTag[4];
147 WORD Feature;
148 } GSUB_FeatureRecord;
149
150 typedef struct {
151 WORD FeatureCount;
152 GSUB_FeatureRecord FeatureRecord[1];
153 } GSUB_FeatureList;
154
155 typedef struct {
156 WORD FeatureParams; /* Reserved */
157 WORD LookupCount;
158 WORD LookupListIndex[1];
159 } GSUB_Feature;
160
161 typedef struct {
162 WORD LookupCount;
163 WORD Lookup[1];
164 } GSUB_LookupList;
165
166 typedef struct {
167 WORD LookupType;
168 WORD LookupFlag;
169 WORD SubTableCount;
170 WORD SubTable[1];
171 } GSUB_LookupTable;
172
173 typedef struct {
174 WORD CoverageFormat;
175 WORD GlyphCount;
176 WORD GlyphArray[1];
177 } GSUB_CoverageFormat1;
178
179 typedef struct {
180 WORD Start;
181 WORD End;
182 WORD StartCoverageIndex;
183 } GSUB_RangeRecord;
184
185 typedef struct {
186 WORD CoverageFormat;
187 WORD RangeCount;
188 GSUB_RangeRecord RangeRecord[1];
189 } GSUB_CoverageFormat2;
190
191 typedef struct {
192 WORD SubstFormat; /* = 1 */
193 WORD Coverage;
194 WORD DeltaGlyphID;
195 } GSUB_SingleSubstFormat1;
196
197 typedef struct {
198 WORD SubstFormat; /* = 2 */
199 WORD Coverage;
200 WORD GlyphCount;
201 WORD Substitute[1];
202 }GSUB_SingleSubstFormat2;
203
204 typedef struct {
205 WORD SubstFormat; /* = 1 */
206 WORD Coverage;
207 WORD SequenceCount;
208 WORD Sequence[1];
209 }GSUB_MultipleSubstFormat1;
210
211 typedef struct {
212 WORD GlyphCount;
213 WORD Substitute[1];
214 }GSUB_Sequence;
215
216 typedef struct {
217 WORD SubstFormat; /* = 1 */
218 WORD Coverage;
219 WORD LigSetCount;
220 WORD LigatureSet[1];
221 }GSUB_LigatureSubstFormat1;
222
223 typedef struct {
224 WORD LigatureCount;
225 WORD Ligature[1];
226 }GSUB_LigatureSet;
227
228 typedef struct{
229 WORD LigGlyph;
230 WORD CompCount;
231 WORD Component[1];
232 }GSUB_Ligature;
233
234 typedef struct{
235 WORD SequenceIndex;
236 WORD LookupListIndex;
237
238 }GSUB_SubstLookupRecord;
239
240 typedef struct{
241 WORD SubstFormat; /* = 1 */
242 WORD Coverage;
243 WORD ChainSubRuleSetCount;
244 WORD ChainSubRuleSet[1];
245 }GSUB_ChainContextSubstFormat1;
246
247 typedef struct {
248 WORD SubstFormat; /* = 3 */
249 WORD BacktrackGlyphCount;
250 WORD Coverage[1];
251 }GSUB_ChainContextSubstFormat3_1;
252
253 typedef struct{
254 WORD InputGlyphCount;
255 WORD Coverage[1];
256 }GSUB_ChainContextSubstFormat3_2;
257
258 typedef struct{
259 WORD LookaheadGlyphCount;
260 WORD Coverage[1];
261 }GSUB_ChainContextSubstFormat3_3;
262
263 typedef struct{
264 WORD SubstCount;
265 GSUB_SubstLookupRecord SubstLookupRecord[1];
266 }GSUB_ChainContextSubstFormat3_4;
267
268 typedef struct {
269 WORD SubstFormat; /* = 1 */
270 WORD Coverage;
271 WORD AlternateSetCount;
272 WORD AlternateSet[1];
273 } GSUB_AlternateSubstFormat1;
274
275 typedef struct{
276 WORD GlyphCount;
277 WORD Alternate[1];
278 } GSUB_AlternateSet;
279
280 /* These are all structures needed for the GDEF table */
281 #define GDEF_TAG MS_MAKE_TAG('G', 'D', 'E', 'F')
282
283 enum {BaseGlyph=1, LigatureGlyph, MarkGlyph, ComponentGlyph};
284
285 typedef struct {
286 DWORD Version;
287 WORD GlyphClassDef;
288 WORD AttachList;
289 WORD LigCaretList;
290 WORD MarkAttachClassDef;
291 } GDEF_Header;
292
293 typedef struct {
294 WORD ClassFormat;
295 WORD StartGlyph;
296 WORD GlyphCount;
297 WORD ClassValueArray[1];
298 } GDEF_ClassDefFormat1;
299
300 typedef struct {
301 WORD Start;
302 WORD End;
303 WORD Class;
304 } GDEF_ClassRangeRecord;
305
306 typedef struct {
307 WORD ClassFormat;
308 WORD ClassRangeCount;
309 GDEF_ClassRangeRecord ClassRangeRecord[1];
310 } GDEF_ClassDefFormat2;
311
312 static INT GSUB_apply_lookup(const GSUB_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count);
313
314 typedef struct tagVowelComponents
315 {
316 WCHAR base;
317 WCHAR parts[3];
318 } VowelComponents;
319
320 typedef struct tagConsonantComponents
321 {
322 WCHAR parts[3];
323 WCHAR output;
324 } ConsonantComponents;
325
326 typedef void (*second_reorder_function)(LPWSTR pwChar, IndicSyllable *syllable,WORD* pwGlyphs, IndicSyllable* glyph_index, lexical_function lex);
327
328 /* the orders of joined_forms and contextual_features need to line up */
329 static const char* contextual_features[] =
330 {
331 "isol",
332 "fina",
333 "init",
334 "medi",
335 /* Syriac Alaph */
336 "med2",
337 "fin2",
338 "fin3"
339 };
340
341 static OPENTYPE_FEATURE_RECORD standard_features[] =
342 {
343 { MS_MAKE_TAG('l','i','g','a'), 1},
344 { MS_MAKE_TAG('c','l','i','g'), 1},
345 };
346
347 static OPENTYPE_FEATURE_RECORD arabic_features[] =
348 {
349 { MS_MAKE_TAG('r','l','i','g'), 1},
350 { MS_MAKE_TAG('c','a','l','t'), 1},
351 { MS_MAKE_TAG('l','i','g','a'), 1},
352 { MS_MAKE_TAG('d','l','i','g'), 1},
353 { MS_MAKE_TAG('c','s','w','h'), 1},
354 { MS_MAKE_TAG('m','s','e','t'), 1},
355 };
356
357 static const char* required_arabic_features[] =
358 {
359 "fina",
360 "init",
361 "medi",
362 "rlig",
363 NULL
364 };
365
366 static OPENTYPE_FEATURE_RECORD hebrew_features[] =
367 {
368 { MS_MAKE_TAG('d','l','i','g'), 1},
369 };
370
371 static OPENTYPE_FEATURE_RECORD syriac_features[] =
372 {
373 { MS_MAKE_TAG('r','l','i','g'), 1},
374 { MS_MAKE_TAG('c','a','l','t'), 1},
375 { MS_MAKE_TAG('l','i','g','a'), 1},
376 { MS_MAKE_TAG('d','l','i','g'), 1},
377 };
378
379 static const char* required_syriac_features[] =
380 {
381 "fina",
382 "fin2",
383 "fin3",
384 "init",
385 "medi",
386 "med2",
387 "rlig",
388 NULL
389 };
390
391 static OPENTYPE_FEATURE_RECORD sinhala_features[] =
392 {
393 /* Presentation forms */
394 { MS_MAKE_TAG('b','l','w','s'), 1},
395 { MS_MAKE_TAG('a','b','v','s'), 1},
396 { MS_MAKE_TAG('p','s','t','s'), 1},
397 };
398
399 static OPENTYPE_FEATURE_RECORD tibetan_features[] =
400 {
401 { MS_MAKE_TAG('a','b','v','s'), 1},
402 { MS_MAKE_TAG('b','l','w','s'), 1},
403 };
404
405 static OPENTYPE_FEATURE_RECORD thai_features[] =
406 {
407 { MS_MAKE_TAG('c','c','m','p'), 1},
408 };
409
410 static const char* required_lao_features[] =
411 {
412 "ccmp",
413 NULL
414 };
415
416 static const char* required_devanagari_features[] =
417 {
418 "nukt",
419 "akhn",
420 "rphf",
421 "blwf",
422 "half",
423 "vatu",
424 "pres",
425 "abvs",
426 "blws",
427 "psts",
428 "haln",
429 NULL
430 };
431
432 static OPENTYPE_FEATURE_RECORD devanagari_features[] =
433 {
434 { MS_MAKE_TAG('p','r','e','s'), 1},
435 { MS_MAKE_TAG('a','b','v','s'), 1},
436 { MS_MAKE_TAG('b','l','w','s'), 1},
437 { MS_MAKE_TAG('p','s','t','s'), 1},
438 { MS_MAKE_TAG('h','a','l','n'), 1},
439 { MS_MAKE_TAG('c','a','l','t'), 1},
440 };
441
442 static const char* required_bengali_features[] =
443 {
444 "nukt",
445 "akhn",
446 "rphf",
447 "blwf",
448 "half",
449 "vatu",
450 "pstf",
451 "init",
452 "abvs",
453 "blws",
454 "psts",
455 "haln",
456 NULL
457 };
458
459 static const char* required_gurmukhi_features[] =
460 {
461 "nukt",
462 "akhn",
463 "rphf",
464 "blwf",
465 "half",
466 "pstf",
467 "vatu",
468 "cjct",
469 "pres",
470 "abvs",
471 "blws",
472 "psts",
473 "haln",
474 "calt",
475 NULL
476 };
477
478 static const char* required_oriya_features[] =
479 {
480 "nukt",
481 "akhn",
482 "rphf",
483 "blwf",
484 "pstf",
485 "cjct",
486 "pres",
487 "abvs",
488 "blws",
489 "psts",
490 "haln",
491 "calt",
492 NULL
493 };
494
495 static const char* required_tamil_features[] =
496 {
497 "nukt",
498 "akhn",
499 "rphf",
500 "pref",
501 "half",
502 "pres",
503 "abvs",
504 "blws",
505 "psts",
506 "haln",
507 "calt",
508 NULL
509 };
510
511 static const char* required_telugu_features[] =
512 {
513 "nukt",
514 "akhn",
515 "rphf",
516 "pref",
517 "half",
518 "pstf",
519 "cjct",
520 "pres",
521 "abvs",
522 "blws",
523 "psts",
524 "haln",
525 "calt",
526 NULL
527 };
528
529 typedef struct ScriptShapeDataTag {
530 TEXTRANGE_PROPERTIES defaultTextRange;
531 const char** requiredFeatures;
532 CHAR otTag[5];
533 CHAR newOtTag[5];
534 ContextualShapingProc contextProc;
535 ShapeCharGlyphPropProc charGlyphPropProc;
536 } ScriptShapeData;
537
538 /* in order of scripts */
539 static const ScriptShapeData ShapingData[] =
540 {
541 {{ standard_features, 2}, NULL, "", "", NULL, NULL},
542 {{ standard_features, 2}, NULL, "latn", "", NULL, NULL},
543 {{ standard_features, 2}, NULL, "latn", "", NULL, NULL},
544 {{ standard_features, 2}, NULL, "latn", "", NULL, NULL},
545 {{ standard_features, 2}, NULL, "" , "", NULL, NULL},
546 {{ standard_features, 2}, NULL, "latn", "", NULL, NULL},
547 {{ arabic_features, 6}, required_arabic_features, "arab", "", ContextualShape_Arabic, ShapeCharGlyphProp_Arabic},
548 {{ arabic_features, 6}, required_arabic_features, "arab", "", ContextualShape_Arabic, ShapeCharGlyphProp_Arabic},
549 {{ hebrew_features, 1}, NULL, "hebr", "", NULL, NULL},
550 {{ syriac_features, 4}, required_syriac_features, "syrc", "", ContextualShape_Syriac, ShapeCharGlyphProp_None},
551 {{ arabic_features, 6}, required_arabic_features, "arab", "", ContextualShape_Arabic, ShapeCharGlyphProp_Arabic},
552 {{ NULL, 0}, NULL, "thaa", "", NULL, ShapeCharGlyphProp_None},
553 {{ standard_features, 2}, NULL, "grek", "", NULL, NULL},
554 {{ standard_features, 2}, NULL, "cyrl", "", NULL, NULL},
555 {{ standard_features, 2}, NULL, "armn", "", NULL, NULL},
556 {{ standard_features, 2}, NULL, "geor", "", NULL, NULL},
557 {{ sinhala_features, 3}, NULL, "sinh", "", ContextualShape_Sinhala, ShapeCharGlyphProp_Sinhala},
558 {{ tibetan_features, 2}, NULL, "tibt", "", NULL, ShapeCharGlyphProp_Tibet},
559 {{ tibetan_features, 2}, NULL, "tibt", "", NULL, ShapeCharGlyphProp_Tibet},
560 {{ tibetan_features, 2}, NULL, "phag", "", ContextualShape_Phags_pa, ShapeCharGlyphProp_Thai},
561 {{ thai_features, 1}, NULL, "thai", "", NULL, ShapeCharGlyphProp_Thai},
562 {{ thai_features, 1}, NULL, "thai", "", NULL, ShapeCharGlyphProp_Thai},
563 {{ thai_features, 1}, required_lao_features, "lao", "", NULL, ShapeCharGlyphProp_Thai},
564 {{ thai_features, 1}, required_lao_features, "lao", "", NULL, ShapeCharGlyphProp_Thai},
565 {{ devanagari_features, 6}, required_devanagari_features, "deva", "dev2", ContextualShape_Devanagari, ShapeCharGlyphProp_Devanagari},
566 {{ devanagari_features, 6}, required_devanagari_features, "deva", "dev2", ContextualShape_Devanagari, ShapeCharGlyphProp_Devanagari},
567 {{ devanagari_features, 6}, required_bengali_features, "beng", "bng2", ContextualShape_Bengali, ShapeCharGlyphProp_Bengali},
568 {{ devanagari_features, 6}, required_bengali_features, "beng", "bng2", ContextualShape_Bengali, ShapeCharGlyphProp_Bengali},
569 {{ devanagari_features, 6}, required_bengali_features, "beng", "bng2", ContextualShape_Bengali, ShapeCharGlyphProp_Bengali},
570 {{ devanagari_features, 6}, required_gurmukhi_features, "guru", "gur2", ContextualShape_Gurmukhi, ShapeCharGlyphProp_Gurmukhi},
571 {{ devanagari_features, 6}, required_gurmukhi_features, "guru", "gur2", ContextualShape_Gurmukhi, ShapeCharGlyphProp_Gurmukhi},
572 {{ devanagari_features, 6}, required_devanagari_features, "gujr", "gjr2", ContextualShape_Gujarati, ShapeCharGlyphProp_Gujarati},
573 {{ devanagari_features, 6}, required_devanagari_features, "gujr", "gjr2", ContextualShape_Gujarati, ShapeCharGlyphProp_Gujarati},
574 {{ devanagari_features, 6}, required_devanagari_features, "gujr", "gjr2", ContextualShape_Gujarati, ShapeCharGlyphProp_Gujarati},
575 {{ devanagari_features, 6}, required_oriya_features, "orya", "ory2", ContextualShape_Oriya, ShapeCharGlyphProp_Oriya},
576 {{ devanagari_features, 6}, required_oriya_features, "orya", "ory2", ContextualShape_Oriya, ShapeCharGlyphProp_Oriya},
577 {{ devanagari_features, 6}, required_tamil_features, "taml", "tam2", ContextualShape_Tamil, ShapeCharGlyphProp_Tamil},
578 {{ devanagari_features, 6}, required_tamil_features, "taml", "tam2", ContextualShape_Tamil, ShapeCharGlyphProp_Tamil},
579 {{ devanagari_features, 6}, required_telugu_features, "telu", "tel2", ContextualShape_Telugu, ShapeCharGlyphProp_Telugu},
580 {{ devanagari_features, 6}, required_telugu_features, "telu", "tel2", ContextualShape_Telugu, ShapeCharGlyphProp_Telugu},
581 {{ devanagari_features, 6}, required_telugu_features, "knda", "knd2", ContextualShape_Kannada, ShapeCharGlyphProp_Kannada},
582 {{ devanagari_features, 6}, required_telugu_features, "knda", "knd2", ContextualShape_Kannada, ShapeCharGlyphProp_Kannada},
583 {{ devanagari_features, 6}, required_telugu_features, "mlym", "mlm2", ContextualShape_Malayalam, ShapeCharGlyphProp_Malayalam},
584 {{ devanagari_features, 6}, required_telugu_features, "mlym", "mlm2", ContextualShape_Malayalam, ShapeCharGlyphProp_Malayalam},
585 };
586
587 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
588 {
589 const GSUB_CoverageFormat1* cf1;
590
591 cf1 = table;
592
593 if (GET_BE_WORD(cf1->CoverageFormat) == 1)
594 {
595 int count = GET_BE_WORD(cf1->GlyphCount);
596 int i;
597 TRACE("Coverage Format 1, %i glyphs\n",count);
598 for (i = 0; i < count; i++)
599 if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
600 return i;
601 return -1;
602 }
603 else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
604 {
605 const GSUB_CoverageFormat2* cf2;
606 int i;
607 int count;
608 cf2 = (const GSUB_CoverageFormat2*)cf1;
609
610 count = GET_BE_WORD(cf2->RangeCount);
611 TRACE("Coverage Format 2, %i ranges\n",count);
612 for (i = 0; i < count; i++)
613 {
614 if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
615 return -1;
616 if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
617 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
618 {
619 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
620 glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
621 }
622 }
623 return -1;
624 }
625 else
626 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
627
628 return -1;
629 }
630
631 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
632 {
633 const GSUB_ScriptList *script;
634 const GSUB_Script *deflt = NULL;
635 int i;
636 script = (const GSUB_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
637
638 TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
639 for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
640 {
641 const GSUB_Script *scr;
642 int offset;
643
644 offset = GET_BE_WORD(script->ScriptRecord[i].Script);
645 scr = (const GSUB_Script*)((const BYTE*)script + offset);
646
647 if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
648 return scr;
649 if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
650 deflt = scr;
651 }
652 return deflt;
653 }
654
655 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
656 {
657 int i;
658 int offset;
659 const GSUB_LangSys *Lang;
660
661 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
662
663 for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
664 {
665 offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
666 Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
667
668 if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
669 return Lang;
670 }
671 offset = GET_BE_WORD(script->DefaultLangSys);
672 if (offset)
673 {
674 Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
675 return Lang;
676 }
677 return NULL;
678 }
679
680 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
681 {
682 int i;
683 const GSUB_FeatureList *feature;
684 feature = (const GSUB_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
685
686 TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
687 for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
688 {
689 int index = GET_BE_WORD(lang->FeatureIndex[i]);
690 if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
691 {
692 const GSUB_Feature *feat;
693 feat = (const GSUB_Feature*)((const BYTE*)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
694 return feat;
695 }
696 }
697 return NULL;
698 }
699
700 static INT GSUB_apply_SingleSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
701 {
702 int j;
703 TRACE("Single Substitution Subtable\n");
704
705 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
706 {
707 int offset;
708 const GSUB_SingleSubstFormat1 *ssf1;
709 offset = GET_BE_WORD(look->SubTable[j]);
710 ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
711 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
712 {
713 int offset = GET_BE_WORD(ssf1->Coverage);
714 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
715 if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyphs[glyph_index]) != -1)
716 {
717 TRACE(" Glyph 0x%x ->",glyphs[glyph_index]);
718 glyphs[glyph_index] = glyphs[glyph_index] + GET_BE_WORD(ssf1->DeltaGlyphID);
719 TRACE(" 0x%x\n",glyphs[glyph_index]);
720 return glyph_index + 1;
721 }
722 }
723 else
724 {
725 const GSUB_SingleSubstFormat2 *ssf2;
726 INT index;
727 INT offset;
728
729 ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
730 offset = GET_BE_WORD(ssf1->Coverage);
731 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
732 index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyphs[glyph_index]);
733 TRACE(" Coverage index %i\n",index);
734 if (index != -1)
735 {
736 if (glyphs[glyph_index] == GET_BE_WORD(ssf2->Substitute[index]))
737 return GSUB_E_NOGLYPH;
738
739 TRACE(" Glyph is 0x%x ->",glyphs[glyph_index]);
740 glyphs[glyph_index] = GET_BE_WORD(ssf2->Substitute[index]);
741 TRACE("0x%x\n",glyphs[glyph_index]);
742 return glyph_index + 1;
743 }
744 }
745 }
746 return GSUB_E_NOGLYPH;
747 }
748
749 static INT GSUB_apply_MultipleSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
750 {
751 int j;
752 TRACE("Multiple Substitution Subtable\n");
753
754 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
755 {
756 int offset, index;
757 const GSUB_MultipleSubstFormat1 *msf1;
758 offset = GET_BE_WORD(look->SubTable[j]);
759 msf1 = (const GSUB_MultipleSubstFormat1*)((const BYTE*)look+offset);
760
761 offset = GET_BE_WORD(msf1->Coverage);
762 index = GSUB_is_glyph_covered((const BYTE*)msf1+offset, glyphs[glyph_index]);
763 if (index != -1)
764 {
765 const GSUB_Sequence *seq;
766 int sub_count;
767 int j;
768 offset = GET_BE_WORD(msf1->Sequence[index]);
769 seq = (const GSUB_Sequence*)((const BYTE*)msf1+offset);
770 sub_count = GET_BE_WORD(seq->GlyphCount);
771 TRACE(" Glyph 0x%x (+%i)->",glyphs[glyph_index],(sub_count-1));
772
773 for (j = (*glyph_count)+(sub_count-1); j > glyph_index; j--)
774 glyphs[j] =glyphs[j-(sub_count-1)];
775
776 for (j = 0; j < sub_count; j++)
777 if (write_dir < 0)
778 glyphs[glyph_index + (sub_count-1) - j] = GET_BE_WORD(seq->Substitute[j]);
779 else
780 glyphs[glyph_index + j] = GET_BE_WORD(seq->Substitute[j]);
781
782 *glyph_count = *glyph_count + (sub_count - 1);
783
784 if (TRACE_ON(uniscribe))
785 {
786 for (j = 0; j < sub_count; j++)
787 TRACE(" 0x%x",glyphs[glyph_index+j]);
788 TRACE("\n");
789 }
790
791 return glyph_index + sub_count;
792 }
793 }
794 return GSUB_E_NOGLYPH;
795 }
796
797 static INT GSUB_apply_AlternateSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
798 {
799 int j;
800 TRACE("Alternate Substitution Subtable\n");
801
802 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
803 {
804 int offset;
805 const GSUB_AlternateSubstFormat1 *asf1;
806 INT index;
807
808 offset = GET_BE_WORD(look->SubTable[j]);
809 asf1 = (const GSUB_AlternateSubstFormat1*)((const BYTE*)look+offset);
810 offset = GET_BE_WORD(asf1->Coverage);
811
812 index = GSUB_is_glyph_covered((const BYTE*)asf1+offset, glyphs[glyph_index]);
813 if (index != -1)
814 {
815 const GSUB_AlternateSet *as;
816 offset = GET_BE_WORD(asf1->AlternateSet[index]);
817 as = (const GSUB_AlternateSet*)((const BYTE*)asf1+offset);
818 FIXME("%i alternates, picking index 0\n",GET_BE_WORD(as->GlyphCount));
819 if (glyphs[glyph_index] == GET_BE_WORD(as->Alternate[0]))
820 return GSUB_E_NOGLYPH;
821
822 TRACE(" Glyph 0x%x ->",glyphs[glyph_index]);
823 glyphs[glyph_index] = GET_BE_WORD(as->Alternate[0]);
824 TRACE(" 0x%x\n",glyphs[glyph_index]);
825 return glyph_index + 1;
826 }
827 }
828 return GSUB_E_NOGLYPH;
829 }
830
831 static INT GSUB_apply_LigatureSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
832 {
833 int j;
834
835 TRACE("Ligature Substitution Subtable\n");
836 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
837 {
838 const GSUB_LigatureSubstFormat1 *lsf1;
839 int offset,index;
840
841 offset = GET_BE_WORD(look->SubTable[j]);
842 lsf1 = (const GSUB_LigatureSubstFormat1*)((const BYTE*)look+offset);
843 offset = GET_BE_WORD(lsf1->Coverage);
844 index = GSUB_is_glyph_covered((const BYTE*)lsf1+offset, glyphs[glyph_index]);
845 TRACE(" Coverage index %i\n",index);
846 if (index != -1)
847 {
848 const GSUB_LigatureSet *ls;
849 int k, count;
850
851 offset = GET_BE_WORD(lsf1->LigatureSet[index]);
852 ls = (const GSUB_LigatureSet*)((const BYTE*)lsf1+offset);
853 count = GET_BE_WORD(ls->LigatureCount);
854 TRACE(" LigatureSet has %i members\n",count);
855 for (k = 0; k < count; k++)
856 {
857 const GSUB_Ligature *lig;
858 int CompCount,l,CompIndex;
859
860 offset = GET_BE_WORD(ls->Ligature[k]);
861 lig = (const GSUB_Ligature*)((const BYTE*)ls+offset);
862 CompCount = GET_BE_WORD(lig->CompCount) - 1;
863 CompIndex = glyph_index+write_dir;
864 for (l = 0; l < CompCount && CompIndex >= 0 && CompIndex < *glyph_count; l++)
865 {
866 int CompGlyph;
867 CompGlyph = GET_BE_WORD(lig->Component[l]);
868 if (CompGlyph != glyphs[CompIndex])
869 break;
870 CompIndex += write_dir;
871 }
872 if (l == CompCount)
873 {
874 int replaceIdx = glyph_index;
875 if (write_dir < 0)
876 replaceIdx = glyph_index - CompCount;
877
878 TRACE(" Glyph is 0x%x (+%i) ->",glyphs[glyph_index],CompCount);
879 glyphs[replaceIdx] = GET_BE_WORD(lig->LigGlyph);
880 TRACE("0x%x\n",glyphs[replaceIdx]);
881 if (CompCount > 0)
882 {
883 int j;
884 for (j = replaceIdx + 1; j < *glyph_count; j++)
885 glyphs[j] =glyphs[j+CompCount];
886 *glyph_count = *glyph_count - CompCount;
887 }
888 return replaceIdx + 1;
889 }
890 }
891 }
892 }
893 return GSUB_E_NOGLYPH;
894 }
895
896 static INT GSUB_apply_ChainContextSubst(const GSUB_LookupList* lookup, const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
897 {
898 int j;
899 BOOL done = FALSE;
900
901 TRACE("Chaining Contextual Substitution Subtable\n");
902 for (j = 0; j < GET_BE_WORD(look->SubTableCount) && !done; j++)
903 {
904 const GSUB_ChainContextSubstFormat1 *ccsf1;
905 int offset;
906 int dirLookahead = write_dir;
907 int dirBacktrack = -1 * write_dir;
908
909 offset = GET_BE_WORD(look->SubTable[j]);
910 ccsf1 = (const GSUB_ChainContextSubstFormat1*)((const BYTE*)look+offset);
911 if (GET_BE_WORD(ccsf1->SubstFormat) == 1)
912 {
913 FIXME(" TODO: subtype 1 (Simple context glyph substitution)\n");
914 continue;
915 }
916 else if (GET_BE_WORD(ccsf1->SubstFormat) == 2)
917 {
918 FIXME(" TODO: subtype 2 (Class-based Chaining Context Glyph Substitution)\n");
919 continue;
920 }
921 else if (GET_BE_WORD(ccsf1->SubstFormat) == 3)
922 {
923 int k;
924 int indexGlyphs;
925 const GSUB_ChainContextSubstFormat3_1 *ccsf3_1;
926 const GSUB_ChainContextSubstFormat3_2 *ccsf3_2;
927 const GSUB_ChainContextSubstFormat3_3 *ccsf3_3;
928 const GSUB_ChainContextSubstFormat3_4 *ccsf3_4;
929 int newIndex = glyph_index;
930
931 ccsf3_1 = (const GSUB_ChainContextSubstFormat3_1 *)ccsf1;
932
933 TRACE(" subtype 3 (Coverage-based Chaining Context Glyph Substitution)\n");
934
935 for (k = 0; k < GET_BE_WORD(ccsf3_1->BacktrackGlyphCount); k++)
936 {
937 offset = GET_BE_WORD(ccsf3_1->Coverage[k]);
938 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
939 break;
940 }
941 if (k != GET_BE_WORD(ccsf3_1->BacktrackGlyphCount))
942 continue;
943 TRACE("Matched Backtrack\n");
944
945 ccsf3_2 = (const GSUB_ChainContextSubstFormat3_2 *)(((LPBYTE)ccsf1)+sizeof(GSUB_ChainContextSubstFormat3_1) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_1->BacktrackGlyphCount)-1)));
946
947 indexGlyphs = GET_BE_WORD(ccsf3_2->InputGlyphCount);
948 for (k = 0; k < indexGlyphs; k++)
949 {
950 offset = GET_BE_WORD(ccsf3_2->Coverage[k]);
951 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
952 break;
953 }
954 if (k != indexGlyphs)
955 continue;
956 TRACE("Matched IndexGlyphs\n");
957
958 ccsf3_3 = (const GSUB_ChainContextSubstFormat3_3 *)(((LPBYTE)ccsf3_2)+sizeof(GSUB_ChainContextSubstFormat3_2) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_2->InputGlyphCount)-1)));
959
960 for (k = 0; k < GET_BE_WORD(ccsf3_3->LookaheadGlyphCount); k++)
961 {
962 offset = GET_BE_WORD(ccsf3_3->Coverage[k]);
963 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
964 break;
965 }
966 if (k != GET_BE_WORD(ccsf3_3->LookaheadGlyphCount))
967 continue;
968 TRACE("Matched LookAhead\n");
969
970 ccsf3_4 = (const GSUB_ChainContextSubstFormat3_4 *)(((LPBYTE)ccsf3_3)+sizeof(GSUB_ChainContextSubstFormat3_3) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_3->LookaheadGlyphCount)-1)));
971
972 if (GET_BE_WORD(ccsf3_4->SubstCount))
973 {
974 for (k = 0; k < GET_BE_WORD(ccsf3_4->SubstCount); k++)
975 {
976 int lookupIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].LookupListIndex);
977 int SequenceIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].SequenceIndex) * write_dir;
978
979 TRACE("SUBST: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
980 newIndex = GSUB_apply_lookup(lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count);
981 if (newIndex == -1)
982 {
983 ERR("Chain failed to generate a glyph\n");
984 continue;
985 }
986 }
987 return newIndex;
988 }
989 else return GSUB_E_NOGLYPH;
990 }
991 }
992 return -1;
993 }
994
995 static INT GSUB_apply_lookup(const GSUB_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
996 {
997 int offset;
998 const GSUB_LookupTable *look;
999
1000 offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
1001 look = (const GSUB_LookupTable*)((const BYTE*)lookup + offset);
1002 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
1003 switch(GET_BE_WORD(look->LookupType))
1004 {
1005 case 1:
1006 return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1007 case 2:
1008 return GSUB_apply_MultipleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1009 case 3:
1010 return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1011 case 4:
1012 return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1013 case 6:
1014 return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
1015 default:
1016 FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
1017 }
1018 return GSUB_E_NOGLYPH;
1019 }
1020
1021 static INT GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
1022 {
1023 int i;
1024 int out_index = GSUB_E_NOGLYPH;
1025 const GSUB_LookupList *lookup;
1026
1027 lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1028
1029 TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
1030 for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
1031 {
1032 out_index = GSUB_apply_lookup(lookup, GET_BE_WORD(feature->LookupListIndex[i]), glyphs, glyph_index, write_dir, glyph_count);
1033 if (out_index != GSUB_E_NOGLYPH)
1034 break;
1035 }
1036 if (out_index == GSUB_E_NOGLYPH)
1037 TRACE("lookups found no glyphs\n");
1038 else
1039 {
1040 int out2;
1041 out2 = GSUB_apply_feature(header, feature, glyphs, glyph_index, write_dir, glyph_count);
1042 if (out2!=GSUB_E_NOGLYPH)
1043 out_index = out2;
1044 }
1045 return out_index;
1046 }
1047
1048 static const char* get_opentype_script(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache *psc, BOOL tryNew)
1049 {
1050 UINT charset;
1051
1052 if (psc->userScript != 0)
1053 {
1054 if (tryNew && ShapingData[psa->eScript].newOtTag[0] != 0 && strncmp((char*)&psc->userScript,ShapingData[psa->eScript].otTag,4)==0)
1055 return ShapingData[psa->eScript].newOtTag;
1056 else
1057 return (char*)&psc->userScript;
1058 }
1059
1060 if (tryNew && ShapingData[psa->eScript].newOtTag[0] != 0)
1061 return ShapingData[psa->eScript].newOtTag;
1062
1063 if (ShapingData[psa->eScript].otTag[0] != 0)
1064 return ShapingData[psa->eScript].otTag;
1065
1066 /*
1067 * fall back to the font charset
1068 */
1069 charset = GetTextCharsetInfo(hdc, NULL, 0x0);
1070 switch (charset)
1071 {
1072 case ANSI_CHARSET: return "latn";
1073 case BALTIC_CHARSET: return "latn"; /* ?? */
1074 case CHINESEBIG5_CHARSET: return "hani";
1075 case EASTEUROPE_CHARSET: return "latn"; /* ?? */
1076 case GB2312_CHARSET: return "hani";
1077 case GREEK_CHARSET: return "grek";
1078 case HANGUL_CHARSET: return "hang";
1079 case RUSSIAN_CHARSET: return "cyrl";
1080 case SHIFTJIS_CHARSET: return "kana";
1081 case TURKISH_CHARSET: return "latn"; /* ?? */
1082 case VIETNAMESE_CHARSET: return "latn";
1083 case JOHAB_CHARSET: return "latn"; /* ?? */
1084 case ARABIC_CHARSET: return "arab";
1085 case HEBREW_CHARSET: return "hebr";
1086 case THAI_CHARSET: return "thai";
1087 default: return "latn";
1088 }
1089 }
1090
1091 static LPCVOID load_GSUB_feature(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache *psc, const char* feat)
1092 {
1093 const GSUB_Feature *feature;
1094 int i;
1095
1096 for (i = 0; i < psc->feature_count; i++)
1097 if (strncmp(psc->features[i].tag,feat,4)==0)
1098 return psc->features[i].feature;
1099
1100 feature = NULL;
1101
1102 if (psc->GSUB_Table)
1103 {
1104 const GSUB_Script *script;
1105 const GSUB_LangSys *language;
1106 int attempt = 2;
1107
1108 do
1109 {
1110 script = GSUB_get_script_table(psc->GSUB_Table, get_opentype_script(hdc,psa,psc,(attempt==2)));
1111 attempt--;
1112 if (script)
1113 {
1114 if (psc->userLang != 0)
1115 language = GSUB_get_lang_table(script,(char*)&psc->userLang);
1116 else
1117 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
1118 if (language)
1119 feature = GSUB_get_feature(psc->GSUB_Table, language, feat);
1120 }
1121 } while(attempt && !feature);
1122
1123 /* try in the default (latin) table */
1124 if (!feature)
1125 {
1126 script = GSUB_get_script_table(psc->GSUB_Table, "latn");
1127 if (script)
1128 {
1129 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
1130 if (language)
1131 feature = GSUB_get_feature(psc->GSUB_Table, language, feat);
1132 }
1133 }
1134 }
1135
1136 TRACE("Feature %s located at %p\n",debugstr_an(feat,4),feature);
1137
1138 psc->feature_count++;
1139
1140 if (psc->features)
1141 psc->features = HeapReAlloc(GetProcessHeap(), 0, psc->features, psc->feature_count * sizeof(LoadedFeature));
1142 else
1143 psc->features = HeapAlloc(GetProcessHeap(), 0, psc->feature_count * sizeof(LoadedFeature));
1144
1145 lstrcpynA(psc->features[psc->feature_count - 1].tag, feat, 5);
1146 psc->features[psc->feature_count - 1].feature = feature;
1147 return feature;
1148 }
1149
1150 static INT apply_GSUB_feature_to_glyph(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, WORD *glyphs, INT index, INT write_dir, INT* glyph_count, const char* feat)
1151 {
1152 const GSUB_Feature *feature;
1153
1154 feature = load_GSUB_feature(hdc, psa, psc, feat);
1155 if (!feature)
1156 return GSUB_E_NOFEATURE;
1157
1158 TRACE("applying feature %s\n",feat);
1159 return GSUB_apply_feature(psc->GSUB_Table, feature, glyphs, index, write_dir, glyph_count);
1160 }
1161
1162 static VOID *load_gsub_table(HDC hdc)
1163 {
1164 VOID* GSUB_Table = NULL;
1165 int length = GetFontData(hdc, GSUB_TAG , 0, NULL, 0);
1166 if (length != GDI_ERROR)
1167 {
1168 GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
1169 GetFontData(hdc, GSUB_TAG , 0, GSUB_Table, length);
1170 TRACE("Loaded GSUB table of %i bytes\n",length);
1171 }
1172 return GSUB_Table;
1173 }
1174
1175 INT SHAPE_does_GSUB_feature_apply_to_chars(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, const WCHAR *chars, INT write_dir, INT count, const char* feature)
1176 {
1177 WORD *glyphs;
1178 INT glyph_count = count;
1179 INT rc;
1180
1181 glyphs = HeapAlloc(GetProcessHeap(),0,sizeof(WORD)*(count*2));
1182 GetGlyphIndicesW(hdc, chars, count, glyphs, 0);
1183 rc = apply_GSUB_feature_to_glyph(hdc, psa, psc, glyphs, 0, write_dir, &glyph_count, feature);
1184 if (rc > GSUB_E_NOGLYPH)
1185 rc = count - glyph_count;
1186 else
1187 rc = 0;
1188
1189 HeapFree(GetProcessHeap(),0,glyphs);
1190 return rc;
1191 }
1192
1193 static WORD GDEF_get_glyph_class(const GDEF_Header *header, WORD glyph)
1194 {
1195 int offset;
1196 WORD class = 0;
1197 const GDEF_ClassDefFormat1 *cf1;
1198
1199 if (!header)
1200 return 0;
1201
1202 offset = GET_BE_WORD(header->GlyphClassDef);
1203 if (!offset)
1204 return 0;
1205
1206 cf1 = (GDEF_ClassDefFormat1*)(((BYTE*)header)+offset);
1207 if (GET_BE_WORD(cf1->ClassFormat) == 1)
1208 {
1209 if (glyph >= GET_BE_WORD(cf1->StartGlyph))
1210 {
1211 int index = glyph - GET_BE_WORD(cf1->StartGlyph);
1212 if (index < GET_BE_WORD(cf1->GlyphCount))
1213 class = GET_BE_WORD(cf1->ClassValueArray[index]);
1214 }
1215 }
1216 else if (GET_BE_WORD(cf1->ClassFormat) == 2)
1217 {
1218 const GDEF_ClassDefFormat2 *cf2 = (GDEF_ClassDefFormat2*)cf1;
1219 int i, top;
1220 top = GET_BE_WORD(cf2->ClassRangeCount);
1221 for (i = 0; i < top; i++)
1222 {
1223 if (glyph >= GET_BE_WORD(cf2->ClassRangeRecord[i].Start) &&
1224 glyph <= GET_BE_WORD(cf2->ClassRangeRecord[i].End))
1225 {
1226 class = GET_BE_WORD(cf2->ClassRangeRecord[i].Class);
1227 break;
1228 }
1229 }
1230 }
1231 else
1232 ERR("Unknown Class Format %i\n",GET_BE_WORD(cf1->ClassFormat));
1233
1234 return class;
1235 }
1236
1237 static VOID *load_gdef_table(HDC hdc)
1238 {
1239 VOID* GDEF_Table = NULL;
1240 int length = GetFontData(hdc, GDEF_TAG , 0, NULL, 0);
1241 if (length != GDI_ERROR)
1242 {
1243 GDEF_Table = HeapAlloc(GetProcessHeap(),0,length);
1244 GetFontData(hdc, GDEF_TAG , 0, GDEF_Table, length);
1245 TRACE("Loaded GDEF table of %i bytes\n",length);
1246 }
1247 return GDEF_Table;
1248 }
1249
1250 static void GDEF_UpdateGlyphProps(HDC hdc, ScriptCache *psc, const WORD *pwGlyphs, const WORD cGlyphs, WORD* pwLogClust, SCRIPT_GLYPHPROP *pGlyphProp)
1251 {
1252 int i;
1253
1254 if (!psc->GDEF_Table)
1255 psc->GDEF_Table = load_gdef_table(hdc);
1256
1257 for (i = 0; i < cGlyphs; i++)
1258 {
1259 WORD class;
1260
1261 class = GDEF_get_glyph_class(psc->GDEF_Table, pwGlyphs[i]);
1262
1263 switch (class)
1264 {
1265 case 0:
1266 case BaseGlyph:
1267 pGlyphProp[i].sva.fClusterStart = 1;
1268 pGlyphProp[i].sva.fDiacritic = 0;
1269 pGlyphProp[i].sva.fZeroWidth = 0;
1270 break;
1271 case LigatureGlyph:
1272 pGlyphProp[i].sva.fClusterStart = 1;
1273 pGlyphProp[i].sva.fDiacritic = 0;
1274 pGlyphProp[i].sva.fZeroWidth = 0;
1275 break;
1276 case MarkGlyph:
1277 pGlyphProp[i].sva.fClusterStart = 0;
1278 pGlyphProp[i].sva.fDiacritic = 1;
1279 pGlyphProp[i].sva.fZeroWidth = 1;
1280 break;
1281 case ComponentGlyph:
1282 pGlyphProp[i].sva.fClusterStart = 0;
1283 pGlyphProp[i].sva.fDiacritic = 0;
1284 pGlyphProp[i].sva.fZeroWidth = 0;
1285 break;
1286 default:
1287 ERR("Unknown glyph class %i\n",class);
1288 pGlyphProp[i].sva.fClusterStart = 1;
1289 pGlyphProp[i].sva.fDiacritic = 0;
1290 pGlyphProp[i].sva.fZeroWidth = 0;
1291 }
1292 }
1293 }
1294
1295 static void UpdateClustersFromGlyphProp(const int cGlyphs, const int cChars, WORD* pwLogClust, SCRIPT_GLYPHPROP *pGlyphProp)
1296 {
1297 int i;
1298
1299 for (i = 0; i < cGlyphs; i++)
1300 {
1301 if (!pGlyphProp[i].sva.fClusterStart)
1302 {
1303 int j;
1304 for (j = 0; j < cChars; j++)
1305 {
1306 if (pwLogClust[j] == i)
1307 {
1308 int k = j;
1309 while (!pGlyphProp[pwLogClust[k]].sva.fClusterStart && k >= 0 && k <cChars)
1310 k-=1;
1311 if (pGlyphProp[pwLogClust[k]].sva.fClusterStart)
1312 pwLogClust[j] = pwLogClust[k];
1313 }
1314 }
1315 }
1316 }
1317 }
1318
1319 static void UpdateClusters(int nextIndex, int changeCount, int write_dir, int chars, WORD* pwLogClust )
1320 {
1321 if (changeCount == 0)
1322 return;
1323 else
1324 {
1325 int i;
1326 int target_glyph = nextIndex - 1;
1327 int seeking_glyph;
1328 int target_index = -1;
1329 int replacing_glyph = -1;
1330 int changed = 0;
1331
1332
1333 if (changeCount > 0)
1334 target_glyph = nextIndex - (changeCount+1);
1335
1336 seeking_glyph = target_glyph;
1337
1338 do {
1339 if (write_dir > 0)
1340 for (i = 0; i < chars; i++)
1341 {
1342 if (pwLogClust[i] == seeking_glyph)
1343 {
1344 target_index = i;
1345 break;
1346 }
1347 }
1348 else
1349 for (i = chars - 1; i >= 0; i--)
1350 {
1351 if (pwLogClust[i] == seeking_glyph)
1352 {
1353 target_index = i;
1354 break;
1355 }
1356 }
1357 if (target_index == -1)
1358 seeking_glyph ++;
1359 }
1360 while (target_index == -1 && seeking_glyph < chars);
1361
1362 if (target_index == -1)
1363 {
1364 ERR("Unable to find target glyph\n");
1365 return;
1366 }
1367
1368 if (changeCount < 0)
1369 {
1370 /* merge glyphs */
1371 for(i = target_index; i < chars && i >= 0; i+=write_dir)
1372 {
1373 if (pwLogClust[i] == target_glyph)
1374 continue;
1375 if(pwLogClust[i] == replacing_glyph)
1376 pwLogClust[i] = target_glyph;
1377 else
1378 {
1379 changed--;
1380 if (changed >= changeCount)
1381 {
1382 replacing_glyph = pwLogClust[i];
1383 pwLogClust[i] = target_glyph;
1384 }
1385 else
1386 break;
1387 }
1388 }
1389
1390 /* renumber trailing indexes*/
1391 for(i = target_index; i < chars && i >= 0; i+=write_dir)
1392 {
1393 if (pwLogClust[i] != target_glyph)
1394 pwLogClust[i] += changeCount;
1395 }
1396 }
1397 else
1398 {
1399 for(i = target_index; i < chars && i >= 0; i+=write_dir)
1400 pwLogClust[i] += changeCount;
1401 }
1402 }
1403 }
1404
1405 static int apply_GSUB_feature(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, WORD *pwOutGlyphs, int write_dir, INT* pcGlyphs, INT cChars, const char* feat, WORD *pwLogClust )
1406 {
1407 int i;
1408
1409 if (psc->GSUB_Table)
1410 {
1411 const GSUB_Feature *feature;
1412
1413 feature = load_GSUB_feature(hdc, psa, psc, feat);
1414 if (!feature)
1415 return GSUB_E_NOFEATURE;
1416
1417 i = 0;
1418 TRACE("applying feature %s\n",debugstr_an(feat,4));
1419 while(i < *pcGlyphs)
1420 {
1421 INT nextIndex;
1422 INT prevCount = *pcGlyphs;
1423 nextIndex = GSUB_apply_feature(psc->GSUB_Table, feature, pwOutGlyphs, i, write_dir, pcGlyphs);
1424 if (nextIndex > GSUB_E_NOGLYPH)
1425 {
1426 UpdateClusters(nextIndex, *pcGlyphs - prevCount, write_dir, cChars, pwLogClust);
1427 i = nextIndex;
1428 }
1429 else
1430 i++;
1431 }
1432 return *pcGlyphs;
1433 }
1434 return GSUB_E_NOFEATURE;
1435 }
1436
1437 static inline BOOL get_GSUB_Indic2(SCRIPT_ANALYSIS *psa, ScriptCache *psc)
1438 {
1439 return(GSUB_get_script_table(psc->GSUB_Table,ShapingData[psa->eScript].newOtTag)!=NULL);
1440 }
1441
1442 static WCHAR neighbour_char(int i, int delta, const WCHAR* chars, INT cchLen)
1443 {
1444 if (i + delta < 0)
1445 return 0;
1446 if ( i+ delta >= cchLen)
1447 return 0;
1448
1449 i += delta;
1450
1451 return chars[i];
1452 }
1453
1454 static CHAR neighbour_joining_type(int i, int delta, const CHAR* context_type, INT cchLen, SCRIPT_ANALYSIS *psa)
1455 {
1456 if (i + delta < 0)
1457 {
1458 if (psa->fLinkBefore)
1459 return jtR;
1460 else
1461 return jtU;
1462 }
1463 if ( i+ delta >= cchLen)
1464 {
1465 if (psa->fLinkAfter)
1466 return jtL;
1467 else
1468 return jtU;
1469 }
1470
1471 i += delta;
1472
1473 if (context_type[i] == jtT)
1474 return neighbour_joining_type(i,delta,context_type,cchLen,psa);
1475 else
1476 return context_type[i];
1477 }
1478
1479 static inline BOOL right_join_causing(CHAR joining_type)
1480 {
1481 return (joining_type == jtL || joining_type == jtD || joining_type == jtC);
1482 }
1483
1484 static inline BOOL left_join_causing(CHAR joining_type)
1485 {
1486 return (joining_type == jtR || joining_type == jtD || joining_type == jtC);
1487 }
1488
1489 static inline BOOL word_break_causing(WCHAR chr)
1490 {
1491 /* we are working within a string of characters already guareented to
1492 be within one script, Syriac, so we do not worry about any character
1493 other than the space character outside of that range */
1494 return (chr == 0 || chr == 0x20 );
1495 }
1496
1497 /*
1498 * ContextualShape_Arabic
1499 */
1500 static void ContextualShape_Arabic(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1501 {
1502 CHAR *context_type;
1503 INT *context_shape;
1504 INT dirR, dirL;
1505 int i;
1506
1507 if (*pcGlyphs != cChars)
1508 {
1509 ERR("Number of Glyphs and Chars need to match at the beginning\n");
1510 return;
1511 }
1512
1513 if (!psa->fLogicalOrder && psa->fRTL)
1514 {
1515 dirR = 1;
1516 dirL = -1;
1517 }
1518 else
1519 {
1520 dirR = -1;
1521 dirL = 1;
1522 }
1523
1524 if (!psc->GSUB_Table)
1525 psc->GSUB_Table = load_gsub_table(hdc);
1526
1527 context_type = HeapAlloc(GetProcessHeap(),0,cChars);
1528 context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1529
1530 for (i = 0; i < cChars; i++)
1531 context_type[i] = get_table_entry( wine_shaping_table, pwcChars[i] );
1532
1533 for (i = 0; i < cChars; i++)
1534 {
1535 if (context_type[i] == jtR && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1536 context_shape[i] = Xr;
1537 else if (context_type[i] == jtL && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1538 context_shape[i] = Xl;
1539 else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)) && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1540 context_shape[i] = Xm;
1541 else if (context_type[i] == jtD && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1542 context_shape[i] = Xr;
1543 else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1544 context_shape[i] = Xl;
1545 else
1546 context_shape[i] = Xn;
1547 }
1548
1549 /* Contextual Shaping */
1550 i = 0;
1551 while(i < *pcGlyphs)
1552 {
1553 BOOL shaped = FALSE;
1554
1555 if (psc->GSUB_Table)
1556 {
1557 INT nextIndex;
1558 INT prevCount = *pcGlyphs;
1559 nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1560 if (nextIndex > GSUB_E_NOGLYPH)
1561 {
1562 i = nextIndex;
1563 UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1564 }
1565 shaped = (nextIndex > GSUB_E_NOGLYPH);
1566 }
1567
1568 if (!shaped)
1569 {
1570 if (context_shape[i] == Xn)
1571 {
1572 WORD newGlyph = pwOutGlyphs[i];
1573 if (pwcChars[i] >= FIRST_ARABIC_CHAR && pwcChars[i] <= LAST_ARABIC_CHAR)
1574 {
1575 /* fall back to presentation form B */
1576 WCHAR context_char = wine_shaping_forms[pwcChars[i] - FIRST_ARABIC_CHAR][context_shape[i]];
1577 if (context_char != pwcChars[i] && GetGlyphIndicesW(hdc, &context_char, 1, &newGlyph, 0) != GDI_ERROR && newGlyph != 0x0000)
1578 pwOutGlyphs[i] = newGlyph;
1579 }
1580 }
1581 i++;
1582 }
1583 }
1584
1585 HeapFree(GetProcessHeap(),0,context_shape);
1586 HeapFree(GetProcessHeap(),0,context_type);
1587 }
1588
1589 /*
1590 * ContextualShape_Syriac
1591 */
1592
1593 #define ALAPH 0x710
1594 #define DALATH 0x715
1595 #define RISH 0x72A
1596
1597 static void ContextualShape_Syriac(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1598 {
1599 CHAR *context_type;
1600 INT *context_shape;
1601 INT dirR, dirL;
1602 int i;
1603
1604 if (*pcGlyphs != cChars)
1605 {
1606 ERR("Number of Glyphs and Chars need to match at the beginning\n");
1607 return;
1608 }
1609
1610 if (!psa->fLogicalOrder && psa->fRTL)
1611 {
1612 dirR = 1;
1613 dirL = -1;
1614 }
1615 else
1616 {
1617 dirR = -1;
1618 dirL = 1;
1619 }
1620
1621 if (!psc->GSUB_Table)
1622 psc->GSUB_Table = load_gsub_table(hdc);
1623
1624 if (!psc->GSUB_Table)
1625 return;
1626
1627 context_type = HeapAlloc(GetProcessHeap(),0,cChars);
1628 context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1629
1630 for (i = 0; i < cChars; i++)
1631 context_type[i] = get_table_entry( wine_shaping_table, pwcChars[i] );
1632
1633 for (i = 0; i < cChars; i++)
1634 {
1635 if (pwcChars[i] == ALAPH)
1636 {
1637 WCHAR rchar = neighbour_char(i,dirR,pwcChars,cChars);
1638
1639 if (left_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)) && word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1640 context_shape[i] = Afj;
1641 else if ( rchar != DALATH && rchar != RISH &&
1642 !left_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)) &&
1643 word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1644 context_shape[i] = Afn;
1645 else if ( (rchar == DALATH || rchar == RISH) && word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1646 context_shape[i] = Afx;
1647 else
1648 context_shape[i] = Xn;
1649 }
1650 else if (context_type[i] == jtR &&
1651 right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1652 context_shape[i] = Xr;
1653 else if (context_type[i] == jtL && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1654 context_shape[i] = Xl;
1655 else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)) && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1656 context_shape[i] = Xm;
1657 else if (context_type[i] == jtD && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1658 context_shape[i] = Xr;
1659 else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1660 context_shape[i] = Xl;
1661 else
1662 context_shape[i] = Xn;
1663 }
1664
1665 /* Contextual Shaping */
1666 i = 0;
1667 while(i < *pcGlyphs)
1668 {
1669 INT nextIndex;
1670 INT prevCount = *pcGlyphs;
1671 nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1672 if (nextIndex > GSUB_E_NOGLYPH)
1673 {
1674 UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1675 i = nextIndex;
1676 }
1677 else
1678 i++;
1679 }
1680
1681 HeapFree(GetProcessHeap(),0,context_shape);
1682 HeapFree(GetProcessHeap(),0,context_type);
1683 }
1684
1685 /*
1686 * ContextualShape_Phags_pa
1687 */
1688
1689 #define phags_pa_CANDRABINDU 0xA873
1690 #define phags_pa_START 0xA840
1691 #define phags_pa_END 0xA87F
1692
1693 static void ContextualShape_Phags_pa(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1694 {
1695 INT *context_shape;
1696 INT dirR, dirL;
1697 int i;
1698
1699 if (*pcGlyphs != cChars)
1700 {
1701 ERR("Number of Glyphs and Chars need to match at the beginning\n");
1702 return;
1703 }
1704
1705 if (!psa->fLogicalOrder && psa->fRTL)
1706 {
1707 dirR = 1;
1708 dirL = -1;
1709 }
1710 else
1711 {
1712 dirR = -1;
1713 dirL = 1;
1714 }
1715
1716 if (!psc->GSUB_Table)
1717 psc->GSUB_Table = load_gsub_table(hdc);
1718
1719 if (!psc->GSUB_Table)
1720 return;
1721
1722 context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1723
1724 for (i = 0; i < cChars; i++)
1725 {
1726 if (pwcChars[i] >= phags_pa_START && pwcChars[i] <= phags_pa_END)
1727 {
1728 WCHAR rchar = neighbour_char(i,dirR,pwcChars,cChars);
1729 WCHAR lchar = neighbour_char(i,dirL,pwcChars,cChars);
1730 BOOL jrchar = (rchar != phags_pa_CANDRABINDU && rchar >= phags_pa_START && rchar <= phags_pa_END);
1731 BOOL jlchar = (lchar != phags_pa_CANDRABINDU && lchar >= phags_pa_START && lchar <= phags_pa_END);
1732
1733 if (jrchar && jlchar)
1734 context_shape[i] = Xm;
1735 else if (jrchar)
1736 context_shape[i] = Xr;
1737 else if (jlchar)
1738 context_shape[i] = Xl;
1739 else
1740 context_shape[i] = Xn;
1741 }
1742 else
1743 context_shape[i] = -1;
1744 }
1745
1746 /* Contextual Shaping */
1747 i = 0;
1748 while(i < *pcGlyphs)
1749 {
1750 if (context_shape[i] >= 0)
1751 {
1752 INT nextIndex;
1753 INT prevCount = *pcGlyphs;
1754 nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1755 if (nextIndex > GSUB_E_NOGLYPH)
1756 {
1757 UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1758 i = nextIndex;
1759 }
1760 else
1761 i++;
1762 }
1763 else
1764 i++;
1765 }
1766
1767 HeapFree(GetProcessHeap(),0,context_shape);
1768 }
1769
1770 static void ReplaceInsertChars(HDC hdc, INT cWalk, INT* pcChars, WCHAR *pwOutChars, const WCHAR *replacements)
1771 {
1772 int i;
1773
1774 /* Replace */
1775 pwOutChars[cWalk] = replacements[0];
1776 cWalk=cWalk+1;
1777
1778 /* Insert */
1779 for (i = 1; replacements[i] != 0x0000 && i < 3; i++)
1780 {
1781 int j;
1782 for (j = *pcChars; j > cWalk; j--)
1783 pwOutChars[j] = pwOutChars[j-1];
1784 *pcChars= *pcChars+1;
1785 pwOutChars[cWalk] = replacements[i];
1786 cWalk = cWalk+1;
1787 }
1788 }
1789
1790 static void DecomposeVowels(HDC hdc, WCHAR *pwOutChars, INT *pcChars, const VowelComponents vowels[], WORD* pwLogClust)
1791 {
1792 int i;
1793 int cWalk;
1794 int offset = 0;
1795
1796 for (cWalk = 0; cWalk < *pcChars; cWalk++)
1797 {
1798 for (i = 0; vowels[i].base != 0x0; i++)
1799 {
1800 if (pwOutChars[cWalk] == vowels[i].base)
1801 {
1802 int j;
1803 int o = 1;
1804 ReplaceInsertChars(hdc, cWalk, pcChars, pwOutChars, vowels[i].parts);
1805 if (vowels[i].parts[1]) { cWalk++; o++; }
1806 if (vowels[i].parts[2]) { cWalk++; o++; }
1807 offset += o;
1808 for (j = (cWalk - offset) + 1; j < *pcChars - offset; j ++)
1809 pwLogClust[j]+=o;
1810 break;
1811 }
1812 }
1813 }
1814 }
1815
1816 static void ComposeConsonants(HDC hdc, WCHAR *pwOutChars, INT *pcChars, const ConsonantComponents consonants[], WORD* pwLogClust)
1817 {
1818 int i;
1819 int offset = 0;
1820 int cWalk;
1821
1822 for (cWalk = 0; cWalk < *pcChars; cWalk++)
1823 {
1824 for (i = 0; consonants[i].output!= 0x0; i++)
1825 {
1826 int j;
1827 for (j = 0; j + cWalk < *pcChars && consonants[i].parts[j]!=0x0; j++)
1828 if (pwOutChars[cWalk+j] != consonants[i].parts[j])
1829 break;
1830
1831 if (consonants[i].parts[j]==0x0) /* matched all */
1832 {
1833 int k;
1834 j--;
1835 pwOutChars[cWalk] = consonants[i].output;
1836 for(k = cWalk+1; k < *pcChars - j; k++)
1837 pwOutChars[k] = pwOutChars[k+j];
1838 *pcChars = *pcChars - j;
1839 for (k = j ; k > 0; k--)
1840 pwLogClust[cWalk + k + offset] = pwLogClust[cWalk + offset];
1841 offset += j;
1842 for (k = cWalk + j + offset; k < *pcChars + offset; k++)
1843 pwLogClust[k]--;
1844 break;
1845 }
1846 }
1847 cWalk++;
1848 }
1849 }
1850
1851 static void Reorder_Ra_follows_base(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
1852 {
1853 if (s->ralf >= 0)
1854 {
1855 int j;
1856 WORD Ra = pwChar[s->start];
1857 WORD H = pwChar[s->start+1];
1858
1859 TRACE("Doing reorder of Ra to %i\n",s->base);
1860 for (j = s->start; j < s->base-1; j++)
1861 pwChar[j] = pwChar[j+2];
1862 pwChar[s->base-1] = Ra;
1863 pwChar[s->base] = H;
1864
1865 s->ralf = s->base-1;
1866 s->base -= 2;
1867 }
1868 }
1869
1870 static void Reorder_Ra_follows_matra(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
1871 {
1872 if (s->ralf >= 0)
1873 {
1874 int j,loc;
1875 int stop = (s->blwf >=0)? s->blwf+1 : s->base;
1876 WORD Ra = pwChar[s->start];
1877 WORD H = pwChar[s->start+1];
1878 for (loc = s->end; loc > stop; loc--)
1879 if (lexical(pwChar[loc]) == lex_Matra_post || lexical(pwChar[loc]) == lex_Matra_below)
1880 break;
1881
1882 TRACE("Doing reorder of Ra to %i\n",loc);
1883 for (j = s->start; j < loc-1; j++)
1884 pwChar[j] = pwChar[j+2];
1885 pwChar[loc-1] = Ra;
1886 pwChar[loc] = H;
1887
1888 s->ralf = loc-1;
1889 s->base -= 2;
1890 if (s->blwf >= 0) s->blwf -= 2;
1891 if (s->pref >= 0) s->pref -= 2;
1892 }
1893 }
1894
1895 static void Reorder_Ra_follows_syllable(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
1896 {
1897 if (s->ralf >= 0)
1898 {
1899 int j;
1900 WORD Ra = pwChar[s->start];
1901 WORD H = pwChar[s->start+1];
1902
1903 TRACE("Doing reorder of Ra to %i\n",s->end-1);
1904 for (j = s->start; j < s->end-1; j++)
1905 pwChar[j] = pwChar[j+2];
1906 pwChar[s->end-1] = Ra;
1907 pwChar[s->end] = H;
1908
1909 s->ralf = s->end-1;
1910 s->base -= 2;
1911 if (s->blwf >= 0) s->blwf -= 2;
1912 if (s->pref >= 0) s->pref -= 2;
1913 }
1914 }
1915
1916 static void Reorder_Matra_precede_base(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
1917 {
1918 int i;
1919
1920 /* reorder Matras */
1921 if (s->end > s->base)
1922 {
1923 for (i = 1; i <= s->end-s->base; i++)
1924 {
1925 if (lexical(pwChar[s->base+i]) == lex_Matra_pre)
1926 {
1927 int j;
1928 WCHAR c = pwChar[s->base+i];
1929 TRACE("Doing reorder of %x %x\n",c,pwChar[s->base]);
1930 for (j = s->base+i; j > s->base; j--)
1931 pwChar[j] = pwChar[j-1];
1932 pwChar[s->base] = c;
1933
1934 if (s->ralf >= s->base) s->ralf++;
1935 if (s->blwf >= s->base) s->blwf++;
1936 if (s->pref >= s->base) s->pref++;
1937 s->base ++;
1938 }
1939 }
1940 }
1941 }
1942
1943 static void Reorder_Matra_precede_syllable(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
1944 {
1945 int i;
1946
1947 /* reorder Matras */
1948 if (s->end > s->base)
1949 {
1950 for (i = 1; i <= s->end-s->base; i++)
1951 {
1952 if (lexical(pwChar[s->base+i]) == lex_Matra_pre)
1953 {
1954 int j;
1955 WCHAR c = pwChar[s->base+i];
1956 TRACE("Doing reorder of %x to %i\n",c,s->start);
1957 for (j = s->base+i; j > s->start; j--)
1958 pwChar[j] = pwChar[j-1];
1959 pwChar[s->start] = c;
1960
1961 if (s->ralf >= 0) s->ralf++;
1962 if (s->blwf >= 0) s->blwf++;
1963 if (s->pref >= 0) s->pref++;
1964 s->base ++;
1965 }
1966 }
1967 }
1968 }
1969
1970 static void SecondReorder_Blwf_follows_matra(LPWSTR pwChar, IndicSyllable *s, WORD *glyphs, IndicSyllable *g, lexical_function lexical)
1971 {
1972 if (s->blwf >= 0 && g->blwf > g->base)
1973 {
1974 int j,loc;
1975 int g_offset;
1976 for (loc = s->end; loc > s->blwf; loc--)
1977 if (lexical(pwChar[loc]) == lex_Matra_below || lexical(pwChar[loc]) == lex_Matra_above || lexical(pwChar[loc]) == lex_Matra_post)
1978 break;
1979
1980 g_offset = (loc - s->blwf) - 1;
1981
1982 if (loc != s->blwf)
1983 {
1984 WORD blwf = glyphs[g->blwf];
1985 TRACE("Doing reorder of Below-base to %i (glyph offset %i)\n",loc,g_offset);
1986 /* do not care about the pwChar array anymore, just the glyphs */
1987 for (j = 0; j < g_offset; j++)
1988 glyphs[g->blwf + j] = glyphs[g->blwf + j + 1];
1989 glyphs[g->blwf + g_offset] = blwf;
1990 }
1991 }
1992 }
1993
1994 static void SecondReorder_Matra_precede_base(LPWSTR pwChar, IndicSyllable *s, WORD *glyphs, IndicSyllable *g, lexical_function lexical)
1995 {
1996 int i;
1997
1998 /* reorder previously moved Matras to correct position*/
1999 for (i = s->start; i < s->base; i++)
2000 {
2001 if (lexical(pwChar[i]) == lex_Matra_pre)
2002 {
2003 int j;
2004 int g_start = g->start + i - s->start;
2005 if (g_start < g->base -1 )
2006 {
2007 WCHAR og = glyphs[g_start];
2008 TRACE("Doing reorder of matra from %i to %i\n",g_start,g->base);
2009 for (j = g_start; j < g->base-1; j++)
2010 glyphs[j] = glyphs[j+1];
2011 glyphs[g->base-1] = og;
2012 }
2013 }
2014 }
2015 }
2016
2017 static void SecondReorder_Pref_precede_base(LPWSTR pwChar, IndicSyllable *s, WORD *glyphs, IndicSyllable *g, lexical_function lexical)
2018 {
2019 if (s->pref >= 0 && g->pref > g->base)
2020 {
2021 int j;
2022 WCHAR og = glyphs[g->pref];
2023 TRACE("Doing reorder of pref from %i to %i\n",g->pref,g->base);
2024 for (j = g->pref; j > g->base; j--)
2025 glyphs[j] = glyphs[j-1];
2026 glyphs[g->base] = og;
2027 }
2028 }
2029
2030 static void Reorder_Like_Sinhala(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2031 {
2032 TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2033 if (s->start == s->base && s->base == s->end) return;
2034 if (lexical(pwChar[s->base]) == lex_Vowel) return;
2035
2036 Reorder_Ra_follows_base(pwChar, s, lexical);
2037 Reorder_Matra_precede_base(pwChar, s, lexical);
2038 }
2039
2040 static void Reorder_Like_Devanagari(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2041 {
2042 TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2043 if (s->start == s->base && s->base == s->end) return;
2044 if (lexical(pwChar[s->base]) == lex_Vowel) return;
2045
2046 Reorder_Ra_follows_matra(pwChar, s, lexical);
2047 Reorder_Matra_precede_syllable(pwChar, s, lexical);
2048 }
2049
2050 static void Reorder_Like_Bengali(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2051 {
2052 TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2053 if (s->start == s->base && s->base == s->end) return;
2054 if (lexical(pwChar[s->base]) == lex_Vowel) return;
2055
2056 Reorder_Ra_follows_base(pwChar, s, lexical);
2057 Reorder_Matra_precede_syllable(pwChar, s, lexical);
2058 }
2059
2060 static void Reorder_Like_Kannada(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2061 {
2062 TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2063 if (s->start == s->base && s->base == s->end) return;
2064 if (lexical(pwChar[s->base]) == lex_Vowel) return;
2065
2066 Reorder_Ra_follows_syllable(pwChar, s, lexical);
2067 Reorder_Matra_precede_syllable(pwChar, s, lexical);
2068 }
2069
2070 static void SecondReorder_Like_Telugu(LPWSTR pwChar, IndicSyllable *s, WORD* pwGlyphs, IndicSyllable *g, lexical_function lexical)
2071 {
2072 TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2073 TRACE("Glyphs (%i..%i..%i)\n",g->start,g->base,g->end);
2074 if (s->start == s->base && s->base == s->end) return;
2075 if (lexical(pwChar[s->base]) == lex_Vowel) return;
2076
2077 SecondReorder_Blwf_follows_matra(pwChar, s, pwGlyphs, g, lexical);
2078 }
2079
2080 static void SecondReorder_Like_Tamil(LPWSTR pwChar, IndicSyllable *s, WORD* pwGlyphs, IndicSyllable *g, lexical_function lexical)
2081 {
2082 TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2083 TRACE("Glyphs (%i..%i..%i)\n",g->start,g->base,g->end);
2084 if (s->start == s->base && s->base == s->end) return;
2085 if (lexical(pwChar[s->base]) == lex_Vowel) return;
2086
2087 SecondReorder_Matra_precede_base(pwChar, s, pwGlyphs, g, lexical);
2088 SecondReorder_Pref_precede_base(pwChar, s, pwGlyphs, g, lexical);
2089 }
2090
2091
2092 static inline void shift_syllable_glyph_indexs(IndicSyllable *glyph_index, INT index, INT shift)
2093 {
2094 if (shift == 0)
2095 return;
2096
2097 if (glyph_index->start > index)
2098 glyph_index->start += shift;
2099 if (glyph_index->base > index)
2100 glyph_index->base+= shift;
2101 if (glyph_index->end > index)
2102 glyph_index->end+= shift;
2103 if (glyph_index->ralf > index)
2104 glyph_index->ralf+= shift;
2105 if (glyph_index->blwf > index)
2106 glyph_index->blwf+= shift;
2107 if (glyph_index->pref > index)
2108 glyph_index->pref+= shift;
2109 }
2110
2111 static void Apply_Indic_BasicForm(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index, const GSUB_Feature *feature )
2112 {
2113 int index = glyph_index->start;
2114
2115 if (!feature)
2116 return;
2117
2118 while(index <= glyph_index->end)
2119 {
2120 INT nextIndex;
2121 INT prevCount = *pcGlyphs;
2122 nextIndex = GSUB_apply_feature(psc->GSUB_Table, feature, pwOutGlyphs, index, 1, pcGlyphs);
2123 if (nextIndex > GSUB_E_NOGLYPH)
2124 {
2125 UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2126 shift_syllable_glyph_indexs(glyph_index,index,*pcGlyphs - prevCount);
2127 index = nextIndex;
2128 }
2129 else
2130 index++;
2131 }
2132 }
2133
2134 static inline INT find_consonant_halant(WCHAR* pwChars, INT index, INT end, lexical_function lexical)
2135 {
2136 int i = 0;
2137 while (i + index < end - 1 && !(is_consonant(lexical(pwChars[index+i])) && (lexical(pwChars[index+i+1]) == lex_Halant || (index + i < end - 2 && lexical(pwChars[index+i+1]) == lex_Nukta && lexical(pwChars[index+i+2] == lex_Halant)))))
2138 i++;
2139 if (index + i <= end-1)
2140 return index + i;
2141 else
2142 return -1;
2143 }
2144
2145 static void Apply_Indic_PreBase(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index, const char* feature)
2146 {
2147 INT index, nextIndex;
2148 INT count,g_offset;
2149
2150 count = syllable->base - syllable->start;
2151
2152 g_offset = 0;
2153 index = find_consonant_halant(&pwChars[syllable->start], 0, count, lexical);
2154 while (index >= 0 && index + g_offset < (glyph_index->base - glyph_index->start))
2155 {
2156 INT prevCount = *pcGlyphs;
2157 nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, index+glyph_index->start+g_offset, 1, pcGlyphs, feature);
2158 if (nextIndex > GSUB_E_NOGLYPH)
2159 {
2160 UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2161 shift_syllable_glyph_indexs(glyph_index, index + glyph_index->start + g_offset, (*pcGlyphs - prevCount));
2162 g_offset += (*pcGlyphs - prevCount);
2163 }
2164
2165 index+=2;
2166 index = find_consonant_halant(&pwChars[syllable->start], index, count, lexical);
2167 }
2168 }
2169
2170 static void Apply_Indic_Rphf(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index)
2171 {
2172 INT nextIndex;
2173 INT prevCount = *pcGlyphs;
2174
2175 if (syllable->ralf >= 0)
2176 {
2177 nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, glyph_index->ralf, 1, pcGlyphs, "rphf");
2178 if (nextIndex > GSUB_E_NOGLYPH)
2179 {
2180 UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2181 shift_syllable_glyph_indexs(glyph_index,glyph_index->ralf,*pcGlyphs - prevCount);
2182 }
2183 }
2184 }
2185
2186 static inline INT find_halant_consonant(WCHAR* pwChars, INT index, INT end, lexical_function lexical)
2187 {
2188 int i = 0;
2189 while (index + i < end-1 && !(lexical(pwChars[index+i]) == lex_Halant &&
2190 ((index + i < end-2 && lexical(pwChars[index+i]) == lex_Nukta && is_consonant(lexical(pwChars[index+i+1]))) ||
2191 is_consonant(lexical(pwChars[index+i+1])))))
2192 i++;
2193 if (index + i <= end-1)
2194 return index+i;
2195 else
2196 return -1;
2197 }
2198
2199 static void Apply_Indic_PostBase(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index, BOOL modern, const char* feat)
2200 {
2201 INT index, nextIndex;
2202 INT count, g_offset=0;
2203 INT ralf = syllable->ralf;
2204
2205 count = syllable->end - syllable->base;
2206
2207 index = find_halant_consonant(&pwChars[syllable->base], 0, count, lexical);
2208
2209 while (index >= 0)
2210 {
2211 INT prevCount = *pcGlyphs;
2212 if (ralf >=0 && ralf < index)
2213 {
2214 g_offset--;
2215 ralf = -1;
2216 }
2217
2218 if (!modern)
2219 {
2220 WORD g = pwOutGlyphs[index+glyph_index->base+g_offset];
2221 pwOutGlyphs[index+glyph_index->base+g_offset] = pwOutGlyphs[index+glyph_index->base+g_offset+1];
2222 pwOutGlyphs[index+glyph_index->base+g_offset+1] = g;
2223 }
2224
2225 nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, index+glyph_index->base+g_offset, 1, pcGlyphs, feat);
2226 if (nextIndex > GSUB_E_NOGLYPH)
2227 {
2228 UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2229 shift_syllable_glyph_indexs(glyph_index,index+glyph_index->start+g_offset, (*pcGlyphs - prevCount));
2230 g_offset += (*pcGlyphs - prevCount);
2231 }
2232 else if (!modern)
2233 {
2234 WORD g = pwOutGlyphs[index+glyph_index->base+g_offset];
2235 pwOutGlyphs[index+glyph_index->base+g_offset] = pwOutGlyphs[index+glyph_index->base+g_offset+1];
2236 pwOutGlyphs[index+glyph_index->base+g_offset+1] = g;
2237 }
2238
2239 index+=2;
2240 index = find_halant_consonant(&pwChars[syllable->base], index, count, lexical);
2241 }
2242 }
2243
2244 static void ShapeIndicSyllables(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllables, INT syllable_count, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, second_reorder_function second_reorder, BOOL modern)
2245 {
2246 int c;
2247 int overall_shift = 0;
2248 const GSUB_Feature *locl = (modern)?load_GSUB_feature(hdc, psa, psc, "locl"):NULL;
2249 const GSUB_Feature *nukt = load_GSUB_feature(hdc, psa, psc, "nukt");
2250 const GSUB_Feature *akhn = load_GSUB_feature(hdc, psa, psc, "akhn");
2251 const GSUB_Feature *rkrf = (modern)?load_GSUB_feature(hdc, psa, psc, "rkrf"):NULL;
2252 const GSUB_Feature *pstf = load_GSUB_feature(hdc, psa, psc, "pstf");
2253 const GSUB_Feature *vatu = (!rkrf)?load_GSUB_feature(hdc, psa, psc, "vatu"):NULL;
2254 const GSUB_Feature *cjct = (modern)?load_GSUB_feature(hdc, psa, psc, "cjct"):NULL;
2255 BOOL rphf = (load_GSUB_feature(hdc, psa, psc, "rphf") != NULL);
2256 BOOL pref = (load_GSUB_feature(hdc, psa, psc, "pref") != NULL);
2257 BOOL blwf = (load_GSUB_feature(hdc, psa, psc, "blwf") != NULL);
2258 BOOL half = (load_GSUB_feature(hdc, psa, psc, "half") != NULL);
2259 IndicSyllable glyph_indexs;
2260
2261 for (c = 0; c < syllable_count; c++)
2262 {
2263 int old_end;
2264 memcpy(&glyph_indexs, &syllables[c], sizeof(IndicSyllable));
2265 shift_syllable_glyph_indexs(&glyph_indexs, -1, overall_shift);
2266 old_end = glyph_indexs.end;
2267
2268 if (locl)
2269 {
2270 TRACE("applying feature locl\n");
2271 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, locl);
2272 }
2273 if (nukt)
2274 {
2275 TRACE("applying feature nukt\n");
2276 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, nukt);
2277 }
2278 if (akhn)
2279 {
2280 TRACE("applying feature akhn\n");
2281 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, akhn);
2282 }
2283
2284 if (rphf)
2285 Apply_Indic_Rphf(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs);
2286 if (rkrf)
2287 {
2288 TRACE("applying feature rkrf\n");
2289 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, rkrf);
2290 }
2291 if (pref)
2292 Apply_Indic_PostBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, modern, "pref");
2293 if (blwf)
2294 {
2295 if (!modern)
2296 Apply_Indic_PreBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, "blwf");
2297
2298 Apply_Indic_PostBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, modern, "blwf");
2299
2300 }
2301 if (half)
2302 Apply_Indic_PreBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, "half");
2303 if (pstf)
2304 {
2305 TRACE("applying feature pstf\n");
2306 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, pstf);
2307 }
2308 if (vatu)
2309 {
2310 TRACE("applying feature vatu\n");
2311 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, vatu);
2312 }
2313 if (cjct)
2314 {
2315 TRACE("applying feature cjct\n");
2316 Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, cjct);
2317 }
2318
2319 if (second_reorder)
2320 second_reorder(pwChars, &syllables[c], pwOutGlyphs, &glyph_indexs, lexical);
2321
2322 overall_shift += glyph_indexs.end - old_end;
2323 }
2324 }
2325
2326 static inline int unicode_lex(WCHAR c)
2327 {
2328 int type;
2329
2330 if (!c) return lex_Generic;
2331 if (c == 0x200D) return lex_ZWJ;
2332 if (c == 0x200C) return lex_ZWNJ;
2333 if (c == 0x00A0) return lex_NBSP;
2334
2335 type = get_table_entry( indic_syllabic_table, c );
2336
2337 if ((type & 0x00ff) != 0x0007) type = type & 0x00ff;
2338
2339 switch( type )
2340 {
2341 case 0x0d07: /* Unknown */
2342 case 0x0e07: /* Unknwon */
2343 default: return lex_Generic;
2344 case 0x0001:
2345 case 0x0002:
2346 case 0x0011:
2347 case 0x0012:
2348 case 0x0013:
2349 case 0x0014: return lex_Modifier;
2350 case 0x0003:
2351 case 0x0009:
2352 case 0x000a:
2353 case 0x000b:
2354 case 0x000d:
2355 case 0x000e:
2356 case 0x000f:
2357 case 0x0010: return lex_Consonant;
2358 case 0x0004: return lex_Nukta;
2359 case 0x0005: return lex_Halant;
2360 case 0x0006:
2361 case 0x0008: return lex_Vowel;
2362 case 0x0007:
2363 case 0x0107: return lex_Matra_post;
2364 case 0x0207:
2365 case 0x0307: return lex_Matra_pre;
2366 case 0x0807:
2367 case 0x0907:
2368 case 0x0a07:
2369 case 0x0b07:
2370 case 0x0c07:
2371 case 0x0407: return lex_Composed_Vowel;
2372 case 0x0507: return lex_Matra_above;
2373 case 0x0607: return lex_Matra_below;
2374 case 0x000c: return lex_Ra;
2375 };
2376 }
2377
2378 static int sinhala_lex(WCHAR c)
2379 {
2380 switch (c)
2381 {
2382 case 0x0DDA:
2383 case 0x0DDD:
2384 case 0x0DDC:
2385 case 0x0DDE: return lex_Matra_post;
2386 default:
2387 return unicode_lex(c);
2388 }
2389 }
2390
2391 static const VowelComponents Sinhala_vowels[] = {
2392 {0x0DDA, {0x0DD9,0x0DDA,0x0}},
2393 {0x0DDC, {0x0DD9,0x0DDC,0x0}},
2394 {0x0DDD, {0x0DD9,0x0DDD,0x0}},
2395 {0x0DDE, {0x0DD9,0x0DDE,0x0}},
2396 {0x0000, {0x0000,0x0000,0x0}}};
2397
2398 static void ContextualShape_Sinhala(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2399 {
2400 int cCount = cChars;
2401 int i;
2402 WCHAR *input;
2403 IndicSyllable *syllables = NULL;
2404 int syllable_count = 0;
2405
2406 if (*pcGlyphs != cChars)
2407 {
2408 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2409 return;
2410 }
2411
2412 input = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR) * (cChars * 3));
2413
2414 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2415
2416 /* Step 1: Decompose multi part vowels */
2417 DecomposeVowels(hdc, input, &cCount, Sinhala_vowels, pwLogClust);
2418
2419 TRACE("New double vowel expanded string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2420
2421 /* Step 2: Reorder within Syllables */
2422 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, sinhala_lex, Reorder_Like_Sinhala, TRUE);
2423 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2424
2425 /* Step 3: Strip dangling joiners */
2426 for (i = 0; i < cCount; i++)
2427 {
2428 if ((input[i] == 0x200D || input[i] == 0x200C) &&
2429 (i == 0 || input[i-1] == 0x0020 || i == cCount-1 || input[i+1] == 0x0020))
2430 input[i] = 0x0020;
2431 }
2432
2433 /* Step 4: Base Form application to syllables */
2434 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2435 *pcGlyphs = cCount;
2436 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, sinhala_lex, NULL, TRUE);
2437
2438 HeapFree(GetProcessHeap(),0,input);
2439 HeapFree(GetProcessHeap(),0,syllables);
2440 }
2441
2442 static int devanagari_lex(WCHAR c)
2443 {
2444 switch (c)
2445 {
2446 case 0x0930: return lex_Ra;
2447 default:
2448 return unicode_lex(c);
2449 }
2450 }
2451
2452 static const ConsonantComponents Devanagari_consonants[] ={
2453 {{0x0928, 0x093C, 0x00000}, 0x0929},
2454 {{0x0930, 0x093C, 0x00000}, 0x0931},
2455 {{0x0933, 0x093C, 0x00000}, 0x0934},
2456 {{0x0915, 0x093C, 0x00000}, 0x0958},
2457 {{0x0916, 0x093C, 0x00000}, 0x0959},
2458 {{0x0917, 0x093C, 0x00000}, 0x095A},
2459 {{0x091C, 0x093C, 0x00000}, 0x095B},
2460 {{0x0921, 0x093C, 0x00000}, 0x095C},
2461 {{0x0922, 0x093C, 0x00000}, 0x095D},
2462 {{0x092B, 0x093C, 0x00000}, 0x095E},
2463 {{0x092F, 0x093C, 0x00000}, 0x095F}};
2464
2465 static void ContextualShape_Devanagari(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2466 {
2467 int cCount = cChars;
2468 WCHAR *input;
2469 IndicSyllable *syllables = NULL;
2470 int syllable_count = 0;
2471 BOOL modern = get_GSUB_Indic2(psa, psc);
2472
2473 if (*pcGlyphs != cChars)
2474 {
2475 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2476 return;
2477 }
2478
2479 input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
2480 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2481
2482 /* Step 1: Compose Consonant and Nukta */
2483 ComposeConsonants(hdc, input, &cCount, Devanagari_consonants, pwLogClust);
2484 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2485
2486 /* Step 2: Reorder within Syllables */
2487 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, devanagari_lex, Reorder_Like_Devanagari, modern);
2488 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2489 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2490 *pcGlyphs = cCount;
2491
2492 /* Step 3: Base Form application to syllables */
2493 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, devanagari_lex, NULL, modern);
2494
2495 HeapFree(GetProcessHeap(),0,input);
2496 HeapFree(GetProcessHeap(),0,syllables);
2497 }
2498
2499 static int bengali_lex(WCHAR c)
2500 {
2501 switch (c)
2502 {
2503 case 0x09B0: return lex_Ra;
2504 default:
2505 return unicode_lex(c);
2506 }
2507 }
2508
2509 static const VowelComponents Bengali_vowels[] = {
2510 {0x09CB, {0x09C7,0x09BE,0x0000}},
2511 {0x09CC, {0x09C7,0x09D7,0x0000}},
2512 {0x0000, {0x0000,0x0000,0x0000}}};
2513
2514 static const ConsonantComponents Bengali_consonants[] = {
2515 {{0x09A4,0x09CD,0x200D}, 0x09CE},
2516 {{0x09A1,0x09BC,0x0000}, 0x09DC},
2517 {{0x09A2,0x09BC,0x0000}, 0x09DD},
2518 {{0x09AF,0x09BC,0x0000}, 0x09DF},
2519 {{0x0000,0x0000,0x0000}, 0x0000}};
2520
2521 static void ContextualShape_Bengali(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2522 {
2523 int cCount = cChars;
2524 WCHAR *input;
2525 IndicSyllable *syllables = NULL;
2526 int syllable_count = 0;
2527 BOOL modern = get_GSUB_Indic2(psa, psc);
2528
2529 if (*pcGlyphs != cChars)
2530 {
2531 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2532 return;
2533 }
2534
2535 input = HeapAlloc(GetProcessHeap(), 0, (cChars * 2) * sizeof(WCHAR));
2536 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2537
2538 /* Step 1: Decompose Vowels and Compose Consonents */
2539 DecomposeVowels(hdc, input, &cCount, Bengali_vowels, pwLogClust);
2540 ComposeConsonants(hdc, input, &cCount, Bengali_consonants, pwLogClust);
2541 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2542
2543 /* Step 2: Reorder within Syllables */
2544 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, bengali_lex, Reorder_Like_Bengali, modern);
2545 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2546 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2547 *pcGlyphs = cCount;
2548
2549 /* Step 3: Initial form is only applied to the beginning of words */
2550 for (cCount = cCount - 1 ; cCount >= 0; cCount --)
2551 {
2552 if (cCount == 0 || input[cCount] == 0x0020) /* space */
2553 {
2554 int index = cCount;
2555 int gCount = 1;
2556 if (index > 0) index++;
2557
2558 apply_GSUB_feature_to_glyph(hdc, psa, psc, &pwOutGlyphs[index], 0, 1, &gCount, "init");
2559 }
2560 }
2561
2562 /* Step 4: Base Form application to syllables */
2563 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, bengali_lex, NULL, modern);
2564
2565 HeapFree(GetProcessHeap(),0,input);
2566 HeapFree(GetProcessHeap(),0,syllables);
2567 }
2568
2569 static int gurmukhi_lex(WCHAR c)
2570 {
2571 return unicode_lex(c);
2572 }
2573
2574 static const ConsonantComponents Gurmukhi_consonants[] = {
2575 {{0x0A32,0x0A3C,0x0000}, 0x0A33},
2576 {{0x0A38,0x0A3C,0x0000}, 0x0A36},
2577 {{0x0A16,0x0A3C,0x0000}, 0x0A59},
2578 {{0x0A17,0x0A3C,0x0000}, 0x0A5A},
2579 {{0x0A1C,0x0A3C,0x0000}, 0x0A5B},
2580 {{0x0A2B,0x0A3C,0x0000}, 0x0A5E},
2581 {{0x0000,0x0000,0x0000}, 0x0000}};
2582
2583 static void ContextualShape_Gurmukhi(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2584 {
2585 int cCount = cChars;
2586 WCHAR *input;
2587 IndicSyllable *syllables = NULL;
2588 int syllable_count = 0;
2589 BOOL modern = get_GSUB_Indic2(psa, psc);
2590
2591 if (*pcGlyphs != cChars)
2592 {
2593 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2594 return;
2595 }
2596
2597 input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
2598 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2599
2600 /* Step 1: Compose Consonents */
2601 ComposeConsonants(hdc, input, &cCount, Gurmukhi_consonants, pwLogClust);
2602 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2603
2604 /* Step 2: Reorder within Syllables */
2605 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, gurmukhi_lex, Reorder_Like_Bengali, modern);
2606 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2607 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2608 *pcGlyphs = cCount;
2609
2610 /* Step 3: Base Form application to syllables */
2611 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, gurmukhi_lex, NULL, modern);
2612
2613 HeapFree(GetProcessHeap(),0,input);
2614 HeapFree(GetProcessHeap(),0,syllables);
2615 }
2616
2617 static int gujarati_lex(WCHAR c)
2618 {
2619 switch (c)
2620 {
2621 case 0x0AB0: return lex_Ra;
2622 default:
2623 return unicode_lex(c);
2624 }
2625 }
2626
2627 static void ContextualShape_Gujarati(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2628 {
2629 int cCount = cChars;
2630 WCHAR *input;
2631 IndicSyllable *syllables = NULL;
2632 int syllable_count = 0;
2633 BOOL modern = get_GSUB_Indic2(psa, psc);
2634
2635 if (*pcGlyphs != cChars)
2636 {
2637 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2638 return;
2639 }
2640
2641 input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
2642 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2643
2644 /* Step 1: Reorder within Syllables */
2645 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, gujarati_lex, Reorder_Like_Devanagari, modern);
2646 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2647 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2648 *pcGlyphs = cCount;
2649
2650 /* Step 2: Base Form application to syllables */
2651 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, gujarati_lex, NULL, modern);
2652
2653 HeapFree(GetProcessHeap(),0,input);
2654 HeapFree(GetProcessHeap(),0,syllables);
2655 }
2656
2657 static int oriya_lex(WCHAR c)
2658 {
2659 switch (c)
2660 {
2661 case 0x0B30: return lex_Ra;
2662 default:
2663 return unicode_lex(c);
2664 }
2665 }
2666
2667 static const VowelComponents Oriya_vowels[] = {
2668 {0x0B48, {0x0B47,0x0B56,0x0000}},
2669 {0x0B4B, {0x0B47,0x0B3E,0x0000}},
2670 {0x0B4C, {0x0B47,0x0B57,0x0000}},
2671 {0x0000, {0x0000,0x0000,0x0000}}};
2672
2673 static const ConsonantComponents Oriya_consonants[] = {
2674 {{0x0B21,0x0B3C,0x0000}, 0x0B5C},
2675 {{0x0B22,0x0B3C,0x0000}, 0x0B5D},
2676 {{0x0000,0x0000,0x0000}, 0x0000}};
2677
2678 static void ContextualShape_Oriya(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2679 {
2680 int cCount = cChars;
2681 WCHAR *input;
2682 IndicSyllable *syllables = NULL;
2683 int syllable_count = 0;
2684 BOOL modern = get_GSUB_Indic2(psa, psc);
2685
2686 if (*pcGlyphs != cChars)
2687 {
2688 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2689 return;
2690 }
2691
2692 input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2693 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2694
2695 /* Step 1: Decompose Vowels and Compose Consonents */
2696 DecomposeVowels(hdc, input, &cCount, Oriya_vowels, pwLogClust);
2697 ComposeConsonants(hdc, input, &cCount, Oriya_consonants, pwLogClust);
2698 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2699
2700 /* Step 2: Reorder within Syllables */
2701 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, oriya_lex, Reorder_Like_Bengali, modern);
2702 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2703 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2704 *pcGlyphs = cCount;
2705
2706 /* Step 3: Base Form application to syllables */
2707 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, oriya_lex, NULL, modern);
2708
2709 HeapFree(GetProcessHeap(),0,input);
2710 HeapFree(GetProcessHeap(),0,syllables);
2711 }
2712
2713 static int tamil_lex(WCHAR c)
2714 {
2715 return unicode_lex(c);
2716 }
2717
2718 static const VowelComponents Tamil_vowels[] = {
2719 {0x0BCA, {0x0BC6,0x0BBE,0x0000}},
2720 {0x0BCB, {0x0BC7,0x0BBE,0x0000}},
2721 {0x0BCB, {0x0BC6,0x0BD7,0x0000}},
2722 {0x0000, {0x0000,0x0000,0x0000}}};
2723
2724 static const ConsonantComponents Tamil_consonants[] = {
2725 {{0x0B92,0x0BD7,0x0000}, 0x0B94},
2726 {{0x0000,0x0000,0x0000}, 0x0000}};
2727
2728 static void ContextualShape_Tamil(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2729 {
2730 int cCount = cChars;
2731 WCHAR *input;
2732 IndicSyllable *syllables = NULL;
2733 int syllable_count = 0;
2734 BOOL modern = get_GSUB_Indic2(psa, psc);
2735
2736 if (*pcGlyphs != cChars)
2737 {
2738 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2739 return;
2740 }
2741
2742 input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2743 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2744
2745 /* Step 1: Decompose Vowels and Compose Consonents */
2746 DecomposeVowels(hdc, input, &cCount, Tamil_vowels, pwLogClust);
2747 ComposeConsonants(hdc, input, &cCount, Tamil_consonants, pwLogClust);
2748 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2749
2750 /* Step 2: Reorder within Syllables */
2751 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, tamil_lex, Reorder_Like_Bengali, modern);
2752 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2753 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2754 *pcGlyphs = cCount;
2755
2756 /* Step 3: Base Form application to syllables */
2757 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, tamil_lex, SecondReorder_Like_Tamil, modern);
2758
2759 HeapFree(GetProcessHeap(),0,input);
2760 HeapFree(GetProcessHeap(),0,syllables);
2761 }
2762
2763 static int telugu_lex(WCHAR c)
2764 {
2765 switch (c)
2766 {
2767 case 0x0C43:
2768 case 0x0C44: return lex_Modifier;
2769 default:
2770 return unicode_lex(c);
2771 }
2772 }
2773
2774 static const VowelComponents Telugu_vowels[] = {
2775 {0x0C48, {0x0C46,0x0C56,0x0000}},
2776 {0x0000, {0x0000,0x0000,0x0000}}};
2777
2778 static void ContextualShape_Telugu(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2779 {
2780 int cCount = cChars;
2781 WCHAR *input;
2782 IndicSyllable *syllables = NULL;
2783 int syllable_count = 0;
2784 BOOL modern = get_GSUB_Indic2(psa, psc);
2785
2786 if (*pcGlyphs != cChars)
2787 {
2788 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2789 return;
2790 }
2791
2792 input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2793 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2794
2795 /* Step 1: Decompose Vowels */
2796 DecomposeVowels(hdc, input, &cCount, Telugu_vowels, pwLogClust);
2797 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2798
2799 /* Step 2: Reorder within Syllables */
2800 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, telugu_lex, Reorder_Like_Bengali, modern);
2801 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2802 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2803 *pcGlyphs = cCount;
2804
2805 /* Step 3: Base Form application to syllables */
2806 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, telugu_lex, SecondReorder_Like_Telugu, modern);
2807
2808 HeapFree(GetProcessHeap(),0,input);
2809 HeapFree(GetProcessHeap(),0,syllables);
2810 }
2811
2812 static int kannada_lex(WCHAR c)
2813 {
2814 switch (c)
2815 {
2816 case 0x0CB0: return lex_Ra;
2817 default:
2818 return unicode_lex(c);
2819 }
2820 }
2821
2822 static const VowelComponents Kannada_vowels[] = {
2823 {0x0CC0, {0x0CBF,0x0CD5,0x0000}},
2824 {0x0CC7, {0x0CC6,0x0CD5,0x0000}},
2825 {0x0CC8, {0x0CC6,0x0CD6,0x0000}},
2826 {0x0CCA, {0x0CC6,0x0CC2,0x0000}},
2827 {0x0CCB, {0x0CC6,0x0CC2,0x0CD5}},
2828 {0x0000, {0x0000,0x0000,0x0000}}};
2829
2830 static void ContextualShape_Kannada(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2831 {
2832 int cCount = cChars;
2833 WCHAR *input;
2834 IndicSyllable *syllables = NULL;
2835 int syllable_count = 0;
2836 BOOL modern = get_GSUB_Indic2(psa, psc);
2837
2838 if (*pcGlyphs != cChars)
2839 {
2840 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2841 return;
2842 }
2843
2844 input = HeapAlloc(GetProcessHeap(), 0, (cChars*3) * sizeof(WCHAR));
2845 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2846
2847 /* Step 1: Decompose Vowels */
2848 DecomposeVowels(hdc, input, &cCount, Kannada_vowels, pwLogClust);
2849 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2850
2851 /* Step 2: Reorder within Syllables */
2852 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, kannada_lex, Reorder_Like_Kannada, modern);
2853 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2854 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2855 *pcGlyphs = cCount;
2856
2857 /* Step 3: Base Form application to syllables */
2858 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, kannada_lex, SecondReorder_Like_Telugu, modern);
2859
2860 HeapFree(GetProcessHeap(),0,input);
2861 HeapFree(GetProcessHeap(),0,syllables);
2862 }
2863
2864 static int malayalam_lex(WCHAR c)
2865 {
2866 return unicode_lex(c);
2867 }
2868
2869 static const VowelComponents Malayalam_vowels[] = {
2870 {0x0D4A, {0x0D46,0x0D3E,0x0000}},
2871 {0x0D4B, {0x0D47,0x0D3E,0x0000}},
2872 {0x0D4C, {0x0D46,0x0D57,0x0000}},
2873 {0x0000, {0x0000,0x0000,0x0000}}};
2874
2875 static void ContextualShape_Malayalam(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2876 {
2877 int cCount = cChars;
2878 WCHAR *input;
2879 IndicSyllable *syllables = NULL;
2880 int syllable_count = 0;
2881 BOOL modern = get_GSUB_Indic2(psa, psc);
2882
2883 if (*pcGlyphs != cChars)
2884 {
2885 ERR("Number of Glyphs and Chars need to match at the beginning\n");
2886 return;
2887 }
2888
2889 input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2890 memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2891
2892 /* Step 1: Decompose Vowels */
2893 DecomposeVowels(hdc, input, &cCount, Malayalam_vowels, pwLogClust);
2894 TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2895
2896 /* Step 2: Reorder within Syllables */
2897 Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, malayalam_lex, Reorder_Like_Devanagari, modern);
2898 TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2899 GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2900 *pcGlyphs = cCount;
2901
2902 /* Step 3: Base Form application to syllables */
2903 ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, malayalam_lex, SecondReorder_Like_Tamil, modern);
2904
2905 HeapFree(GetProcessHeap(),0,input);
2906 HeapFree(GetProcessHeap(),0,syllables);
2907 }
2908
2909 static void ShapeCharGlyphProp_Default( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp)
2910 {
2911 int i,k;
2912
2913 for (i = 0; i < cGlyphs; i++)
2914 {
2915 int char_index[20];
2916 int char_count = 0;
2917
2918 for (k = 0; k < cChars; k++)
2919 {
2920 if (pwLogClust[k] == i)
2921 {
2922 char_index[char_count] = k;
2923 char_count++;
2924 }
2925 }
2926
2927 if (char_count == 0)
2928 {
2929 FIXME("No chars in this glyph? Must be an error\n");
2930 continue;
2931 }
2932
2933 if (char_count ==1 && pwcChars[char_index[0]] == 0x0020) /* space */
2934 {
2935 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_BLANK;
2936 pCharProp[char_index[0]].fCanGlyphAlone = 1;
2937 }
2938 else
2939 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
2940 }
2941
2942 GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, pGlyphProp);
2943 UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
2944 }
2945
2946 static void ShapeCharGlyphProp_Arabic( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
2947 {
2948 int i,k;
2949 int initGlyph, finaGlyph;
2950 INT dirR, dirL;
2951 BYTE *spaces;
2952
2953 spaces = HeapAlloc(GetProcessHeap(),0,cGlyphs);
2954 memset(spaces,0,cGlyphs);
2955
2956 if (!psa->fLogicalOrder && psa->fRTL)
2957 {
2958 initGlyph = cGlyphs-1;
2959 finaGlyph = 0;
2960 dirR = 1;
2961 dirL = -1;
2962 }
2963 else
2964 {
2965 initGlyph = 0;
2966 finaGlyph = cGlyphs-1;
2967 dirR = -1;
2968 dirL = 1;
2969 }
2970
2971 for (i = 0; i < cGlyphs; i++)
2972 {
2973 for (k = 0; k < cChars; k++)
2974 if (pwLogClust[k] == i)
2975 {
2976 if (pwcChars[k] == 0x0020)
2977 spaces[i] = 1;
2978 }
2979 }
2980
2981 for (i = 0; i < cGlyphs; i++)
2982 {
2983 int char_index[20];
2984 int char_count = 0;
2985 BOOL isInit, isFinal;
2986
2987 for (k = 0; k < cChars; k++)
2988 {
2989 if (pwLogClust[k] == i)
2990 {
2991 char_index[char_count] = k;
2992 char_count++;
2993 }
2994 }
2995
2996 isInit = (i == initGlyph || (i+dirR > 0 && i+dirR < cGlyphs && spaces[i+dirR]));
2997 isFinal = (i == finaGlyph || (i+dirL > 0 && i+dirL < cGlyphs && spaces[i+dirL]));
2998
2999 if (char_count == 0)
3000 {
3001 FIXME("No chars in this glyph? Must be an error\n");
3002 continue;
3003 }
3004
3005 if (char_count == 1)
3006 {
3007 if (pwcChars[char_index[0]] == 0x0020) /* space */
3008 {
3009 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_BLANK;
3010 pCharProp[char_index[0]].fCanGlyphAlone = 1;
3011 }
3012 else if (pwcChars[char_index[0]] == 0x0640) /* kashida */
3013 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_KASHIDA;
3014 else if (pwcChars[char_index[0]] == 0x0633) /* SEEN */
3015 {
3016 if (!isInit && !isFinal)
3017 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_SEEN_M;
3018 else if (isInit)
3019 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_SEEN;
3020 else
3021 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3022 }
3023 else if (!isInit)
3024 {
3025 if (pwcChars[char_index[0]] == 0x0628 ) /* BA */
3026 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_BA;
3027 else if (pwcChars[char_index[0]] == 0x0631 ) /* RA */
3028 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_RA;
3029 else if (pwcChars[char_index[0]] == 0x0647 ) /* HA */
3030 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_HA;
3031 else if ((pwcChars[char_index[0]] == 0x0627 || pwcChars[char_index[0]] == 0x0625 || pwcChars[char_index[0]] == 0x0623 || pwcChars[char_index[0]] == 0x0622) ) /* alef-like */
3032 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_ALEF;
3033 else
3034 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3035 }
3036 else if (!isInit && !isFinal)
3037 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_NORMAL;
3038 else
3039 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3040 }
3041 else if (char_count == 2)
3042 {
3043 if ((pwcChars[char_index[0]] == 0x0628 && pwcChars[char_index[1]]== 0x0631) || (pwcChars[char_index[0]] == 0x0631 && pwcChars[char_index[1]]== 0x0628)) /* BA+RA */
3044 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_BARA;
3045 else if (!isInit)
3046 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_NORMAL;
3047 else
3048 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3049 }
3050 else if (!isInit && !isFinal)
3051 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_NORMAL;
3052 else
3053 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3054 }
3055
3056 GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, pGlyphProp);
3057 UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3058 HeapFree(GetProcessHeap(),0,spaces);
3059 }
3060
3061 static void ShapeCharGlyphProp_Thai( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3062 {
3063 int i,k;
3064 int finaGlyph;
3065 INT dirL;
3066 BYTE *spaces;
3067
3068 spaces = HeapAlloc(GetProcessHeap(),0,cGlyphs);
3069 memset(spaces,0,cGlyphs);
3070
3071 if (!psa->fLogicalOrder && psa->fRTL)
3072 {
3073 finaGlyph = 0;
3074 dirL = -1;
3075 }
3076 else
3077 {
3078 finaGlyph = cGlyphs-1;
3079 dirL = 1;
3080 }
3081
3082 for (i = 0; i < cGlyphs; i++)
3083 {
3084 for (k = 0; k < cChars; k++)
3085 if (pwLogClust[k] == i)
3086 {
3087 if (pwcChars[k] == 0x0020)
3088 spaces[i] = 1;
3089 }
3090 }
3091
3092 for (i = 0; i < cGlyphs; i++)
3093 {
3094 int char_index[20];
3095 int char_count = 0;
3096
3097 for (k = 0; k < cChars; k++)
3098 {
3099 if (pwLogClust[k] == i)
3100 {
3101 char_index[char_count] = k;
3102 char_count++;
3103 }
3104 }
3105
3106 if (char_count == 0)
3107 {
3108 FIXME("No chars in this glyph? Must be an error\n");
3109 continue;
3110 }
3111
3112 if (char_count ==1 && pwcChars[char_index[0]] == 0x0020) /* space */
3113 {
3114 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3115 pCharProp[char_index[0]].fCanGlyphAlone = 1;
3116 }
3117 else if (i == finaGlyph)
3118 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3119 else
3120 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3121 }
3122
3123 HeapFree(GetProcessHeap(),0,spaces);
3124 GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, pGlyphProp);
3125 UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3126
3127 /* Do not allow justification between marks and their base */
3128 for (i = 0; i < cGlyphs; i++)
3129 {
3130 if (!pGlyphProp[i].sva.fClusterStart)
3131 pGlyphProp[i-dirL].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3132 }
3133 }
3134
3135 static void ShapeCharGlyphProp_None( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp)
3136 {
3137 int i,k;
3138
3139 for (i = 0; i < cGlyphs; i++)
3140 {
3141 int char_index[20];
3142 int char_count = 0;
3143
3144 for (k = 0; k < cChars; k++)
3145 {
3146 if (pwLogClust[k] == i)
3147 {
3148 char_index[char_count] = k;
3149 char_count++;
3150 }
3151 }
3152
3153 if (char_count == 0)
3154 {
3155 FIXME("No chars in this glyph? Must be an error\n");
3156 continue;
3157 }
3158
3159 if (char_count ==1 && pwcChars[char_index[0]] == 0x0020) /* space */
3160 {
3161 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3162 pCharProp[char_index[0]].fCanGlyphAlone = 1;
3163 }
3164 else
3165 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3166 }
3167 GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, pGlyphProp);
3168 UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3169 }
3170
3171 static void ShapeCharGlyphProp_Tibet( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp)
3172 {
3173 int i,k;
3174
3175 for (i = 0; i < cGlyphs; i++)
3176 {
3177 int char_index[20];
3178 int char_count = 0;
3179
3180 for (k = 0; k < cChars; k++)
3181 {
3182 if (pwLogClust[k] == i)
3183 {
3184 char_index[char_count] = k;
3185 char_count++;
3186 }
3187 }
3188
3189 if (char_count == 0)
3190 {
3191 FIXME("No chars in this glyph? Must be an error\n");
3192 continue;
3193 }
3194
3195 if (char_count ==1 && pwcChars[char_index[0]] == 0x0020) /* space */
3196 {
3197 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_BLANK;
3198 pCharProp[char_index[0]].fCanGlyphAlone = 1;
3199 }
3200 else
3201 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3202 }
3203 GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, pGlyphProp);
3204 UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3205
3206 /* Tibeten script does not set sva.fDiacritic or sva.fZeroWidth */
3207 for (i = 0; i < cGlyphs; i++)
3208 {
3209 if (!pGlyphProp[i].sva.fClusterStart)
3210 {
3211 pGlyphProp[i].sva.fDiacritic = 0;
3212 pGlyphProp[i].sva.fZeroWidth = 0;
3213 }
3214 }
3215 }
3216
3217 static void ShapeCharGlyphProp_BaseIndic( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp, lexical_function lexical)
3218 {
3219 int i,k;
3220 IndicSyllable *syllables = NULL;
3221 int syllable_count = 0;
3222 BOOL modern = get_GSUB_Indic2(psa, psc);
3223
3224 for (i = 0; i < cGlyphs; i++)
3225 {
3226 int char_index[20];
3227 int char_count = 0;
3228
3229 for (k = 0; k < cChars; k++)
3230 {
3231 if (pwLogClust[k] == i)
3232 {
3233 char_index[char_count] = k;
3234 char_count++;
3235 }
3236 }
3237
3238 if (char_count == 0)
3239 {
3240 FIXME("No chars in this glyph? Must be an error\n");
3241 continue;
3242 }
3243
3244 if (char_count ==1 && pwcChars[char_index[0]] == 0x0020) /* space */
3245 {
3246 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_BLANK;
3247 pCharProp[char_index[0]].fCanGlyphAlone = 1;
3248 }
3249 else
3250 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3251
3252 pGlyphProp[i].sva.fClusterStart = 0;
3253 for (k = 0; k < char_count && !pGlyphProp[i].sva.fClusterStart; k++)
3254 switch (lexical(pwcChars[char_index[k]]))
3255 {
3256 case lex_Matra_pre:
3257 case lex_Matra_post:
3258 case lex_Matra_above:
3259 case lex_Matra_below:
3260 case lex_Modifier:
3261 break;
3262 default:
3263 pGlyphProp[i].sva.fClusterStart = 1;
3264 break;
3265 }
3266 }
3267
3268 Indic_ParseSyllables( hdc, psa, psc, pwcChars, cChars, &syllables, &syllable_count, lexical, modern);
3269
3270 for (i = 0; i < syllable_count; i++)
3271 {
3272 int j;
3273 WORD g = pwLogClust[syllables[i].start];
3274 for (j = syllables[i].start+1; j <= syllables[i].end; j++)
3275 {
3276 if (pwLogClust[j] != g)
3277 {
3278 pGlyphProp[pwLogClust[j]].sva.fClusterStart = 0;
3279 pwLogClust[j] = g;
3280 }
3281 }
3282 }
3283
3284 UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3285 HeapFree(GetProcessHeap(), 0, syllables);
3286 }
3287
3288 static void ShapeCharGlyphProp_Sinhala( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3289 {
3290 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, sinhala_lex);
3291 }
3292
3293 static void ShapeCharGlyphProp_Devanagari( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3294 {
3295 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, devanagari_lex);
3296 }
3297
3298 static void ShapeCharGlyphProp_Bengali( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3299 {
3300 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, bengali_lex);
3301 }
3302
3303 static void ShapeCharGlyphProp_Gurmukhi( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3304 {
3305 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, gurmukhi_lex);
3306 }
3307
3308 static void ShapeCharGlyphProp_Gujarati( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3309 {
3310 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, gujarati_lex);
3311 }
3312
3313 static void ShapeCharGlyphProp_Oriya( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3314 {
3315 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, oriya_lex);
3316 }
3317
3318 static void ShapeCharGlyphProp_Tamil( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3319 {
3320 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, tamil_lex);
3321 }
3322
3323 static void ShapeCharGlyphProp_Telugu( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3324 {
3325 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, telugu_lex);
3326 }
3327
3328 static void ShapeCharGlyphProp_Kannada( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3329 {
3330 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, kannada_lex);
3331 }
3332
3333 static void ShapeCharGlyphProp_Malayalam( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3334 {
3335 ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, malayalam_lex);
3336 }
3337
3338 void SHAPE_CharGlyphProp(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp)
3339 {
3340 if (ShapingData[psa->eScript].charGlyphPropProc)
3341 ShapingData[psa->eScript].charGlyphPropProc(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp);
3342 else
3343 ShapeCharGlyphProp_Default(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp);
3344 }
3345
3346 void SHAPE_ContextualShaping(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
3347 {
3348 if (ShapingData[psa->eScript].contextProc)
3349 ShapingData[psa->eScript].contextProc(hdc, psc, psa, pwcChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
3350 }
3351
3352 static void SHAPE_ApplyOpenTypeFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, INT cChars, const TEXTRANGE_PROPERTIES *rpRangeProperties, WORD *pwLogClust)
3353 {
3354 int i;
3355 INT dirL;
3356
3357 if (!rpRangeProperties)
3358 return;
3359
3360 if (!psc->GSUB_Table)
3361 psc->GSUB_Table = load_gsub_table(hdc);
3362
3363 if (!psc->GSUB_Table)
3364 return;
3365
3366 if (!psa->fLogicalOrder && psa->fRTL)
3367 dirL = -1;
3368 else
3369 dirL = 1;
3370
3371 for (i = 0; i < rpRangeProperties->cotfRecords; i++)
3372 {
3373 if (rpRangeProperties->potfRecords[i].lParameter > 0)
3374 apply_GSUB_feature(hdc, psa, psc, pwOutGlyphs, dirL, pcGlyphs, cChars, (const char*)&rpRangeProperties->potfRecords[i].tagFeature, pwLogClust);
3375 }
3376 }
3377
3378 void SHAPE_ApplyDefaultOpentypeFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, INT cChars, WORD *pwLogClust)
3379 {
3380 const TEXTRANGE_PROPERTIES *rpRangeProperties;
3381 rpRangeProperties = &ShapingData[psa->eScript].defaultTextRange;
3382
3383 SHAPE_ApplyOpenTypeFeatures(hdc, psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, rpRangeProperties, pwLogClust);
3384 }
3385
3386 HRESULT SHAPE_CheckFontForRequiredFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa)
3387 {
3388 const GSUB_Feature *feature;
3389 int i;
3390
3391 if (!ShapingData[psa->eScript].requiredFeatures)
3392 return S_OK;
3393
3394 if (!psc->GSUB_Table)
3395 psc->GSUB_Table = load_gsub_table(hdc);
3396
3397 /* we need to have at least one of the required features */
3398 i = 0;
3399 while (ShapingData[psa->eScript].requiredFeatures[i])
3400 {
3401 feature = load_GSUB_feature(hdc, psa, psc, ShapingData[psa->eScript].requiredFeatures[i]);
3402 if (feature)
3403 return S_OK;
3404 i++;
3405 }
3406
3407 return USP_E_SCRIPT_NOT_IN_FONT;
3408 }
Windows API implementation