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