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