?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9/tests: Add a D3DXValidMesh test.
[wine/multimedia.git] / dlls / usp10 / usp10.c
blob4f532f54f93cb13b0aa23fcdae629669b1726f54
1 /*
2 * Implementation of Uniscribe Script Processor (usp10.dll)
3 *
4 * Copyright 2005 Steven Edwards for CodeWeavers
5 * Copyright 2006 Hans Leidekker
6 * Copyright 2010 CodeWeavers, Aric Stewart
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 * Notes:
23 * Uniscribe allows for processing of complex scripts such as joining
24 * and filtering characters and bi-directional text with custom line breaks.
25 */
26
27 #include <stdarg.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "winnls.h"
34 #include "winreg.h"
35 #include "usp10.h"
36
37 #include "usp10_internal.h"
38
39 #include "wine/debug.h"
40 #include "wine/unicode.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
43
44 typedef struct _scriptRange
45 {
46 WORD script;
47 DWORD rangeFirst;
48 DWORD rangeLast;
49 WORD numericScript;
50 WORD punctScript;
51 } scriptRange;
52
53 static const scriptRange scriptRanges[] = {
54 /* Basic Latin: U+0000–U+007A */
55 { Script_Latin, 0x00, 0x07a , Script_Numeric, Script_Punctuation},
56 /* Latin-1 Supplement: U+0080–U+00FF */
57 /* Latin Extended-A: U+0100–U+017F */
58 /* Latin Extended-B: U+0180–U+024F */
59 /* IPA Extensions: U+0250–U+02AF */
60 /* Spacing Modifier Letters:U+02B0–U+02FF */
61 { Script_Latin, 0x80, 0x2ff , Script_Numeric2, Script_Punctuation},
62 /* Combining Diacritical Marks : U+0300–U+036F */
63 { Script_Diacritical,0x300, 0x36f, 0, 0},
64 /* Greek: U+0370–U+03FF */
65 { Script_Greek, 0x370, 0x3ff, 0, 0},
66 /* Cyrillic: U+0400–U+04FF */
67 /* Cyrillic Supplement: U+0500–U+052F */
68 { Script_Cyrillic, 0x400, 0x52f, 0, 0},
69 /* Armenian: U+0530–U+058F */
70 { Script_Armenian, 0x530, 0x58f, 0, 0},
71 /* Hebrew: U+0590–U+05FF */
72 { Script_Hebrew, 0x590, 0x5ff, 0, 0},
73 /* Arabic: U+0600–U+06FF */
74 { Script_Arabic, 0x600, 0x6ef, Script_Arabic_Numeric, 0},
75 /* Defined by Windows */
76 { Script_Persian, 0x6f0, 0x6f9, 0, 0},
77 /* Continue Arabic: U+0600–U+06FF */
78 { Script_Arabic, 0x6fa, 0x6ff, 0, 0},
79 /* Syriac: U+0700–U+074F*/
80 { Script_Syriac, 0x700, 0x74f, 0, 0},
81 /* Arabic Supplement: U+0750–U+077F */
82 { Script_Arabic, 0x750, 0x77f, 0, 0},
83 /* Thaana: U+0780–U+07BF */
84 { Script_Thaana, 0x780, 0x7bf, 0, 0},
85 /* N’Ko: U+07C0–U+07FF */
86 { Script_NKo, 0x7c0, 0x7ff, 0, 0},
87 /* Devanagari: U+0900–U+097F */
88 { Script_Devanagari, 0x900, 0x97f, Script_Devanagari_Numeric, 0},
89 /* Bengali: U+0980–U+09FF */
90 { Script_Bengali, 0x980, 0x9ff, Script_Bengali_Numeric, 0},
91 /* Gurmukhi: U+0A00–U+0A7F*/
92 { Script_Gurmukhi, 0xa00, 0xa7f, Script_Gurmukhi_Numeric, 0},
93 /* Gujarati: U+0A80–U+0AFF*/
94 { Script_Gujarati, 0xa80, 0xaff, Script_Gujarati_Numeric, 0},
95 /* Oriya: U+0B00–U+0B7F */
96 { Script_Oriya, 0xb00, 0xb7f, Script_Oriya_Numeric, 0},
97 /* Tamil: U+0B80–U+0BFF */
98 { Script_Tamil, 0xb80, 0xbff, Script_Tamil_Numeric, 0},
99 /* Telugu: U+0C00–U+0C7F */
100 { Script_Telugu, 0xc00, 0xc7f, Script_Telugu_Numeric, 0},
101 /* Kannada: U+0C80–U+0CFF */
102 { Script_Kannada, 0xc80, 0xcff, Script_Kannada_Numeric, 0},
103 /* Malayalam: U+0D00–U+0D7F */
104 { Script_Malayalam, 0xd00, 0xd7f, Script_Malayalam_Numeric, 0},
105 /* Sinhala: U+0D80–U+0DFF */
106 { Script_Sinhala, 0xd80, 0xdff, 0, 0},
107 /* Thai: U+0E00–U+0E7F */
108 { Script_Thai, 0xe00, 0xe7f, Script_Thai_Numeric, 0},
109 /* Lao: U+0E80–U+0EFF */
110 { Script_Lao, 0xe80, 0xeff, Script_Lao_Numeric, 0},
111 /* Tibetan: U+0F00–U+0FFF */
112 { Script_Tibetan, 0xf00, 0xfff, 0, 0},
113 /* Myanmar: U+1000–U+109F */
114 { Script_Myanmar, 0x1000, 0x109f, Script_Myanmar_Numeric, 0},
115 /* Georgian: U+10A0–U+10FF */
116 { Script_Georgian, 0x10a0, 0x10ff, 0, 0},
117 /* Hangul Jamo: U+1100–U+11FF */
118 { Script_Hangul, 0x1100, 0x11ff, 0, 0},
119 /* Ethiopic: U+1200–U+137F */
120 /* Ethiopic Extensions: U+1380–U+139F */
121 { Script_Ethiopic, 0x1200, 0x139f, 0, 0},
122 /* Cherokee: U+13A0–U+13FF */
123 { Script_Cherokee, 0x13a0, 0x13ff, 0, 0},
124 /* Canadian Aboriginal Syllabics: U+1400–U+167F */
125 { Script_Canadian, 0x1400, 0x167f, 0, 0},
126 /* Ogham: U+1680–U+169F */
127 { Script_Ogham, 0x1680, 0x169f, 0, 0},
128 /* Runic: U+16A0–U+16F0 */
129 { Script_Runic, 0x16a0, 0x16f0, 0, 0},
130 /* Khmer: U+1780–U+17FF */
131 { Script_Khmer, 0x1780, 0x17ff, Script_Khmer_Numeric, 0},
132 /* Mongolian: U+1800–U+18AF */
133 { Script_Mongolian, 0x1800, 0x18af, Script_Mongolian_Numeric, 0},
134 /* Canadian Aboriginal Syllabics Extended: U+18B0–U+18FF */
135 { Script_Canadian, 0x18b0, 0x18ff, 0, 0},
136 /* Tai Le: U+1950–U+197F */
137 { Script_Tai_Le, 0x1950, 0x197f, 0, 0},
138 /* New Tai Lue: U+1980–U+19DF */
139 { Script_New_Tai_Lue,0x1980, 0x19df, Script_New_Tai_Lue_Numeric, 0},
140 /* Khmer Symbols: U+19E0–U+19FF */
141 { Script_Khmer, 0x19e0, 0x19ff, Script_Khmer_Numeric, 0},
142 /* Vedic Extensions: U+1CD0-U+1CFF */
143 { Script_Devanagari, 0x1cd0, 0x1cff, Script_Devanagari_Numeric, 0},
144 /* Phonetic Extensions: U+1D00–U+1DBF */
145 { Script_Latin, 0x1d00, 0x1dbf, 0, 0},
146 /* Combining Diacritical Marks Supplement: U+1DC0–U+1DFF */
147 { Script_Diacritical,0x1dc0, 0x1dff, 0, 0},
148 /* Latin Extended Additional: U+1E00–U+1EFF */
149 { Script_Latin, 0x1e00, 0x1eff, 0, 0},
150 /* Greek Extended: U+1F00–U+1FFF */
151 { Script_Greek, 0x1f00, 0x1fff, 0, 0},
152 /* General Punctuation: U+2000 –U+206f */
153 { Script_Latin, 0x2000, 0x206f, 0, 0},
154 /* Superscripts and Subscripts : U+2070 –U+209f */
155 /* Currency Symbols : U+20a0 –U+20cf */
156 { Script_Numeric2, 0x2070, 0x2070, 0, 0},
157 { Script_Latin, 0x2071, 0x2073, 0, 0},
158 { Script_Numeric2, 0x2074, 0x2079, 0, 0},
159 { Script_Latin, 0x207a, 0x207f, 0, 0},
160 { Script_Numeric2, 0x2080, 0x2089, 0, 0},
161 { Script_Latin, 0x208a, 0x20cf, 0, 0},
162 /* Letterlike Symbols : U+2100 –U+214f */
163 /* Number Forms : U+2150 –U+218f */
164 /* Arrows : U+2190 –U+21ff */
165 /* Mathematical Operators : U+2200 –U+22ff */
166 /* Miscellaneous Technical : U+2300 –U+23ff */
167 /* Control Pictures : U+2400 –U+243f */
168 /* Optical Character Recognition : U+2440 –U+245f */
169 /* Enclosed Alphanumerics : U+2460 –U+24ff */
170 /* Box Drawing : U+2500 –U+25ff */
171 /* Block Elements : U+2580 –U+259f */
172 /* Geometric Shapes : U+25a0 –U+25ff */
173 /* Miscellaneous Symbols : U+2600 –U+26ff */
174 /* Dingbats : U+2700 –U+27bf */
175 /* Miscellaneous Mathematical Symbols-A : U+27c0 –U+27ef */
176 /* Supplemental Arrows-A : U+27f0 –U+27ff */
177 { Script_Latin, 0x2100, 0x27ff, 0, 0},
178 /* Braille Patterns: U+2800–U+28FF */
179 { Script_Braille, 0x2800, 0x28ff, 0, 0},
180 /* Supplemental Arrows-B : U+2900 –U+297f */
181 /* Miscellaneous Mathematical Symbols-B : U+2980 –U+29ff */
182 /* Supplemental Mathematical Operators : U+2a00 –U+2aff */
183 /* Miscellaneous Symbols and Arrows : U+2b00 –U+2bff */
184 { Script_Latin, 0x2900, 0x2bff, 0, 0},
185 /* Latin Extended-C: U+2C60–U+2C7F */
186 { Script_Latin, 0x2c60, 0x2c7f, 0, 0},
187 /* Georgian: U+2D00–U+2D2F */
188 { Script_Georgian, 0x2d00, 0x2d2f, 0, 0},
189 /* Tifinagh: U+2D30–U+2D7F */
190 { Script_Tifinagh, 0x2d30, 0x2d7f, 0, 0},
191 /* Ethiopic Extensions: U+2D80–U+2DDF */
192 { Script_Ethiopic, 0x2d80, 0x2ddf, 0, 0},
193 /* Cyrillic Extended-A: U+2DE0–U+2DFF */
194 { Script_Cyrillic, 0x2de0, 0x2dff, 0, 0},
195 /* CJK Radicals Supplement: U+2E80–U+2EFF */
196 /* Kangxi Radicals: U+2F00–U+2FDF */
197 { Script_CJK_Han, 0x2e80, 0x2fdf, 0, 0},
198 /* Ideographic Description Characters: U+2FF0–U+2FFF */
199 { Script_Ideograph ,0x2ff0, 0x2fff, 0, 0},
200 /* CJK Symbols and Punctuation: U+3000–U+303F */
201 { Script_Ideograph ,0x3000, 0x3004, 0, 0},
202 { Script_CJK_Han ,0x3005, 0x3005, 0, 0},
203 { Script_Ideograph ,0x3006, 0x3006, 0, 0},
204 { Script_CJK_Han ,0x3007, 0x3007, 0, 0},
205 { Script_Ideograph ,0x3008, 0x3020, 0, 0},
206 { Script_CJK_Han ,0x3021, 0x3029, 0, 0},
207 { Script_Ideograph ,0x302a, 0x3030, 0, 0},
208 /* Kana Marks: */
209 { Script_Kana ,0x3031, 0x3035, 0, 0},
210 { Script_Ideograph ,0x3036, 0x3037, 0, 0},
211 { Script_CJK_Han ,0x3038, 0x303b, 0, 0},
212 { Script_Ideograph ,0x303c, 0x303f, 0, 0},
213 /* Hiragana: U+3040–U+309F */
214 /* Katakana: U+30A0–U+30FF */
215 { Script_Kana ,0x3040, 0x30ff, 0, 0},
216 /* Bopomofo: U+3100–U+312F */
217 { Script_Bopomofo ,0x3100, 0x312f, 0, 0},
218 /* Hangul Compatibility Jamo: U+3130–U+318F */
219 { Script_Hangul ,0x3130, 0x318f, 0, 0},
220 /* Kanbun: U+3190–U+319F */
221 { Script_Ideograph ,0x3190, 0x319f, 0, 0},
222 /* Bopomofo Extended: U+31A0–U+31BF */
223 { Script_Bopomofo ,0x31a0, 0x31bf, 0, 0},
224 /* CJK Strokes: U+31C0–U+31EF */
225 { Script_Ideograph ,0x31c0, 0x31ef, 0, 0},
226 /* Katakana Phonetic Extensions: U+31F0–U+31FF */
227 { Script_Kana ,0x31f0, 0x31ff, 0, 0},
228 /* Enclosed CJK Letters and Months: U+3200–U+32FF */
229 { Script_Hangul ,0x3200, 0x321f, 0, 0},
230 { Script_Ideograph ,0x3220, 0x325f, 0, 0},
231 { Script_Hangul ,0x3260, 0x327f, 0, 0},
232 { Script_Ideograph ,0x3280, 0x32ef, 0, 0},
233 { Script_Kana ,0x32d0, 0x31ff, 0, 0},
234 /* CJK Compatibility: U+3300–U+33FF*/
235 { Script_Kana ,0x3300, 0x3357, 0, 0},
236 { Script_Ideograph ,0x3358, 0x33ff, 0, 0},
237 /* CJK Unified Ideographs Extension A: U+3400–U+4DBF */
238 { Script_CJK_Han ,0x3400, 0x4dbf, 0, 0},
239 /* CJK Unified Ideographs: U+4E00–U+9FFF */
240 { Script_CJK_Han ,0x4e00, 0x9fff, 0, 0},
241 /* Yi: U+A000–U+A4CF */
242 { Script_Yi ,0xa000, 0xa4cf, 0, 0},
243 /* Vai: U+A500–U+A63F */
244 { Script_Vai ,0xa500, 0xa63f, Script_Vai_Numeric, 0},
245 /* Cyrillic Extended-B: U+A640–U+A69F */
246 { Script_Cyrillic, 0xa640, 0xa69f, 0, 0},
247 /* Modifier Tone Letters: U+A700–U+A71F */
248 /* Latin Extended-D: U+A720–U+A7FF */
249 { Script_Latin, 0xa700, 0xa7ff, 0, 0},
250 /* Phags-pa: U+A840–U+A87F */
251 { Script_Phags_pa, 0xa840, 0xa87f, 0, 0},
252 /* Devanagari Extended: U+A8E0-U+A8FF */
253 { Script_Devanagari, 0xa8e0, 0xa8ff, Script_Devanagari_Numeric, 0},
254 /* Myanmar Extended-A: U+AA60–U+AA7F */
255 { Script_Myanmar, 0xaa60, 0xaa7f, Script_Myanmar_Numeric, 0},
256 /* Hangul Jamo Extended-A: U+A960–U+A97F */
257 { Script_Hangul, 0xa960, 0xa97f, 0, 0},
258 /* Hangul Syllables: U+AC00–U+D7A3 */
259 { Script_Hangul, 0xac00, 0xd7a3, 0, 0},
260 /* Hangul Jamo Extended-B: U+D7B0–U+D7FF */
261 { Script_Hangul, 0xd7b0, 0xd7ff, 0, 0},
262 /* Surrogates Area: U+D800–U+DFFF */
263 { Script_Surrogates, 0xd800, 0xdbfe, 0, 0},
264 { Script_Private, 0xdbff, 0xdc00, 0, 0},
265 { Script_Surrogates, 0xdc01, 0xdfff, 0, 0},
266 /* Private Use Area: U+E000–U+F8FF */
267 { Script_Private, 0xe000, 0xf8ff, 0, 0},
268 /* CJK Compatibility Ideographs: U+F900–U+FAFF */
269 { Script_CJK_Han ,0xf900, 0xfaff, 0, 0},
270 /* Latin Ligatures: U+FB00–U+FB06 */
271 { Script_Latin, 0xfb00, 0xfb06, 0, 0},
272 /* Armenian ligatures U+FB13..U+FB17 */
273 { Script_Armenian, 0xfb13, 0xfb17, 0, 0},
274 /* Alphabetic Presentation Forms: U+FB1D–U+FB4F */
275 { Script_Hebrew, 0xfb1d, 0xfb4f, 0, 0},
276 /* Arabic Presentation Forms-A: U+FB50–U+FDFF*/
277 { Script_Arabic, 0xfb50, 0xfdff, 0, 0},
278 /* Vertical Forms: U+FE10–U+FE1F */
279 /* Combining Half Marks: U+FE20–U+FE2F */
280 /* CJK Compatibility Forms: U+FE30–U+FE4F */
281 /* Small Form Variants: U+FE50–U+FE6F */
282 { Script_Ideograph ,0xfe10, 0xfe6f, 0, 0},
283 /* Arabic Presentation Forms-B: U+FE70–U+FEFF*/
284 { Script_Arabic, 0xfe70, 0xfeff, 0, 0},
285 /* Halfwidth and Fullwidth Forms: U+FF00–FFEF */
286 { Script_Ideograph ,0xff00, 0xff64, Script_Numeric2, 0},
287 { Script_Kana ,0xff65, 0xff9f, 0, 0},
288 { Script_Hangul ,0xffa0, 0xffdf, 0, 0},
289 { Script_Ideograph ,0xffe0, 0xffef, 0, 0},
290 /* Plane - 1 */
291 /* Deseret: U+10400–U+1044F */
292 { Script_Deseret, 0x10400, 0x1044F, 0, 0},
293 /* Osmanya: U+10480–U+104AF */
294 { Script_Osmanya, 0x10480, 0x104AF, Script_Osmanya_Numeric, 0},
295 /* Mathematical Alphanumeric Symbols: U+1D400–U+1D7FF */
296 { Script_MathAlpha, 0x1D400, 0x1D7FF, 0, 0},
297 /* END */
298 { SCRIPT_UNDEFINED, 0, 0, 0}
299 };
300
301 typedef struct _scriptData
302 {
303 SCRIPT_ANALYSIS a;
304 SCRIPT_PROPERTIES props;
305 OPENTYPE_TAG scriptTag;
306 WCHAR fallbackFont[LF_FACESIZE];
307 } scriptData;
308
309 /* the must be in order so that the index matches the Script value */
310 static const scriptData scriptInformation[] = {
311 {{SCRIPT_UNDEFINED, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
312 {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
313 0x00000000,
314 {0}},
315 {{Script_Latin, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
316 {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
317 MS_MAKE_TAG('l','a','t','n'),
318 {0}},
319 {{Script_CR, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
320 {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
321 0x00000000,
322 {0}},
323 {{Script_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
324 {LANG_ENGLISH, 1, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
325 0x00000000,
326 {0}},
327 {{Script_Control, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
328 {LANG_ENGLISH, 0, 1, 0, 0, ANSI_CHARSET, 1, 0, 0, 0, 0, 0, 1, 0, 0},
329 0x00000000,
330 {0}},
331 {{Script_Punctuation, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
332 {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
333 0x00000000,
334 {0}},
335 {{Script_Arabic, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
336 {LANG_ARABIC, 0, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 1, 0},
337 MS_MAKE_TAG('a','r','a','b'),
338 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
339 {{Script_Arabic_Numeric, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
340 {LANG_ARABIC, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
341 MS_MAKE_TAG('a','r','a','b'),
342 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
343 {{Script_Hebrew, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
344 {LANG_HEBREW, 0, 1, 0, 1, HEBREW_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
345 MS_MAKE_TAG('h','e','b','r'),
346 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
347 {{Script_Syriac, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
348 {LANG_SYRIAC, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 1, 0},
349 MS_MAKE_TAG('s','y','r','c'),
350 {'E','s','t','r','a','n','g','e','l','o',' ','E','d','e','s','s','a',0}},
351 {{Script_Persian, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
352 {LANG_PERSIAN, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
353 MS_MAKE_TAG('s','y','r','c'),
354 {'E','s','t','r','a','n','g','e','l','o',' ','E','d','e','s','s','a',0}},
355 {{Script_Thaana, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
356 {LANG_DIVEHI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
357 MS_MAKE_TAG('t','h','a','a'),
358 {'M','V',' ','B','o','l','i',0}},
359 {{Script_Greek, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
360 {LANG_GREEK, 0, 0, 0, 0, GREEK_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
361 MS_MAKE_TAG('g','r','e','k'),
362 {0}},
363 {{Script_Cyrillic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
364 {LANG_RUSSIAN, 0, 0, 0, 0, RUSSIAN_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
365 MS_MAKE_TAG('c','y','r','l'),
366 {0}},
367 {{Script_Armenian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
368 {LANG_ARMENIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
369 MS_MAKE_TAG('a','r','m','n'),
370 {'S','y','l','f','a','e','n',0}},
371 {{Script_Georgian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
372 {LANG_GEORGIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
373 MS_MAKE_TAG('g','e','o','r'),
374 {'S','y','l','f','a','e','n',0}},
375 {{Script_Sinhala, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
376 {LANG_SINHALESE, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
377 MS_MAKE_TAG('s','i','n','h'),
378 {'I','s','k','o','o','l','a',' ','P','o','t','a',0}},
379 {{Script_Tibetan, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
380 {LANG_TIBETAN, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0},
381 MS_MAKE_TAG('t','i','b','t'),
382 {'M','i','c','r','o','s','o','f','t',' ','H','i','m','a','l','a','y','a',0}},
383 {{Script_Tibetan_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
384 {LANG_TIBETAN, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
385 MS_MAKE_TAG('t','i','b','t'),
386 {'M','i','c','r','o','s','o','f','t',' ','H','i','m','a','l','a','y','a',0}},
387 {{Script_Phags_pa, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
388 {LANG_MONGOLIAN, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
389 MS_MAKE_TAG('p','h','a','g'),
390 {'M','i','c','r','o','s','o','f','t',' ','P','h','a','g','s','P','a',0}},
391 {{Script_Thai, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
392 {LANG_THAI, 0, 1, 1, 1, THAI_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 1},
393 MS_MAKE_TAG('t','h','a','i'),
394 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
395 {{Script_Thai_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
396 {LANG_THAI, 1, 1, 0, 0, THAI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
397 MS_MAKE_TAG('t','h','a','i'),
398 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
399 {{Script_Lao, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
400 {LANG_LAO, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0},
401 MS_MAKE_TAG('l','a','o',' '),
402 {'D','o','k','C','h','a','m','p','a',0}},
403 {{Script_Lao_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
404 {LANG_LAO, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
405 MS_MAKE_TAG('l','a','o',' '),
406 {'D','o','k','C','h','a','m','p','a',0}},
407 {{Script_Devanagari, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
408 {LANG_HINDI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
409 MS_MAKE_TAG('d','e','v','a'),
410 {'M','a','n','g','a','l',0}},
411 {{Script_Devanagari_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
412 {LANG_HINDI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
413 MS_MAKE_TAG('d','e','v','a'),
414 {'M','a','n','g','a','l',0}},
415 {{Script_Bengali, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
416 {LANG_BENGALI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
417 MS_MAKE_TAG('b','e','n','g'),
418 {'V','r','i','n','d','a',0}},
419 {{Script_Bengali_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
420 {LANG_BENGALI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
421 MS_MAKE_TAG('b','e','n','g'),
422 {'V','r','i','n','d','a',0}},
423 {{Script_Bengali_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
424 {LANG_BENGALI, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
425 MS_MAKE_TAG('b','e','n','g'),
426 {'V','r','i','n','d','a',0}},
427 {{Script_Gurmukhi, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
428 {LANG_PUNJABI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
429 MS_MAKE_TAG('g','u','r','u'),
430 {'R','a','a','v','i',0}},
431 {{Script_Gurmukhi_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
432 {LANG_PUNJABI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
433 MS_MAKE_TAG('g','u','r','u'),
434 {'R','a','a','v','i',0}},
435 {{Script_Gujarati, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
436 {LANG_GUJARATI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
437 MS_MAKE_TAG('g','u','j','r'),
438 {'S','h','r','u','t','i',0}},
439 {{Script_Gujarati_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
440 {LANG_GUJARATI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
441 MS_MAKE_TAG('g','u','j','r'),
442 {'S','h','r','u','t','i',0}},
443 {{Script_Gujarati_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
444 {LANG_GUJARATI, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
445 MS_MAKE_TAG('g','u','j','r'),
446 {'S','h','r','u','t','i',0}},
447 {{Script_Oriya, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
448 {LANG_ORIYA, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
449 MS_MAKE_TAG('o','r','y','a'),
450 {'K','a','l','i','n','g','a',0}},
451 {{Script_Oriya_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
452 {LANG_ORIYA, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
453 MS_MAKE_TAG('o','r','y','a'),
454 {'K','a','l','i','n','g','a',0}},
455 {{Script_Tamil, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
456 {LANG_TAMIL, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
457 MS_MAKE_TAG('t','a','m','l'),
458 {'L','a','t','h','a',0}},
459 {{Script_Tamil_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
460 {LANG_TAMIL, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
461 MS_MAKE_TAG('t','a','m','l'),
462 {'L','a','t','h','a',0}},
463 {{Script_Telugu, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
464 {LANG_TELUGU, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
465 MS_MAKE_TAG('t','e','l','u'),
466 {'G','a','u','t','a','m','i',0}},
467 {{Script_Telugu_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
468 {LANG_TELUGU, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
469 MS_MAKE_TAG('t','e','l','u'),
470 {'G','a','u','t','a','m','i',0}},
471 {{Script_Kannada, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
472 {LANG_KANNADA, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
473 MS_MAKE_TAG('k','n','d','a'),
474 {'T','u','n','g','a',0}},
475 {{Script_Kannada_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
476 {LANG_KANNADA, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
477 MS_MAKE_TAG('k','n','d','a'),
478 {'T','u','n','g','a',0}},
479 {{Script_Malayalam, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
480 {LANG_MALAYALAM, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
481 MS_MAKE_TAG('m','l','y','m'),
482 {'K','a','r','t','i','k','a',0}},
483 {{Script_Malayalam_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
484 {LANG_MALAYALAM, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
485 MS_MAKE_TAG('m','l','y','m'),
486 {'K','a','r','t','i','k','a',0}},
487 {{Script_Diacritical, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
488 {LANG_ENGLISH, 0, 1, 0, 1, ANSI_CHARSET, 0, 0, 0, 0, 0, 1, 1, 0, 0},
489 0x00000000,
490 {0}},
491 {{Script_Punctuation2, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
492 {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
493 MS_MAKE_TAG('l','a','t','n'),
494 {0}},
495 {{Script_Numeric2, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
496 {LANG_ENGLISH, 1, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
497 0x00000000,
498 {0}},
499 {{Script_Myanmar, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
500 {0x55, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
501 MS_MAKE_TAG('m','y','m','r'),
502 {0}},
503 {{Script_Myanmar_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
504 {0x55, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
505 MS_MAKE_TAG('m','y','m','r'),
506 {0}},
507 {{Script_Tai_Le, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
508 {0, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
509 MS_MAKE_TAG('t','a','l','e'),
510 {'M','i','c','r','o','s','o','f','t',' ','T','a','i',' ','L','e'}},
511 {{Script_New_Tai_Lue, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
512 {0, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
513 MS_MAKE_TAG('t','a','l','u'),
514 {'M','i','c','r','o','s','o','f','t',' ','N','e','w',' ','T','a','i',' ','L','u','e'}},
515 {{Script_New_Tai_Lue_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
516 {0, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
517 MS_MAKE_TAG('t','a','l','u'),
518 {'M','i','c','r','o','s','o','f','t',' ','N','e','w',' ','T','a','i',' ','L','u','e'}},
519 {{Script_Khmer, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
520 {0x53, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
521 MS_MAKE_TAG('k','h','m','r'),
522 {'D','a','u','n','P','e','n','h'}},
523 {{Script_Khmer, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
524 {0x53, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
525 MS_MAKE_TAG('k','h','m','r'),
526 {'D','a','u','n','P','e','n','h'}},
527 {{Script_CJK_Han, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
528 {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
529 MS_MAKE_TAG('h','a','n','i'),
530 {0}},
531 {{Script_Ideograph, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
532 {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
533 MS_MAKE_TAG('h','a','n','i'),
534 {0}},
535 {{Script_Bopomofo, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
536 {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
537 MS_MAKE_TAG('b','o','p','o'),
538 {0}},
539 {{Script_Kana, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
540 {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
541 MS_MAKE_TAG('k','a','n','a'),
542 {0}},
543 {{Script_Hangul, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
544 {LANG_KOREAN, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
545 MS_MAKE_TAG('h','a','n','g'),
546 {0}},
547 {{Script_Yi, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
548 {LANG_ENGLISH, 0, 0, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
549 MS_MAKE_TAG('y','i',' ',' '),
550 {'M','i','c','r','o','s','o','f','t',' ','Y','i',' ','B','a','i','t','i'}},
551 {{Script_Ethiopic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
552 {0x5e, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
553 MS_MAKE_TAG('e','t','h','i'),
554 {'N','y','a','l','a'}},
555 {{Script_Ethiopic_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
556 {0x5e, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
557 MS_MAKE_TAG('e','t','h','i'),
558 {'N','y','a','l','a'}},
559 {{Script_Mongolian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
560 {LANG_MONGOLIAN, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
561 MS_MAKE_TAG('m','o','n','g'),
562 {'M','o','n','g','o','l','i','a','n',' ','B','a','i','t','i'}},
563 {{Script_Mongolian_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
564 {LANG_MONGOLIAN, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
565 MS_MAKE_TAG('m','o','n','g'),
566 {'M','o','n','g','o','l','i','a','n',' ','B','a','i','t','i'}},
567 {{Script_Tifinagh, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
568 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
569 MS_MAKE_TAG('t','f','n','g'),
570 {'E','b','r','i','m','a'}},
571 {{Script_NKo, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
572 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
573 MS_MAKE_TAG('n','k','o',' '),
574 {'E','b','r','i','m','a'}},
575 {{Script_Vai, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
576 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
577 MS_MAKE_TAG('v','a','i',' '),
578 {'E','b','r','i','m','a'}},
579 {{Script_Vai_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
580 {0, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
581 MS_MAKE_TAG('v','a','i',' '),
582 {'E','b','r','i','m','a'}},
583 {{Script_Cherokee, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
584 {0x5c, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
585 MS_MAKE_TAG('c','h','e','r'),
586 {'P','l','a','n','t','a','g','e','n','e','t',' ','C','h','e','r','o','k','e','e'}},
587 {{Script_Canadian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
588 {0x5d, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
589 MS_MAKE_TAG('c','a','n','s'),
590 {'E','u','p','h','e','m','i','a'}},
591 {{Script_Ogham, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
592 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
593 MS_MAKE_TAG('o','g','a','m'),
594 {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
595 {{Script_Runic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
596 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
597 MS_MAKE_TAG('r','u','n','r'),
598 {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
599 {{Script_Braille, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
600 {LANG_ENGLISH, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
601 MS_MAKE_TAG('b','r','a','i'),
602 {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
603 {{Script_Surrogates, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
604 {LANG_ENGLISH, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
605 0x00000000,
606 {0}},
607 {{Script_Private, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
608 {0, 0, 0, 0, 0, DEFAULT_CHARSET, 0, 1, 0, 0, 0, 0, 1, 0, 0},
609 0x00000000,
610 {0}},
611 {{Script_Deseret, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
612 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
613 MS_MAKE_TAG('d','s','r','t'),
614 {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
615 {{Script_Osmanya, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
616 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
617 MS_MAKE_TAG('o','s','m','a'),
618 {'E','b','r','i','m','a'}},
619 {{Script_Osmanya_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
620 {0, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
621 MS_MAKE_TAG('o','s','m','a'),
622 {'E','b','r','i','m','a'}},
623 {{Script_MathAlpha, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
624 {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
625 MS_MAKE_TAG('m','a','t','h'),
626 {'C','a','m','b','r','i','a',' ','M','a','t','h'}},
627 };
628
629 static const SCRIPT_PROPERTIES *script_props[] =
630 {
631 &scriptInformation[0].props, &scriptInformation[1].props,
632 &scriptInformation[2].props, &scriptInformation[3].props,
633 &scriptInformation[4].props, &scriptInformation[5].props,
634 &scriptInformation[6].props, &scriptInformation[7].props,
635 &scriptInformation[8].props, &scriptInformation[9].props,
636 &scriptInformation[10].props, &scriptInformation[11].props,
637 &scriptInformation[12].props, &scriptInformation[13].props,
638 &scriptInformation[14].props, &scriptInformation[15].props,
639 &scriptInformation[16].props, &scriptInformation[17].props,
640 &scriptInformation[18].props, &scriptInformation[19].props,
641 &scriptInformation[20].props, &scriptInformation[21].props,
642 &scriptInformation[22].props, &scriptInformation[23].props,
643 &scriptInformation[24].props, &scriptInformation[25].props,
644 &scriptInformation[26].props, &scriptInformation[27].props,
645 &scriptInformation[28].props, &scriptInformation[29].props,
646 &scriptInformation[30].props, &scriptInformation[31].props,
647 &scriptInformation[32].props, &scriptInformation[33].props,
648 &scriptInformation[34].props, &scriptInformation[35].props,
649 &scriptInformation[36].props, &scriptInformation[37].props,
650 &scriptInformation[38].props, &scriptInformation[39].props,
651 &scriptInformation[40].props, &scriptInformation[41].props,
652 &scriptInformation[42].props, &scriptInformation[43].props,
653 &scriptInformation[44].props, &scriptInformation[45].props,
654 &scriptInformation[46].props, &scriptInformation[47].props,
655 &scriptInformation[48].props, &scriptInformation[49].props,
656 &scriptInformation[50].props, &scriptInformation[51].props,
657 &scriptInformation[52].props, &scriptInformation[53].props,
658 &scriptInformation[54].props, &scriptInformation[55].props,
659 &scriptInformation[56].props, &scriptInformation[57].props,
660 &scriptInformation[58].props, &scriptInformation[59].props,
661 &scriptInformation[60].props, &scriptInformation[61].props,
662 &scriptInformation[62].props, &scriptInformation[63].props,
663 &scriptInformation[64].props, &scriptInformation[65].props,
664 &scriptInformation[66].props, &scriptInformation[67].props,
665 &scriptInformation[68].props, &scriptInformation[69].props,
666 &scriptInformation[70].props, &scriptInformation[71].props,
667 &scriptInformation[72].props, &scriptInformation[73].props,
668 &scriptInformation[74].props, &scriptInformation[75].props,
669 &scriptInformation[76].props, &scriptInformation[77].props,
670 &scriptInformation[78].props
671 };
672
673 typedef struct {
674 ScriptCache *sc;
675 int numGlyphs;
676 WORD* glyphs;
677 WORD* pwLogClust;
678 int* piAdvance;
679 SCRIPT_VISATTR* psva;
680 GOFFSET* pGoffset;
681 ABC* abc;
682 int iMaxPosX;
683 HFONT fallbackFont;
684 } StringGlyphs;
685
686 typedef struct {
687 HDC hdc;
688 DWORD dwFlags;
689 BOOL invalid;
690 int clip_len;
691 int cItems;
692 int cMaxGlyphs;
693 SCRIPT_ITEM* pItem;
694 int numItems;
695 StringGlyphs* glyphs;
696 SCRIPT_LOGATTR* logattrs;
697 SIZE* sz;
698 int* logical2visual;
699 } StringAnalysis;
700
701 static inline void *heap_alloc(SIZE_T size)
702 {
703 return HeapAlloc(GetProcessHeap(), 0, size);
704 }
705
706 static inline void *heap_alloc_zero(SIZE_T size)
707 {
708 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
709 }
710
711 static inline void *heap_realloc_zero(LPVOID mem, SIZE_T size)
712 {
713 return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
714 }
715
716 static inline BOOL heap_free(LPVOID mem)
717 {
718 return HeapFree(GetProcessHeap(), 0, mem);
719 }
720
721 static inline WCHAR get_cache_default_char(SCRIPT_CACHE *psc)
722 {
723 return ((ScriptCache *)*psc)->tm.tmDefaultChar;
724 }
725
726 static inline LONG get_cache_height(SCRIPT_CACHE *psc)
727 {
728 return ((ScriptCache *)*psc)->tm.tmHeight;
729 }
730
731 static inline BYTE get_cache_pitch_family(SCRIPT_CACHE *psc)
732 {
733 return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
734 }
735
736 static inline WORD get_cache_glyph(SCRIPT_CACHE *psc, DWORD c)
737 {
738 WORD *block = ((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
739
740 if (!block) return 0;
741 return block[c & GLYPH_BLOCK_MASK];
742 }
743
744 static inline WORD set_cache_glyph(SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
745 {
746 WORD **block = &((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
747
748 if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
749 return ((*block)[c & GLYPH_BLOCK_MASK] = glyph);
750 }
751
752 static inline BOOL get_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
753 {
754 static const ABC nil;
755 ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
756
757 if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
758 memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
759 return TRUE;
760 }
761
762 static inline BOOL set_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
763 {
764 ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
765
766 if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
767 memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
768 return TRUE;
769 }
770
771 static HRESULT init_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
772 {
773 ScriptCache *sc;
774
775 if (!psc) return E_INVALIDARG;
776 if (*psc) return S_OK;
777 if (!hdc) return E_PENDING;
778
779 if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
780 if (!GetTextMetricsW(hdc, &sc->tm))
781 {
782 heap_free(sc);
783 return E_INVALIDARG;
784 }
785 if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(LOGFONTW), &sc->lf))
786 {
787 heap_free(sc);
788 return E_INVALIDARG;
789 }
790 sc->sfnt = (GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, NULL, 0)!=GDI_ERROR);
791 *psc = sc;
792 TRACE("<- %p\n", sc);
793 return S_OK;
794 }
795
796 static WCHAR mirror_char( WCHAR ch )
797 {
798 extern const WCHAR wine_mirror_map[];
799 return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
800 }
801
802 static inline DWORD decode_surrogate_pair(LPCWSTR str, INT index, INT end)
803 {
804 if (index < end-1 && IS_SURROGATE_PAIR(str[index],str[index+1]))
805 {
806 DWORD ch = 0x10000 + ((str[index] - 0xd800) << 10) + (str[index+1] - 0xdc00);
807 TRACE("Surrogate Pair %x %x => %x\n",str[index], str[index+1], ch);
808 return ch;
809 }
810 return 0;
811 }
812
813 static WORD get_char_script( LPCWSTR str, INT index, INT end, INT *consumed)
814 {
815 static const WCHAR latin_punc[] = {'#','$','&','\'',',',';','<','>','?','@','\\','^','_','`','{','|','}','~', 0x00a0, 0};
816 WORD type = 0;
817 DWORD ch;
818 int i;
819
820 *consumed = 1;
821
822 if (str[index] == 0xc || str[index] == 0x20 || str[index] == 0x202f)
823 return Script_CR;
824
825 /* These punctuation are separated out as Latin punctuation */
826 if (strchrW(latin_punc,str[index]))
827 return Script_Punctuation2;
828
829 /* These chars are itemized as Punctuation by Windows */
830 if (str[index] == 0x2212 || str[index] == 0x2044)
831 return Script_Punctuation;
832
833 GetStringTypeW(CT_CTYPE1, &str[index], 1, &type);
834
835 if (type == 0)
836 return SCRIPT_UNDEFINED;
837
838 if (type & C1_CNTRL)
839 return Script_Control;
840
841 ch = decode_surrogate_pair(str, index, end);
842 if (ch)
843 *consumed = 2;
844 else
845 ch = str[index];
846
847 i = 0;
848 do
849 {
850 if (ch < scriptRanges[i].rangeFirst || scriptRanges[i].script == SCRIPT_UNDEFINED)
851 break;
852
853 if (ch >= scriptRanges[i].rangeFirst && ch <= scriptRanges[i].rangeLast)
854 {
855 if (scriptRanges[i].numericScript && type & C1_DIGIT)
856 return scriptRanges[i].numericScript;
857 if (scriptRanges[i].punctScript && type & C1_PUNCT)
858 return scriptRanges[i].punctScript;
859 return scriptRanges[i].script;
860 }
861 i++;
862 } while (1);
863
864 return SCRIPT_UNDEFINED;
865 }
866
867 /***********************************************************************
868 * DllMain
869 *
870 */
871 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
872 {
873 switch(fdwReason)
874 {
875 case DLL_PROCESS_ATTACH:
876 DisableThreadLibraryCalls(hInstDLL);
877 break;
878 case DLL_PROCESS_DETACH:
879 break;
880 }
881 return TRUE;
882 }
883
884 /***********************************************************************
885 * ScriptFreeCache (USP10.@)
886 *
887 * Free a script cache.
888 *
889 * PARAMS
890 * psc [I/O] Script cache.
891 *
892 * RETURNS
893 * Success: S_OK
894 * Failure: Non-zero HRESULT value.
895 */
896 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
897 {
898 TRACE("%p\n", psc);
899
900 if (psc && *psc)
901 {
902 unsigned int i;
903 for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
904 {
905 heap_free(((ScriptCache *)*psc)->glyphs[i]);
906 heap_free(((ScriptCache *)*psc)->widths[i]);
907 }
908 heap_free(((ScriptCache *)*psc)->GSUB_Table);
909 heap_free(((ScriptCache *)*psc)->GDEF_Table);
910 heap_free(((ScriptCache *)*psc)->CMAP_Table);
911 heap_free(((ScriptCache *)*psc)->features);
912 heap_free(*psc);
913 *psc = NULL;
914 }
915 return S_OK;
916 }
917
918 /***********************************************************************
919 * ScriptGetProperties (USP10.@)
920 *
921 * Retrieve a list of script properties.
922 *
923 * PARAMS
924 * props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
925 * num [I] Pointer to the number of scripts.
926 *
927 * RETURNS
928 * Success: S_OK
929 * Failure: Non-zero HRESULT value.
930 *
931 * NOTES
932 * Behaviour matches WinXP.
933 */
934 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
935 {
936 TRACE("(%p,%p)\n", props, num);
937
938 if (!props && !num) return E_INVALIDARG;
939
940 if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
941 if (props) *props = script_props;
942
943 return S_OK;
944 }
945
946 /***********************************************************************
947 * ScriptGetFontProperties (USP10.@)
948 *
949 * Get information on special glyphs.
950 *
951 * PARAMS
952 * hdc [I] Device context.
953 * psc [I/O] Opaque pointer to a script cache.
954 * sfp [O] Font properties structure.
955 */
956 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
957 {
958 HRESULT hr;
959
960 TRACE("%p,%p,%p\n", hdc, psc, sfp);
961
962 if (!sfp) return E_INVALIDARG;
963 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
964
965 if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
966 return E_INVALIDARG;
967
968 /* return something sensible? */
969 sfp->wgBlank = 0;
970 sfp->wgDefault = get_cache_default_char(psc);
971 sfp->wgInvalid = 0;
972 sfp->wgKashida = 0xffff;
973 sfp->iKashidaWidth = 0;
974
975 return S_OK;
976 }
977
978 /***********************************************************************
979 * ScriptRecordDigitSubstitution (USP10.@)
980 *
981 * Record digit substitution settings for a given locale.
982 *
983 * PARAMS
984 * locale [I] Locale identifier.
985 * sds [I] Structure to record substitution settings.
986 *
987 * RETURNS
988 * Success: S_OK
989 * Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
990 *
991 * SEE ALSO
992 * http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
993 */
994 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
995 {
996 DWORD plgid, sub;
997
998 TRACE("0x%x, %p\n", locale, sds);
999
1000 /* This implementation appears to be correct for all languages, but it's
1001 * not clear if sds->DigitSubstitute is ever set to anything except
1002 * CONTEXT or NONE in reality */
1003
1004 if (!sds) return E_POINTER;
1005
1006 locale = ConvertDefaultLocale(locale);
1007
1008 if (!IsValidLocale(locale, LCID_INSTALLED))
1009 return E_INVALIDARG;
1010
1011 plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
1012 sds->TraditionalDigitLanguage = plgid;
1013
1014 if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
1015 sds->NationalDigitLanguage = plgid;
1016 else
1017 sds->NationalDigitLanguage = LANG_ENGLISH;
1018
1019 if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
1020 (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
1021
1022 switch (sub)
1023 {
1024 case 0:
1025 if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
1026 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
1027 else
1028 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
1029 break;
1030 case 1:
1031 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
1032 break;
1033 case 2:
1034 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
1035 break;
1036 default:
1037 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
1038 break;
1039 }
1040
1041 sds->dwReserved = 0;
1042 return S_OK;
1043 }
1044
1045 /***********************************************************************
1046 * ScriptApplyDigitSubstitution (USP10.@)
1047 *
1048 * Apply digit substitution settings.
1049 *
1050 * PARAMS
1051 * sds [I] Structure with recorded substitution settings.
1052 * sc [I] Script control structure.
1053 * ss [I] Script state structure.
1054 *
1055 * RETURNS
1056 * Success: S_OK
1057 * Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
1058 */
1059 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds,
1060 SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
1061 {
1062 SCRIPT_DIGITSUBSTITUTE psds;
1063
1064 TRACE("%p, %p, %p\n", sds, sc, ss);
1065
1066 if (!sc || !ss) return E_POINTER;
1067 if (!sds)
1068 {
1069 sds = &psds;
1070 if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
1071 return E_INVALIDARG;
1072 }
1073
1074 sc->uDefaultLanguage = LANG_ENGLISH;
1075 sc->fContextDigits = 0;
1076 ss->fDigitSubstitute = 0;
1077
1078 switch (sds->DigitSubstitute) {
1079 case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
1080 case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
1081 case SCRIPT_DIGITSUBSTITUTE_NONE:
1082 case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
1083 return S_OK;
1084 default:
1085 return E_INVALIDARG;
1086 }
1087 }
1088
1089 static inline BOOL is_indic(WORD script)
1090 {
1091 return (script >= Script_Devanagari && script <= Script_Malayalam_Numeric);
1092 }
1093
1094 static inline WORD base_indic(WORD script)
1095 {
1096 switch (script)
1097 {
1098 case Script_Devanagari:
1099 case Script_Devanagari_Numeric: return Script_Devanagari;
1100 case Script_Bengali:
1101 case Script_Bengali_Numeric:
1102 case Script_Bengali_Currency: return Script_Bengali;
1103 case Script_Gurmukhi:
1104 case Script_Gurmukhi_Numeric: return Script_Gurmukhi;
1105 case Script_Gujarati:
1106 case Script_Gujarati_Numeric:
1107 case Script_Gujarati_Currency: return Script_Gujarati;
1108 case Script_Oriya:
1109 case Script_Oriya_Numeric: return Script_Oriya;
1110 case Script_Tamil:
1111 case Script_Tamil_Numeric: return Script_Tamil;
1112 case Script_Telugu:
1113 case Script_Telugu_Numeric: return Script_Telugu;
1114 case Script_Kannada:
1115 case Script_Kannada_Numeric: return Script_Kannada;
1116 case Script_Malayalam:
1117 case Script_Malayalam_Numeric: return Script_Malayalam;
1118 default:
1119 return -1;
1120 };
1121 }
1122
1123 /***********************************************************************
1124 * ScriptItemizeOpenType (USP10.@)
1125 *
1126 * Split a Unicode string into shapeable parts.
1127 *
1128 * PARAMS
1129 * pwcInChars [I] String to split.
1130 * cInChars [I] Number of characters in pwcInChars.
1131 * cMaxItems [I] Maximum number of items to return.
1132 * psControl [I] Pointer to a SCRIPT_CONTROL structure.
1133 * psState [I] Pointer to a SCRIPT_STATE structure.
1134 * pItems [O] Buffer to receive SCRIPT_ITEM structures.
1135 * pScriptTags [O] Buffer to receive OPENTYPE_TAGs.
1136 * pcItems [O] Number of script items returned.
1137 *
1138 * RETURNS
1139 * Success: S_OK
1140 * Failure: Non-zero HRESULT value.
1141 */
1142 HRESULT WINAPI ScriptItemizeOpenType(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
1143 const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
1144 SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
1145 {
1146
1147 #define Numeric_space 0x0020
1148 #define ZWNJ 0x200C
1149 #define ZWJ 0x200D
1150
1151 int cnt = 0, index = 0, str = 0;
1152 int New_Script = -1;
1153 int i;
1154 WORD *levels = NULL;
1155 WORD *strength = NULL;
1156 WORD *scripts = NULL;
1157 WORD baselevel = 0;
1158 BOOL new_run;
1159 WORD last_indic = -1;
1160 WORD layoutRTL = 0;
1161 BOOL forceLevels = FALSE;
1162 INT consumed = 0;
1163
1164 TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems,
1165 psControl, psState, pItems, pcItems);
1166
1167 if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
1168 return E_INVALIDARG;
1169
1170 scripts = heap_alloc(cInChars * sizeof(WORD));
1171 if (!scripts)
1172 return E_OUTOFMEMORY;
1173
1174 for (i = 0; i < cInChars; i++)
1175 {
1176 if (consumed <= 0)
1177 {
1178 scripts[i] = get_char_script(pwcInChars,i,cInChars,&consumed);
1179 consumed --;
1180 }
1181 else
1182 {
1183 scripts[i] = scripts[i-1];
1184 consumed --;
1185 }
1186 /* Devanagari danda (U+0964) and double danda (U+0965) are used for
1187 all Indic scripts */
1188 if ((pwcInChars[i] == 0x964 || pwcInChars[i] ==0x965) && last_indic > 0)
1189 scripts[i] = last_indic;
1190 else if (is_indic(scripts[i]))
1191 last_indic = base_indic(scripts[i]);
1192
1193 /* Some unicode points (Zero Width Space U+200B -
1194 Right-to-Left Mark U+200F) will force us into bidi mode */
1195 if (!forceLevels && pwcInChars[i] >= 0x200B && pwcInChars[i] <= 0x200F)
1196 forceLevels = TRUE;
1197
1198 /* Diacritical marks merge with other scripts */
1199 if (scripts[i] == Script_Diacritical && i > 0)
1200 scripts[i] = scripts[i-1];
1201 }
1202
1203 for (i = 0; i < cInChars; i++)
1204 {
1205 /* Joiners get merged preferencially right */
1206 if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ))
1207 {
1208 int j;
1209 if (i+1 == cInChars)
1210 scripts[i] = scripts[i-1];
1211 else
1212 {
1213 for (j = i+1; j < cInChars; j++)
1214 {
1215 if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ && pwcInChars[j] != Numeric_space)
1216 {
1217 scripts[i] = scripts[j];
1218 break;
1219 }
1220 }
1221 }
1222 }
1223 }
1224
1225 if (psState && psControl)
1226 {
1227 levels = heap_alloc_zero(cInChars * sizeof(WORD));
1228 if (!levels)
1229 {
1230 heap_free(scripts);
1231 return E_OUTOFMEMORY;
1232 }
1233
1234 BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels);
1235 baselevel = levels[0];
1236 for (i = 0; i < cInChars; i++)
1237 if (levels[i]!=levels[0])
1238 break;
1239 if (i >= cInChars && !odd(baselevel) && !odd(psState->uBidiLevel) && !forceLevels)
1240 {
1241 heap_free(levels);
1242 levels = NULL;
1243 }
1244 else
1245 {
1246 BOOL inNumber = FALSE;
1247 static WCHAR math_punc[] = {'#','$','%','+',',','-','.','/',':',0x2212, 0x2044, 0x00a0,0};
1248
1249 strength = heap_alloc_zero(cInChars * sizeof(WORD));
1250 if (!strength)
1251 {
1252 heap_free(scripts);
1253 heap_free(levels);
1254 return E_OUTOFMEMORY;
1255 }
1256 BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
1257
1258 /* We currently mis-level leading Diacriticals */
1259 if (scripts[0] == Script_Diacritical)
1260 for (i = 0; i < cInChars && scripts[0] == Script_Diacritical; i++)
1261 {
1262 levels[i] = odd(levels[i])?levels[i]+1:levels[i];
1263 strength[i] = BIDI_STRONG;
1264 }
1265
1266 for (i = 0; i < cInChars; i++)
1267 {
1268 /* Script_Numeric and select puncuation at level 0 get bumped to level 2 */
1269 if ((levels[i] == 0 || (odd(psState->uBidiLevel) && levels[i] == psState->uBidiLevel+1)) && inNumber && strchrW(math_punc,pwcInChars[i]))
1270 {
1271 scripts[i] = Script_Numeric;
1272 levels[i] = 2;
1273 }
1274 else if ((levels[i] == 0 || (odd(psState->uBidiLevel) && levels[i] == psState->uBidiLevel+1)) && scripts[i] == Script_Numeric)
1275 {
1276 levels[i] = 2;
1277 inNumber = TRUE;
1278 }
1279 else
1280 inNumber = FALSE;
1281
1282 /* Joiners get merged preferencially right */
1283 if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ))
1284 {
1285 int j;
1286 if (i+1 == cInChars && levels[i-1] == levels[i])
1287 strength[i] = strength[i-1];
1288 else
1289 for (j = i+1; j < cInChars && levels[i] == levels[j]; j++)
1290 if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ && pwcInChars[j] != Numeric_space)
1291 {
1292 strength[i] = strength[j];
1293 break;
1294 }
1295 }
1296 }
1297 if (psControl->fMergeNeutralItems)
1298 {
1299 /* Merge the neutrals */
1300 for (i = 0; i < cInChars; i++)
1301 {
1302 if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
1303 {
1304 int j;
1305 for (j = i; j > 0; j--)
1306 {
1307 if (levels[i] != levels[j])
1308 break;
1309 if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
1310 {
1311 scripts[i] = scripts[j];
1312 strength[i] = strength[j];
1313 break;
1314 }
1315 }
1316 }
1317 /* Try going the other way */
1318 if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
1319 {
1320 int j;
1321 for (j = i; j < cInChars; j++)
1322 {
1323 if (levels[i] != levels[j])
1324 break;
1325 if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
1326 {
1327 scripts[i] = scripts[j];
1328 strength[i] = strength[j];
1329 break;
1330 }
1331 }
1332 }
1333 }
1334 }
1335 }
1336 }
1337
1338 while ((!levels || (levels && levels[cnt+1] == levels[0])) && (pwcInChars[cnt] == Numeric_space) && cnt < cInChars)
1339 cnt++;
1340
1341 if (cnt == cInChars) /* All Spaces */
1342 {
1343 cnt = 0;
1344 New_Script = scripts[cnt];
1345 }
1346
1347 pItems[index].iCharPos = 0;
1348 pItems[index].a = scriptInformation[scripts[cnt]].a;
1349 pScriptTags[index] = scriptInformation[scripts[cnt]].scriptTag;
1350
1351 if (strength && strength[cnt] == BIDI_STRONG)
1352 str = strength[cnt];
1353 else if (strength)
1354 str = strength[0];
1355
1356 cnt = 0;
1357
1358 if (levels)
1359 {
1360 if (strength[cnt] == BIDI_STRONG)
1361 layoutRTL = (odd(levels[cnt]))?1:0;
1362 else
1363 layoutRTL = (psState->uBidiLevel || odd(levels[cnt]))?1:0;
1364 pItems[index].a.fRTL = odd(levels[cnt]);
1365 pItems[index].a.fLayoutRTL = layoutRTL;
1366 pItems[index].a.s.uBidiLevel = levels[cnt];
1367 }
1368 else if (!pItems[index].a.s.uBidiLevel)
1369 {
1370 layoutRTL = (odd(baselevel))?1:0;
1371 pItems[index].a.s.uBidiLevel = baselevel;
1372 pItems[index].a.fLayoutRTL = odd(baselevel);
1373 pItems[index].a.fRTL = odd(baselevel);
1374 }
1375
1376 TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
1377 levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
1378 pItems[index].iCharPos);
1379
1380 for (cnt=1; cnt < cInChars; cnt++)
1381 {
1382 if(pwcInChars[cnt] != Numeric_space)
1383 New_Script = scripts[cnt];
1384 else if (levels)
1385 {
1386 int j = 1;
1387 while (cnt + j < cInChars - 1 && pwcInChars[cnt+j] == Numeric_space && levels[cnt] == levels[cnt+j])
1388 j++;
1389 if (cnt + j < cInChars && levels[cnt] == levels[cnt+j])
1390 New_Script = scripts[cnt+j];
1391 else
1392 New_Script = scripts[cnt];
1393 }
1394
1395 new_run = FALSE;
1396 /* merge space strengths*/
1397 if (strength && strength[cnt] == BIDI_STRONG && str != BIDI_STRONG && New_Script == pItems[index].a.eScript)
1398 str = BIDI_STRONG;
1399
1400 if (strength && strength[cnt] == BIDI_NEUTRAL && str == BIDI_STRONG && pwcInChars[cnt] != Numeric_space && New_Script == pItems[index].a.eScript)
1401 str = BIDI_NEUTRAL;
1402
1403 /* changes in level */
1404 if (levels && (levels[cnt] != pItems[index].a.s.uBidiLevel))
1405 {
1406 TRACE("Level break(%i/%i)\n",pItems[index].a.s.uBidiLevel,levels[cnt]);
1407 new_run = TRUE;
1408 }
1409 /* changes in strength */
1410 else if (strength && pwcInChars[cnt] != Numeric_space && str != strength[cnt])
1411 {
1412 TRACE("Strength break (%i/%i)\n",str,strength[cnt]);
1413 new_run = TRUE;
1414 }
1415 /* changes in script */
1416 else if (((pwcInChars[cnt] != Numeric_space) && (New_Script != -1) && (New_Script != pItems[index].a.eScript)) || (New_Script == Script_Control))
1417 {
1418 TRACE("Script break(%i/%i)\n",pItems[index].a.eScript,New_Script);
1419 new_run = TRUE;
1420 }
1421
1422 if (!new_run && strength && str == BIDI_STRONG)
1423 {
1424 layoutRTL = odd(levels[cnt])?1:0;
1425 pItems[index].a.fLayoutRTL = layoutRTL;
1426 }
1427
1428 if (new_run)
1429 {
1430 TRACE("New_Level = %i, New_Strength = %i, New_Script=%d, eScript=%d\n", levels?levels[cnt]:-1, strength?strength[cnt]:str, New_Script, pItems[index].a.eScript);
1431
1432 index++;
1433 if (index+1 > cMaxItems)
1434 return E_OUTOFMEMORY;
1435
1436 if (strength)
1437 str = strength[cnt];
1438
1439 pItems[index].iCharPos = cnt;
1440 memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
1441
1442 pItems[index].a = scriptInformation[New_Script].a;
1443 pScriptTags[index] = scriptInformation[New_Script].scriptTag;
1444 if (levels)
1445 {
1446 if (levels[cnt] == 0)
1447 layoutRTL = 0;
1448 else
1449 layoutRTL = (layoutRTL || odd(levels[cnt]))?1:0;
1450 pItems[index].a.fRTL = odd(levels[cnt]);
1451 pItems[index].a.fLayoutRTL = layoutRTL;
1452 pItems[index].a.s.uBidiLevel = levels[cnt];
1453 }
1454 else if (!pItems[index].a.s.uBidiLevel)
1455 {
1456 pItems[index].a.s.uBidiLevel = baselevel;
1457 pItems[index].a.fLayoutRTL = layoutRTL;
1458 pItems[index].a.fRTL = odd(baselevel);
1459 }
1460
1461 TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
1462 }
1463 }
1464
1465 /* While not strictly necessary according to the spec, make sure the n+1
1466 * item is set up to prevent random behaviour if the caller erroneously
1467 * checks the n+1 structure */
1468 index++;
1469 memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
1470
1471 TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
1472
1473 /* Set one SCRIPT_STATE item being returned */
1474 if (index + 1 > cMaxItems) return E_OUTOFMEMORY;
1475 if (pcItems) *pcItems = index;
1476
1477 /* Set SCRIPT_ITEM */
1478 pItems[index].iCharPos = cnt; /* the last item contains the ptr to the lastchar */
1479 heap_free(levels);
1480 heap_free(strength);
1481 heap_free(scripts);
1482 return S_OK;
1483 }
1484
1485 /***********************************************************************
1486 * ScriptItemize (USP10.@)
1487 *
1488 * Split a Unicode string into shapeable parts.
1489 *
1490 * PARAMS
1491 * pwcInChars [I] String to split.
1492 * cInChars [I] Number of characters in pwcInChars.
1493 * cMaxItems [I] Maximum number of items to return.
1494 * psControl [I] Pointer to a SCRIPT_CONTROL structure.
1495 * psState [I] Pointer to a SCRIPT_STATE structure.
1496 * pItems [O] Buffer to receive SCRIPT_ITEM structures.
1497 * pcItems [O] Number of script items returned.
1498 *
1499 * RETURNS
1500 * Success: S_OK
1501 * Failure: Non-zero HRESULT value.
1502 */
1503 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
1504 const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
1505 SCRIPT_ITEM *pItems, int *pcItems)
1506 {
1507 OPENTYPE_TAG *discarded_tags;
1508 HRESULT res;
1509
1510 discarded_tags = heap_alloc(cMaxItems * sizeof(OPENTYPE_TAG));
1511 if (!discarded_tags)
1512 return E_OUTOFMEMORY;
1513 res = ScriptItemizeOpenType(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, discarded_tags, pcItems);
1514 heap_free(discarded_tags);
1515 return res;
1516 }
1517
1518 static inline int getGivenTabWidth(ScriptCache *psc, SCRIPT_TABDEF *pTabdef, int charPos, int current_x)
1519 {
1520 int defWidth;
1521 int cTabStops=0;
1522 INT *lpTabPos = NULL;
1523 INT nTabOrg = 0;
1524 INT x = 0;
1525
1526 if (pTabdef)
1527 lpTabPos = pTabdef->pTabStops;
1528
1529 if (pTabdef && pTabdef->iTabOrigin)
1530 {
1531 if (pTabdef->iScale)
1532 nTabOrg = (pTabdef->iTabOrigin * pTabdef->iScale)/4;
1533 else
1534 nTabOrg = pTabdef->iTabOrigin * psc->tm.tmAveCharWidth;
1535 }
1536
1537 if (pTabdef)
1538 cTabStops = pTabdef->cTabStops;
1539
1540 if (cTabStops == 1)
1541 {
1542 if (pTabdef->iScale)
1543 defWidth = ((pTabdef->pTabStops[0])*pTabdef->iScale) / 4;
1544 else
1545 defWidth = (pTabdef->pTabStops[0])*psc->tm.tmAveCharWidth;
1546 cTabStops = 0;
1547 }
1548 else
1549 defWidth = 8 * psc->tm.tmAveCharWidth;
1550
1551 for (; cTabStops>0 ; lpTabPos++, cTabStops--)
1552 {
1553 int position = *lpTabPos;
1554 if (position < 0)
1555 position = -1 * position;
1556 if (pTabdef->iScale)
1557 position = (position * pTabdef->iScale) / 4;
1558 else
1559 position = position * psc->tm.tmAveCharWidth;
1560
1561 if( nTabOrg + position > current_x)
1562 {
1563 if( *lpTabPos >= 0)
1564 {
1565 /* a left aligned tab */
1566 x = (nTabOrg + *lpTabPos) - current_x;
1567 break;
1568 }
1569 else
1570 {
1571 FIXME("Negative tabstop\n");
1572 break;
1573 }
1574 }
1575 }
1576 if ((!cTabStops) && (defWidth > 0))
1577 x =((((current_x - nTabOrg) / defWidth)+1) * defWidth) - current_x;
1578 else if ((!cTabStops) && (defWidth < 0))
1579 FIXME("TODO: Negative defWidth\n");
1580
1581 return x;
1582 }
1583
1584 /***********************************************************************
1585 * Helper function for ScriptStringAnalyse
1586 */
1587 static BOOL requires_fallback(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
1588 const WCHAR *pwcInChars, int cChars )
1589 {
1590 /* FIXME: When to properly fallback is still a bit of a mystery */
1591 WORD *glyphs;
1592
1593 if (psa->fNoGlyphIndex)
1594 return FALSE;
1595
1596 if (init_script_cache(hdc, psc) != S_OK)
1597 return FALSE;
1598
1599 if (SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa) != S_OK)
1600 return TRUE;
1601
1602 glyphs = heap_alloc(sizeof(WORD) * cChars);
1603 if (!glyphs)
1604 return FALSE;
1605 if (ScriptGetCMap(hdc, psc, pwcInChars, cChars, 0, glyphs) != S_OK)
1606 {
1607 heap_free(glyphs);
1608 return TRUE;
1609 }
1610 heap_free(glyphs);
1611
1612 return FALSE;
1613 }
1614
1615 static void find_fallback_font(DWORD scriptid, LPWSTR FaceName)
1616 {
1617 HKEY hkey;
1618
1619 if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Uniscribe\\Fallback", &hkey))
1620 {
1621 static const WCHAR szFmt[] = {'%','x',0};
1622 WCHAR value[10];
1623 DWORD count = LF_FACESIZE * sizeof(WCHAR);
1624 DWORD type;
1625
1626 sprintfW(value, szFmt, scriptInformation[scriptid].scriptTag);
1627 if (RegQueryValueExW(hkey, value, 0, &type, (LPBYTE)FaceName, &count))
1628 lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
1629 RegCloseKey(hkey);
1630 }
1631 else
1632 lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
1633 }
1634
1635 /***********************************************************************
1636 * ScriptStringAnalyse (USP10.@)
1637 *
1638 */
1639 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
1640 int cGlyphs, int iCharset, DWORD dwFlags,
1641 int iReqWidth, SCRIPT_CONTROL *psControl,
1642 SCRIPT_STATE *psState, const int *piDx,
1643 SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
1644 SCRIPT_STRING_ANALYSIS *pssa)
1645 {
1646 HRESULT hr = E_OUTOFMEMORY;
1647 StringAnalysis *analysis = NULL;
1648 SCRIPT_CONTROL sControl;
1649 SCRIPT_STATE sState;
1650 int i, num_items = 255;
1651 BYTE *BidiLevel;
1652 WCHAR *iString = NULL;
1653
1654 TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
1655 hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
1656 psControl, psState, piDx, pTabdef, pbInClass, pssa);
1657
1658 if (iCharset != -1)
1659 {
1660 FIXME("Only Unicode strings are supported\n");
1661 return E_INVALIDARG;
1662 }
1663 if (cString < 1 || !pString) return E_INVALIDARG;
1664 if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
1665
1666 if (!(analysis = heap_alloc_zero(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
1667 if (!(analysis->pItem = heap_alloc_zero(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
1668
1669 /* FIXME: handle clipping */
1670 analysis->clip_len = cString;
1671 analysis->hdc = hdc;
1672 analysis->dwFlags = dwFlags;
1673
1674 if (psState)
1675 sState = *psState;
1676 else
1677 memset(&sState, 0, sizeof(SCRIPT_STATE));
1678
1679 if (psControl)
1680 sControl = *psControl;
1681 else
1682 memset(&sControl, 0, sizeof(SCRIPT_CONTROL));
1683
1684 if (dwFlags & SSA_PASSWORD)
1685 {
1686 iString = heap_alloc(sizeof(WCHAR)*cString);
1687 if (!iString)
1688 {
1689 hr = E_OUTOFMEMORY;
1690 goto error;
1691 }
1692 for (i = 0; i < cString; i++)
1693 iString[i] = *((const WCHAR *)pString);
1694 pString = iString;
1695 }
1696
1697 hr = ScriptItemize(pString, cString, num_items, &sControl, &sState, analysis->pItem,
1698 &analysis->numItems);
1699
1700 while (hr == E_OUTOFMEMORY)
1701 {
1702 SCRIPT_ITEM *tmp;
1703
1704 num_items *= 2;
1705 if (!(tmp = heap_realloc_zero(analysis->pItem, num_items * sizeof(SCRIPT_ITEM) + 1)))
1706 goto error;
1707
1708 analysis->pItem = tmp;
1709 hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
1710 &analysis->numItems);
1711 }
1712 if (hr != S_OK) goto error;
1713
1714 /* set back to out of memory for default goto error behaviour */
1715 hr = E_OUTOFMEMORY;
1716
1717 if (dwFlags & SSA_BREAK)
1718 {
1719 if ((analysis->logattrs = heap_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
1720 {
1721 for (i = 0; i < analysis->numItems; i++)
1722 ScriptBreak(&((LPWSTR)pString)[analysis->pItem[i].iCharPos], analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos, &analysis->pItem[i].a, &analysis->logattrs[analysis->pItem[i].iCharPos]);
1723 }
1724 else
1725 goto error;
1726 }
1727
1728 if (!(analysis->logical2visual = heap_alloc_zero(sizeof(int) * analysis->numItems)))
1729 goto error;
1730 if (!(BidiLevel = heap_alloc_zero(analysis->numItems)))
1731 goto error;
1732
1733 if (dwFlags & SSA_GLYPHS)
1734 {
1735 int tab_x = 0;
1736 if (!(analysis->glyphs = heap_alloc_zero(sizeof(StringGlyphs) * analysis->numItems)))
1737 {
1738 heap_free(BidiLevel);
1739 goto error;
1740 }
1741
1742 for (i = 0; i < analysis->numItems; i++)
1743 {
1744 SCRIPT_CACHE *sc = (SCRIPT_CACHE*)&analysis->glyphs[i].sc;
1745 int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1746 int numGlyphs = 1.5 * cChar + 16;
1747 WORD *glyphs = heap_alloc_zero(sizeof(WORD) * numGlyphs);
1748 WORD *pwLogClust = heap_alloc_zero(sizeof(WORD) * cChar);
1749 int *piAdvance = heap_alloc_zero(sizeof(int) * numGlyphs);
1750 SCRIPT_VISATTR *psva = heap_alloc_zero(sizeof(SCRIPT_VISATTR) * numGlyphs);
1751 GOFFSET *pGoffset = heap_alloc_zero(sizeof(GOFFSET) * numGlyphs);
1752 ABC *abc = heap_alloc_zero(sizeof(ABC));
1753 int numGlyphsReturned;
1754 HFONT originalFont = 0x0;
1755
1756 /* FIXME: non unicode strings */
1757 const WCHAR* pStr = (const WCHAR*)pString;
1758 analysis->glyphs[i].fallbackFont = NULL;
1759
1760 if (!glyphs || !pwLogClust || !piAdvance || !psva || !pGoffset || !abc)
1761 {
1762 heap_free (BidiLevel);
1763 heap_free (glyphs);
1764 heap_free (pwLogClust);
1765 heap_free (piAdvance);
1766 heap_free (psva);
1767 heap_free (pGoffset);
1768 heap_free (abc);
1769 hr = E_OUTOFMEMORY;
1770 goto error;
1771 }
1772
1773 if ((dwFlags & SSA_FALLBACK) && requires_fallback(hdc, sc, &analysis->pItem[i].a, &pStr[analysis->pItem[i].iCharPos], cChar))
1774 {
1775 LOGFONTW lf;
1776 GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), & lf);
1777 lf.lfCharSet = scriptInformation[analysis->pItem[i].a.eScript].props.bCharSet;
1778 lf.lfFaceName[0] = 0;
1779 find_fallback_font(analysis->pItem[i].a.eScript, lf.lfFaceName);
1780 if (lf.lfFaceName[0])
1781 {
1782 analysis->glyphs[i].fallbackFont = CreateFontIndirectW(&lf);
1783 if (analysis->glyphs[i].fallbackFont)
1784 {
1785 ScriptFreeCache(sc);
1786 originalFont = SelectObject(hdc, analysis->glyphs[i].fallbackFont);
1787 }
1788 }
1789 }
1790
1791 hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
1792 cChar, numGlyphs, &analysis->pItem[i].a,
1793 glyphs, pwLogClust, psva, &numGlyphsReturned);
1794 hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
1795 piAdvance, pGoffset, abc);
1796 if (originalFont)
1797 SelectObject(hdc,originalFont);
1798
1799 if (dwFlags & SSA_TAB)
1800 {
1801 int tabi = 0;
1802 for (tabi = 0; tabi < cChar; tabi++)
1803 {
1804 if (pStr[analysis->pItem[i].iCharPos+tabi] == 0x0009)
1805 piAdvance[tabi] = getGivenTabWidth(analysis->glyphs[i].sc, pTabdef, analysis->pItem[i].iCharPos+tabi, tab_x);
1806 tab_x+=piAdvance[tabi];
1807 }
1808 }
1809
1810 analysis->glyphs[i].numGlyphs = numGlyphsReturned;
1811 analysis->glyphs[i].glyphs = glyphs;
1812 analysis->glyphs[i].pwLogClust = pwLogClust;
1813 analysis->glyphs[i].piAdvance = piAdvance;
1814 analysis->glyphs[i].psva = psva;
1815 analysis->glyphs[i].pGoffset = pGoffset;
1816 analysis->glyphs[i].abc = abc;
1817 analysis->glyphs[i].iMaxPosX= -1;
1818
1819 BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1820 }
1821 }
1822 else
1823 {
1824 for (i = 0; i < analysis->numItems; i++)
1825 BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1826 }
1827
1828 ScriptLayout(analysis->numItems, BidiLevel, NULL, analysis->logical2visual);
1829 heap_free(BidiLevel);
1830
1831 *pssa = analysis;
1832 heap_free(iString);
1833 return S_OK;
1834
1835 error:
1836 heap_free(iString);
1837 heap_free(analysis->glyphs);
1838 heap_free(analysis->logattrs);
1839 heap_free(analysis->pItem);
1840 heap_free(analysis->logical2visual);
1841 heap_free(analysis);
1842 return hr;
1843 }
1844
1845 static inline BOOL does_glyph_start_cluster(const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cChars, int glyph, int direction)
1846 {
1847 int i;
1848
1849 if (pva[glyph].fClusterStart)
1850 return TRUE;
1851 for (i = 0; i < cChars; i++)
1852 if (pwLogClust[i] == glyph) break;
1853 if (i != cChars)
1854 return TRUE;
1855
1856 return FALSE;
1857 }
1858
1859
1860 static HRESULT SS_ItemOut( SCRIPT_STRING_ANALYSIS ssa,
1861 int iX,
1862 int iY,
1863 int iItem,
1864 int cStart,
1865 int cEnd,
1866 UINT uOptions,
1867 const RECT *prc,
1868 BOOL fSelected,
1869 BOOL fDisabled)
1870 {
1871 StringAnalysis *analysis;
1872 int off_x = 0;
1873 HRESULT hr;
1874 COLORREF BkColor = 0x0;
1875 COLORREF TextColor = 0x0;
1876 INT BkMode = 0;
1877 INT runStart, runEnd;
1878 INT iGlyph, cGlyphs;
1879 HFONT oldFont = 0x0;
1880
1881 TRACE("(%p,%d,%d,%d,%d,%d, 0x%1x, %d, %d)\n",
1882 ssa, iX, iY, iItem, cStart, cEnd, uOptions, fSelected, fDisabled);
1883
1884 if (!(analysis = ssa)) return E_INVALIDARG;
1885
1886 if ((cStart >= 0 && analysis->pItem[iItem+1].iCharPos <= cStart) ||
1887 (cEnd >= 0 && analysis->pItem[iItem].iCharPos >= cEnd))
1888 return S_OK;
1889
1890 if (fSelected)
1891 {
1892 BkMode = GetBkMode(analysis->hdc);
1893 SetBkMode( analysis->hdc, OPAQUE);
1894 BkColor = GetBkColor(analysis->hdc);
1895 SetBkColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHT));
1896 if (!fDisabled)
1897 {
1898 TextColor = GetTextColor(analysis->hdc);
1899 SetTextColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1900 }
1901 }
1902 if (analysis->glyphs[iItem].fallbackFont)
1903 oldFont = SelectObject(analysis->hdc, analysis->glyphs[iItem].fallbackFont);
1904
1905 if (cStart >= 0 && analysis->pItem[iItem+1].iCharPos > cStart && analysis->pItem[iItem].iCharPos <= cStart)
1906 runStart = cStart - analysis->pItem[iItem].iCharPos;
1907 else
1908 runStart = 0;
1909 if (cEnd >= 0 && analysis->pItem[iItem+1].iCharPos > cEnd && analysis->pItem[iItem].iCharPos <= cEnd)
1910 runEnd = (cEnd-1) - analysis->pItem[iItem].iCharPos;
1911 else
1912 runEnd = (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos) - 1;
1913
1914 if (analysis->pItem[iItem].a.fRTL)
1915 {
1916 if (cEnd >= 0 && cEnd < analysis->pItem[iItem+1].iCharPos)
1917 ScriptStringCPtoX(ssa, cEnd, FALSE, &off_x);
1918 else
1919 ScriptStringCPtoX(ssa, analysis->pItem[iItem+1].iCharPos-1, TRUE, &off_x);
1920 }
1921 else
1922 {
1923 if (cStart >=0 && runStart)
1924 ScriptStringCPtoX(ssa, cStart, FALSE, &off_x);
1925 else
1926 ScriptStringCPtoX(ssa, analysis->pItem[iItem].iCharPos, FALSE, &off_x);
1927 }
1928
1929 if (analysis->pItem[iItem].a.fRTL)
1930 iGlyph = analysis->glyphs[iItem].pwLogClust[runEnd];
1931 else
1932 iGlyph = analysis->glyphs[iItem].pwLogClust[runStart];
1933
1934 if (analysis->pItem[iItem].a.fRTL)
1935 cGlyphs = analysis->glyphs[iItem].pwLogClust[runStart] - iGlyph;
1936 else
1937 cGlyphs = analysis->glyphs[iItem].pwLogClust[runEnd] - iGlyph;
1938
1939 cGlyphs++;
1940
1941 if (cEnd < 0 || scriptInformation[analysis->pItem[iItem].a.eScript].props.fNeedsCaretInfo)
1942 {
1943 INT direction;
1944 INT clust_glyph;
1945
1946 clust_glyph = iGlyph + cGlyphs;
1947 if (analysis->pItem[iItem].a.fRTL)
1948 direction = -1;
1949 else
1950 direction = 1;
1951
1952 while(clust_glyph < analysis->glyphs[iItem].numGlyphs &&
1953 !does_glyph_start_cluster(analysis->glyphs[iItem].psva, analysis->glyphs[iItem].pwLogClust, (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos), clust_glyph, direction))
1954 {
1955 cGlyphs++;
1956 clust_glyph++;
1957 }
1958 }
1959
1960 hr = ScriptTextOut(analysis->hdc,
1961 (SCRIPT_CACHE *)&analysis->glyphs[iItem].sc, iX + off_x,
1962 iY, uOptions, prc, &analysis->pItem[iItem].a, NULL, 0,
1963 &analysis->glyphs[iItem].glyphs[iGlyph], cGlyphs,
1964 &analysis->glyphs[iItem].piAdvance[iGlyph], NULL,
1965 &analysis->glyphs[iItem].pGoffset[iGlyph]);
1966
1967 TRACE("ScriptTextOut hr=%08x\n", hr);
1968
1969 if (fSelected)
1970 {
1971 SetBkColor(analysis->hdc, BkColor);
1972 SetBkMode( analysis->hdc, BkMode);
1973 if (!fDisabled)
1974 SetTextColor(analysis->hdc, TextColor);
1975 }
1976 if (analysis->glyphs[iItem].fallbackFont)
1977 SelectObject(analysis->hdc, oldFont);
1978
1979 return hr;
1980 }
1981
1982 /***********************************************************************
1983 * ScriptStringOut (USP10.@)
1984 *
1985 * This function takes the output of ScriptStringAnalyse and joins the segments
1986 * of glyphs and passes the resulting string to ScriptTextOut. ScriptStringOut
1987 * only processes glyphs.
1988 *
1989 * Parameters:
1990 * ssa [I] buffer to hold the analysed string components
1991 * iX [I] X axis displacement for output
1992 * iY [I] Y axis displacement for output
1993 * uOptions [I] flags controling output processing
1994 * prc [I] rectangle coordinates
1995 * iMinSel [I] starting pos for substringing output string
1996 * iMaxSel [I] ending pos for substringing output string
1997 * fDisabled [I] controls text highlighting
1998 *
1999 * RETURNS
2000 * Success: S_OK
2001 * Failure: is the value returned by ScriptTextOut
2002 */
2003 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
2004 int iX,
2005 int iY,
2006 UINT uOptions,
2007 const RECT *prc,
2008 int iMinSel,
2009 int iMaxSel,
2010 BOOL fDisabled)
2011 {
2012 StringAnalysis *analysis;
2013 int item;
2014 HRESULT hr;
2015
2016 TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
2017 ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
2018
2019 if (!(analysis = ssa)) return E_INVALIDARG;
2020 if (!(analysis->dwFlags & SSA_GLYPHS)) return E_INVALIDARG;
2021
2022 for (item = 0; item < analysis->numItems; item++)
2023 {
2024 hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], -1, -1, uOptions, prc, FALSE, fDisabled);
2025 if (FAILED(hr))
2026 return hr;
2027 }
2028
2029 if (iMinSel < iMaxSel && (iMinSel > 0 || iMaxSel > 0))
2030 {
2031 if (iMaxSel > 0 && iMinSel < 0)
2032 iMinSel = 0;
2033 for (item = 0; item < analysis->numItems; item++)
2034 {
2035 hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], iMinSel, iMaxSel, uOptions, prc, TRUE, fDisabled);
2036 if (FAILED(hr))
2037 return hr;
2038 }
2039 }
2040
2041 return S_OK;
2042 }
2043
2044 /***********************************************************************
2045 * ScriptStringCPtoX (USP10.@)
2046 *
2047 */
2048 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
2049 {
2050 int item;
2051 int runningX = 0;
2052 StringAnalysis* analysis = ssa;
2053
2054 TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
2055
2056 if (!ssa || !pX) return S_FALSE;
2057 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
2058
2059 /* icp out of range */
2060 if(icp < 0)
2061 {
2062 analysis->invalid = TRUE;
2063 return E_INVALIDARG;
2064 }
2065
2066 for(item=0; item<analysis->numItems; item++)
2067 {
2068 int CP, i;
2069 int offset;
2070
2071 i = analysis->logical2visual[item];
2072 CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
2073 /* initialize max extents for uninitialized runs */
2074 if (analysis->glyphs[i].iMaxPosX == -1)
2075 {
2076 if (analysis->pItem[i].a.fRTL)
2077 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2078 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2079 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2080 else
2081 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2082 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2083 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2084 }
2085
2086 if (icp >= analysis->pItem[i+1].iCharPos || icp < analysis->pItem[i].iCharPos)
2087 {
2088 runningX += analysis->glyphs[i].iMaxPosX;
2089 continue;
2090 }
2091
2092 icp -= analysis->pItem[i].iCharPos;
2093 ScriptCPtoX(icp, fTrailing, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2094 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2095 &analysis->pItem[i].a, &offset);
2096 runningX += offset;
2097
2098 *pX = runningX;
2099 return S_OK;
2100 }
2101
2102 /* icp out of range */
2103 analysis->invalid = TRUE;
2104 return E_INVALIDARG;
2105 }
2106
2107 /***********************************************************************
2108 * ScriptStringXtoCP (USP10.@)
2109 *
2110 */
2111 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing)
2112 {
2113 StringAnalysis* analysis = ssa;
2114 int item;
2115
2116 TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
2117
2118 if (!ssa || !piCh || !piTrailing) return S_FALSE;
2119 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
2120
2121 /* out of range */
2122 if(iX < 0)
2123 {
2124 if (analysis->pItem[0].a.fRTL)
2125 {
2126 *piCh = 1;
2127 *piTrailing = FALSE;
2128 }
2129 else
2130 {
2131 *piCh = -1;
2132 *piTrailing = TRUE;
2133 }
2134 return S_OK;
2135 }
2136
2137 for(item=0; item<analysis->numItems; item++)
2138 {
2139 int i;
2140 int CP;
2141
2142 for (i = 0; i < analysis->numItems && analysis->logical2visual[i] != item; i++)
2143 /* nothing */;
2144
2145 CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
2146 /* initialize max extents for uninitialized runs */
2147 if (analysis->glyphs[i].iMaxPosX == -1)
2148 {
2149 if (analysis->pItem[i].a.fRTL)
2150 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2151 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2152 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2153 else
2154 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2155 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2156 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2157 }
2158
2159 if (iX > analysis->glyphs[i].iMaxPosX)
2160 {
2161 iX -= analysis->glyphs[i].iMaxPosX;
2162 continue;
2163 }
2164
2165 ScriptXtoCP(iX, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2166 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2167 &analysis->pItem[i].a, piCh, piTrailing);
2168 *piCh += analysis->pItem[i].iCharPos;
2169
2170 return S_OK;
2171 }
2172
2173 /* out of range */
2174 *piCh = analysis->pItem[analysis->numItems].iCharPos;
2175 *piTrailing = FALSE;
2176
2177 return S_OK;
2178 }
2179
2180
2181 /***********************************************************************
2182 * ScriptStringFree (USP10.@)
2183 *
2184 * Free a string analysis.
2185 *
2186 * PARAMS
2187 * pssa [I] string analysis.
2188 *
2189 * RETURNS
2190 * Success: S_OK
2191 * Failure: Non-zero HRESULT value.
2192 */
2193 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
2194 {
2195 StringAnalysis* analysis;
2196 BOOL invalid;
2197 int i;
2198
2199 TRACE("(%p)\n", pssa);
2200
2201 if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
2202
2203 invalid = analysis->invalid;
2204
2205 if (analysis->glyphs)
2206 {
2207 for (i = 0; i < analysis->numItems; i++)
2208 {
2209 heap_free(analysis->glyphs[i].glyphs);
2210 heap_free(analysis->glyphs[i].pwLogClust);
2211 heap_free(analysis->glyphs[i].piAdvance);
2212 heap_free(analysis->glyphs[i].psva);
2213 heap_free(analysis->glyphs[i].pGoffset);
2214 heap_free(analysis->glyphs[i].abc);
2215 if (analysis->glyphs[i].fallbackFont)
2216 DeleteObject(analysis->glyphs[i].fallbackFont);
2217 ScriptFreeCache((SCRIPT_CACHE *)&analysis->glyphs[i].sc);
2218 heap_free(analysis->glyphs[i].sc);
2219 }
2220 heap_free(analysis->glyphs);
2221 }
2222
2223 heap_free(analysis->pItem);
2224 heap_free(analysis->logattrs);
2225 heap_free(analysis->sz);
2226 heap_free(analysis->logical2visual);
2227 heap_free(analysis);
2228
2229 if (invalid) return E_INVALIDARG;
2230 return S_OK;
2231 }
2232
2233 static inline int get_cluster_size(const WORD *pwLogClust, int cChars, int item,
2234 int direction, int* iCluster, int *check_out)
2235 {
2236 int clust_size = 1;
2237 int check;
2238 WORD clust = pwLogClust[item];
2239
2240 for (check = item+direction; check < cChars && check >= 0; check+=direction)
2241 {
2242 if (pwLogClust[check] == clust)
2243 {
2244 clust_size ++;
2245 if (iCluster && *iCluster == -1)
2246 *iCluster = item;
2247 }
2248 else break;
2249 }
2250
2251 if (check_out)
2252 *check_out = check;
2253
2254 return clust_size;
2255 }
2256
2257 static inline int get_glyph_cluster_advance(const int* piAdvance, const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cGlyphs, int cChars, int glyph, int direction)
2258 {
2259 int advance;
2260 int log_clust_max = 0;
2261 int i;
2262
2263 advance = piAdvance[glyph];
2264
2265 for (i = 0; i < cChars; i++)
2266 {
2267 if (pwLogClust[i] > log_clust_max)
2268 log_clust_max = pwLogClust[i];
2269 }
2270
2271 if (glyph > log_clust_max)
2272 return advance;
2273
2274 for (glyph+=direction; glyph < cGlyphs && glyph >= 0; glyph +=direction)
2275 {
2276
2277 if (does_glyph_start_cluster(pva, pwLogClust, cChars, glyph, direction))
2278 break;
2279 if (glyph > log_clust_max)
2280 break;
2281 advance += piAdvance[glyph];
2282 }
2283
2284 return advance;
2285 }
2286
2287 /***********************************************************************
2288 * ScriptCPtoX (USP10.@)
2289 *
2290 */
2291 HRESULT WINAPI ScriptCPtoX(int iCP,
2292 BOOL fTrailing,
2293 int cChars,
2294 int cGlyphs,
2295 const WORD *pwLogClust,
2296 const SCRIPT_VISATTR *psva,
2297 const int *piAdvance,
2298 const SCRIPT_ANALYSIS *psa,
2299 int *piX)
2300 {
2301 int item;
2302 float iPosX;
2303 int iSpecial = -1;
2304 int iCluster = -1;
2305 int clust_size = 1;
2306 float special_size = 0.0;
2307 int iMaxPos = 0;
2308 int advance = 0;
2309 BOOL rtl = FALSE;
2310
2311 TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
2312 iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
2313 psa, piX);
2314
2315 if (psa->fRTL && ! psa->fLogicalOrder)
2316 rtl = TRUE;
2317
2318 if (fTrailing)
2319 iCP++;
2320
2321 if (rtl)
2322 {
2323 int max_clust = pwLogClust[0];
2324
2325 for (item=0; item < cGlyphs; item++)
2326 if (pwLogClust[item] > max_clust)
2327 {
2328 ERR("We do not handle non reversed clusters properly\n");
2329 break;
2330 }
2331
2332 iMaxPos = 0;
2333 for (item = max_clust; item >=0; item --)
2334 iMaxPos += piAdvance[item];
2335 }
2336
2337 iPosX = 0.0;
2338 for (item=0; item < iCP && item < cChars; item++)
2339 {
2340 if (iSpecial == -1 && (iCluster == -1 || (iCluster != -1 && iCluster+clust_size <= item)))
2341 {
2342 int check;
2343 int clust = pwLogClust[item];
2344
2345 iCluster = -1;
2346 clust_size = get_cluster_size(pwLogClust, cChars, item, 1, &iCluster,
2347 &check);
2348
2349 advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, 1);
2350
2351 if (check >= cChars && !iMaxPos)
2352 {
2353 for (check = clust; check < cChars; check++)
2354 special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, check, 1);
2355 iSpecial = item;
2356 special_size /= (cChars - item);
2357 iPosX += special_size;
2358 }
2359 else
2360 {
2361 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2362 {
2363 clust_size --;
2364 if (clust_size == 0)
2365 iPosX += advance;
2366 }
2367 else
2368 iPosX += advance / (float)clust_size;
2369 }
2370 }
2371 else if (iSpecial != -1)
2372 iPosX += special_size;
2373 else /* (iCluster != -1) */
2374 {
2375 int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], 1);
2376 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2377 {
2378 clust_size --;
2379 if (clust_size == 0)
2380 iPosX += adv;
2381 }
2382 else
2383 iPosX += adv / (float)clust_size;
2384 }
2385 }
2386
2387 if (iMaxPos > 0)
2388 {
2389 iPosX = iMaxPos - iPosX;
2390 if (iPosX < 0)
2391 iPosX = 0;
2392 }
2393
2394 *piX = iPosX;
2395 TRACE("*piX=%d\n", *piX);
2396 return S_OK;
2397 }
2398
2399 /***********************************************************************
2400 * ScriptXtoCP (USP10.@)
2401 *
2402 */
2403 HRESULT WINAPI ScriptXtoCP(int iX,
2404 int cChars,
2405 int cGlyphs,
2406 const WORD *pwLogClust,
2407 const SCRIPT_VISATTR *psva,
2408 const int *piAdvance,
2409 const SCRIPT_ANALYSIS *psa,
2410 int *piCP,
2411 int *piTrailing)
2412 {
2413 int item;
2414 float iPosX;
2415 float iLastPosX;
2416 int iSpecial = -1;
2417 int iCluster = -1;
2418 int clust_size = 1;
2419 int cjump = 0;
2420 int advance;
2421 float special_size = 0.0;
2422 int direction = 1;
2423
2424 TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
2425 iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
2426 psa, piCP, piTrailing);
2427
2428 if (psa->fRTL && ! psa->fLogicalOrder)
2429 direction = -1;
2430
2431 if (direction<0)
2432 {
2433 int max_clust = pwLogClust[0];
2434
2435 if (iX < 0)
2436 {
2437 *piCP = cChars;
2438 *piTrailing = 0;
2439 return S_OK;
2440 }
2441
2442 for (item=0; item < cChars; item++)
2443 if (pwLogClust[item] > max_clust)
2444 {
2445 ERR("We do not handle non reversed clusters properly\n");
2446 break;
2447 }
2448 }
2449
2450 if (iX < 0)
2451 {
2452 *piCP = -1;
2453 *piTrailing = 1;
2454 return S_OK;
2455 }
2456
2457 iPosX = iLastPosX = 0;
2458 if (direction > 0)
2459 item = 0;
2460 else
2461 item = cChars - 1;
2462 for (; iPosX <= iX && item < cChars && item >= 0; item+=direction)
2463 {
2464 iLastPosX = iPosX;
2465 if (iSpecial == -1 &&
2466 (iCluster == -1 ||
2467 (iCluster != -1 &&
2468 ((direction > 0 && iCluster+clust_size <= item) ||
2469 (direction < 0 && iCluster-clust_size >= item))
2470 )
2471 )
2472 )
2473 {
2474 int check;
2475 int clust = pwLogClust[item];
2476
2477 iCluster = -1;
2478 cjump = 0;
2479 clust_size = get_cluster_size(pwLogClust, cChars, item, direction,
2480 &iCluster, &check);
2481 advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, direction);
2482
2483 if (check >= cChars && direction > 0)
2484 {
2485 for (check = clust; check < cChars; check++)
2486 special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, check, direction);
2487 iSpecial = item;
2488 special_size /= (cChars - item);
2489 iPosX += special_size;
2490 }
2491 else
2492 {
2493 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2494 {
2495 if (!cjump)
2496 iPosX += advance;
2497 cjump++;
2498 }
2499 else
2500 iPosX += advance / (float)clust_size;
2501 }
2502 }
2503 else if (iSpecial != -1)
2504 iPosX += special_size;
2505 else /* (iCluster != -1) */
2506 {
2507 int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], direction);
2508 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2509 {
2510 if (!cjump)
2511 iPosX += adv;
2512 cjump++;
2513 }
2514 else
2515 iPosX += adv / (float)clust_size;
2516 }
2517 }
2518
2519 if (direction > 0)
2520 {
2521 if (iPosX > iX)
2522 item--;
2523 if (item < cChars && ((iPosX - iLastPosX) / 2.0) + iX >= iPosX)
2524 {
2525 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo && clust_size > 1)
2526 item+=(clust_size-1);
2527 *piTrailing = 1;
2528 }
2529 else
2530 *piTrailing = 0;
2531 }
2532 else
2533 {
2534 if (iX == iLastPosX)
2535 item++;
2536 if (iX >= iLastPosX && iX <= iPosX)
2537 item++;
2538
2539 if (iLastPosX == iX)
2540 *piTrailing = 0;
2541 else if (item < 0 || ((iLastPosX - iPosX) / 2.0) + iX <= iLastPosX)
2542 {
2543 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo && clust_size > 1)
2544 item-=(clust_size-1);
2545 *piTrailing = 1;
2546 }
2547 else
2548 *piTrailing = 0;
2549 }
2550
2551 *piCP = item;
2552
2553 TRACE("*piCP=%d\n", *piCP);
2554 TRACE("*piTrailing=%d\n", *piTrailing);
2555 return S_OK;
2556 }
2557
2558 /***********************************************************************
2559 * ScriptBreak (USP10.@)
2560 *
2561 * Retrieve line break information.
2562 *
2563 * PARAMS
2564 * chars [I] Array of characters.
2565 * sa [I] String analysis.
2566 * la [I] Array of logical attribute structures.
2567 *
2568 * RETURNS
2569 * Success: S_OK
2570 * Failure: S_FALSE
2571 */
2572 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
2573 {
2574 TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
2575
2576 if (!la) return S_FALSE;
2577
2578 BREAK_line(chars, count, sa, la);
2579
2580 return S_OK;
2581 }
2582
2583 /***********************************************************************
2584 * ScriptIsComplex (USP10.@)
2585 *
2586 * Determine if a string is complex.
2587 *
2588 * PARAMS
2589 * chars [I] Array of characters to test.
2590 * len [I] Length in characters.
2591 * flag [I] Flag.
2592 *
2593 * RETURNS
2594 * Success: S_OK
2595 * Failure: S_FALSE
2596 *
2597 */
2598 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
2599 {
2600 int i;
2601 INT consumed = 0;
2602
2603 TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
2604
2605 for (i = 0; i < len; i+=consumed)
2606 {
2607 int script;
2608 if (i >= len)
2609 break;
2610
2611 if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
2612 return S_OK;
2613
2614 script = get_char_script(chars,i,len, &consumed);
2615 if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
2616 (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
2617 return S_OK;
2618 }
2619 return S_FALSE;
2620 }
2621
2622 /***********************************************************************
2623 * ScriptShapeOpenType (USP10.@)
2624 *
2625 * Produce glyphs and visual attributes for a run.
2626 *
2627 * PARAMS
2628 * hdc [I] Device context.
2629 * psc [I/O] Opaque pointer to a script cache.
2630 * psa [I/O] Script analysis.
2631 * tagScript [I] The OpenType tag for the Script
2632 * tagLangSys [I] The OpenType tag for the Language
2633 * rcRangeChars[I] Array of Character counts in each range
2634 * rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
2635 * cRanges [I] Count of ranges
2636 * pwcChars [I] Array of characters specifying the run.
2637 * cChars [I] Number of characters in pwcChars.
2638 * cMaxGlyphs [I] Length of pwOutGlyphs.
2639 * pwLogClust [O] Array of logical cluster info.
2640 * pCharProps [O] Array of character property values
2641 * pwOutGlyphs [O] Array of glyphs.
2642 * pOutGlyphProps [O] Array of attributes for the retrieved glyphs
2643 * pcGlyphs [O] Number of glyphs returned.
2644 *
2645 * RETURNS
2646 * Success: S_OK
2647 * Failure: Non-zero HRESULT value.
2648 */
2649 HRESULT WINAPI ScriptShapeOpenType( HDC hdc, SCRIPT_CACHE *psc,
2650 SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript,
2651 OPENTYPE_TAG tagLangSys, int *rcRangeChars,
2652 TEXTRANGE_PROPERTIES **rpRangeProperties,
2653 int cRanges, const WCHAR *pwcChars, int cChars,
2654 int cMaxGlyphs, WORD *pwLogClust,
2655 SCRIPT_CHARPROP *pCharProps, WORD *pwOutGlyphs,
2656 SCRIPT_GLYPHPROP *pOutGlyphProps, int *pcGlyphs)
2657 {
2658 HRESULT hr;
2659 unsigned int i,g;
2660 BOOL rtl;
2661 int cluster;
2662
2663 TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %d, %d, %p, %p, %p, %p, %p )\n",
2664 hdc, psc, psa,
2665 debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
2666 rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
2667 cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
2668
2669 if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
2670 psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
2671
2672 if (!pOutGlyphProps || !pcGlyphs || !pCharProps) return E_INVALIDARG;
2673 if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
2674
2675 if (cRanges)
2676 FIXME("Ranges not supported yet\n");
2677
2678 rtl = (psa && !psa->fLogicalOrder && psa->fRTL);
2679
2680 *pcGlyphs = cChars;
2681 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2682 if (!pwLogClust) return E_FAIL;
2683
2684 ((ScriptCache *)*psc)->userScript = tagScript;
2685 ((ScriptCache *)*psc)->userLang = tagLangSys;
2686
2687 /* set fNoGlyphIndex non truetype/opentype fonts */
2688 if (!psa->fNoGlyphIndex && !((ScriptCache *)*psc)->sfnt)
2689 psa->fNoGlyphIndex = TRUE;
2690
2691 /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
2692 for (i = 0; i < cChars; i++)
2693 {
2694 int idx = i;
2695 if (rtl) idx = cChars - 1 - i;
2696 /* FIXME: set to better values */
2697 pOutGlyphProps[i].sva.uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
2698 pOutGlyphProps[i].sva.fClusterStart = 1;
2699 pOutGlyphProps[i].sva.fDiacritic = 0;
2700 pOutGlyphProps[i].sva.fZeroWidth = 0;
2701 pOutGlyphProps[i].sva.fReserved = 0;
2702 pOutGlyphProps[i].sva.fShapeReserved = 0;
2703
2704 /* FIXME: have the shaping engine set this */
2705 pCharProps[i].fCanGlyphAlone = 0;
2706
2707 pwLogClust[i] = idx;
2708 }
2709
2710 if (psa && !psa->fNoGlyphIndex)
2711 {
2712 WCHAR *rChars;
2713 if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
2714
2715 rChars = heap_alloc(sizeof(WCHAR) * cChars);
2716 if (!rChars) return E_OUTOFMEMORY;
2717 for (i = 0, g = 0, cluster = 0; i < cChars; i++)
2718 {
2719 int idx = i;
2720 DWORD chInput;
2721
2722 if (rtl) idx = cChars - 1 - i;
2723 if (!cluster)
2724 {
2725 chInput = decode_surrogate_pair(pwcChars, idx, cChars);
2726 if (!chInput)
2727 {
2728 if (psa->fRTL)
2729 chInput = mirror_char(pwcChars[idx]);
2730 else
2731 chInput = pwcChars[idx];
2732 /* special case for tabs */
2733 if (chInput == 0x0009)
2734 chInput = 0x0020;
2735 rChars[i] = chInput;
2736 }
2737 else
2738 {
2739 rChars[i] = pwcChars[idx];
2740 rChars[i+1] = pwcChars[(rtl)?idx-1:idx+1];
2741 cluster = 1;
2742 }
2743 if (!(pwOutGlyphs[g] = get_cache_glyph(psc, chInput)))
2744 {
2745 WORD glyph;
2746 if (!hdc)
2747 {
2748 heap_free(rChars);
2749 return E_PENDING;
2750 }
2751 if (CMAP_GetGlyphIndex(hdc, (ScriptCache *)*psc, chInput, &glyph, 0) == GDI_ERROR)
2752 {
2753 heap_free(rChars);
2754 return S_FALSE;
2755 }
2756 pwOutGlyphs[g] = set_cache_glyph(psc, chInput, glyph);
2757 }
2758 g++;
2759 }
2760 else
2761 {
2762 int k;
2763 cluster--;
2764 pwLogClust[idx] = (rtl)?pwLogClust[idx+1]:pwLogClust[idx-1];
2765 for (k = (rtl)?idx-1:idx+1; k >= 0 && k < cChars; (rtl)?k--:k++)
2766 pwLogClust[k]--;
2767 }
2768 }
2769 *pcGlyphs = g;
2770
2771 SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
2772 SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
2773 SHAPE_CharGlyphProp(hdc, (ScriptCache *)*psc, psa, pwcChars, cChars, pwOutGlyphs, *pcGlyphs, pwLogClust, pCharProps, pOutGlyphProps);
2774 heap_free(rChars);
2775 }
2776 else
2777 {
2778 TRACE("no glyph translation\n");
2779 for (i = 0; i < cChars; i++)
2780 {
2781 int idx = i;
2782 /* No mirroring done here */
2783 if (rtl) idx = cChars - 1 - i;
2784 pwOutGlyphs[i] = pwcChars[idx];
2785 }
2786 }
2787
2788 return S_OK;
2789 }
2790
2791
2792 /***********************************************************************
2793 * ScriptShape (USP10.@)
2794 *
2795 * Produce glyphs and visual attributes for a run.
2796 *
2797 * PARAMS
2798 * hdc [I] Device context.
2799 * psc [I/O] Opaque pointer to a script cache.
2800 * pwcChars [I] Array of characters specifying the run.
2801 * cChars [I] Number of characters in pwcChars.
2802 * cMaxGlyphs [I] Length of pwOutGlyphs.
2803 * psa [I/O] Script analysis.
2804 * pwOutGlyphs [O] Array of glyphs.
2805 * pwLogClust [O] Array of logical cluster info.
2806 * psva [O] Array of visual attributes.
2807 * pcGlyphs [O] Number of glyphs returned.
2808 *
2809 * RETURNS
2810 * Success: S_OK
2811 * Failure: Non-zero HRESULT value.
2812 */
2813 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars,
2814 int cChars, int cMaxGlyphs,
2815 SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
2816 SCRIPT_VISATTR *psva, int *pcGlyphs)
2817 {
2818 HRESULT hr;
2819 int i;
2820 SCRIPT_CHARPROP *charProps;
2821 SCRIPT_GLYPHPROP *glyphProps;
2822
2823 if (!psva || !pcGlyphs) return E_INVALIDARG;
2824 if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
2825
2826 charProps = heap_alloc_zero(sizeof(SCRIPT_CHARPROP)*cChars);
2827 if (!charProps) return E_OUTOFMEMORY;
2828 glyphProps = heap_alloc_zero(sizeof(SCRIPT_GLYPHPROP)*cMaxGlyphs);
2829 if (!glyphProps)
2830 {
2831 heap_free(charProps);
2832 return E_OUTOFMEMORY;
2833 }
2834
2835 hr = ScriptShapeOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, pwcChars, cChars, cMaxGlyphs, pwLogClust, charProps, pwOutGlyphs, glyphProps, pcGlyphs);
2836
2837 if (SUCCEEDED(hr))
2838 {
2839 for (i = 0; i < *pcGlyphs; i++)
2840 psva[i] = glyphProps[i].sva;
2841 }
2842
2843 heap_free(charProps);
2844 heap_free(glyphProps);
2845
2846 return hr;
2847 }
2848
2849 /***********************************************************************
2850 * ScriptPlaceOpenType (USP10.@)
2851 *
2852 * Produce advance widths for a run.
2853 *
2854 * PARAMS
2855 * hdc [I] Device context.
2856 * psc [I/O] Opaque pointer to a script cache.
2857 * psa [I/O] String analysis.
2858 * tagScript [I] The OpenType tag for the Script
2859 * tagLangSys [I] The OpenType tag for the Language
2860 * rcRangeChars[I] Array of Character counts in each range
2861 * rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
2862 * cRanges [I] Count of ranges
2863 * pwcChars [I] Array of characters specifying the run.
2864 * pwLogClust [I] Array of logical cluster info
2865 * pCharProps [I] Array of character property values
2866 * cChars [I] Number of characters in pwcChars.
2867 * pwGlyphs [I] Array of glyphs.
2868 * pGlyphProps [I] Array of attributes for the retrieved glyphs
2869 * cGlyphs [I] Count of Glyphs
2870 * piAdvance [O] Array of advance widths.
2871 * pGoffset [O] Glyph offsets.
2872 * pABC [O] Combined ABC width.
2873 *
2874 * RETURNS
2875 * Success: S_OK
2876 * Failure: Non-zero HRESULT value.
2877 */
2878
2879 HRESULT WINAPI ScriptPlaceOpenType( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
2880 OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys,
2881 int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties,
2882 int cRanges, const WCHAR *pwcChars, WORD *pwLogClust,
2883 SCRIPT_CHARPROP *pCharProps, int cChars,
2884 const WORD *pwGlyphs, const SCRIPT_GLYPHPROP *pGlyphProps,
2885 int cGlyphs, int *piAdvance,
2886 GOFFSET *pGoffset, ABC *pABC
2887 )
2888 {
2889 HRESULT hr;
2890 int i;
2891
2892 TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %p, %p, %d, %p, %p, %d, %p %p %p)\n",
2893 hdc, psc, psa,
2894 debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
2895 rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
2896 pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance,
2897 pGoffset, pABC);
2898
2899 if (!pGlyphProps) return E_INVALIDARG;
2900 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2901 if (!pGoffset) return E_FAIL;
2902
2903 if (cRanges)
2904 FIXME("Ranges not supported yet\n");
2905
2906 ((ScriptCache *)*psc)->userScript = tagScript;
2907 ((ScriptCache *)*psc)->userLang = tagLangSys;
2908
2909 if (pABC) memset(pABC, 0, sizeof(ABC));
2910 for (i = 0; i < cGlyphs; i++)
2911 {
2912 ABC abc;
2913 if (!get_cache_glyph_widths(psc, pwGlyphs[i], &abc))
2914 {
2915 if (!hdc) return E_PENDING;
2916 if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE) && !psa->fNoGlyphIndex)
2917 {
2918 if (!GetCharABCWidthsI(hdc, 0, 1, (WORD *)&pwGlyphs[i], &abc)) return S_FALSE;
2919 }
2920 else
2921 {
2922 INT width;
2923 if (!GetCharWidth32W(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
2924 abc.abcB = width;
2925 abc.abcA = abc.abcC = 0;
2926 }
2927 set_cache_glyph_widths(psc, pwGlyphs[i], &abc);
2928 }
2929 if (pABC)
2930 {
2931 pABC->abcA += abc.abcA;
2932 pABC->abcB += abc.abcB;
2933 pABC->abcC += abc.abcC;
2934 }
2935 /* FIXME: set to more reasonable values */
2936 pGoffset[i].du = pGoffset[i].dv = 0;
2937 if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
2938 }
2939
2940 if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
2941 return S_OK;
2942 }
2943
2944 /***********************************************************************
2945 * ScriptPlace (USP10.@)
2946 *
2947 * Produce advance widths for a run.
2948 *
2949 * PARAMS
2950 * hdc [I] Device context.
2951 * psc [I/O] Opaque pointer to a script cache.
2952 * pwGlyphs [I] Array of glyphs.
2953 * cGlyphs [I] Number of glyphs in pwGlyphs.
2954 * psva [I] Array of visual attributes.
2955 * psa [I/O] String analysis.
2956 * piAdvance [O] Array of advance widths.
2957 * pGoffset [O] Glyph offsets.
2958 * pABC [O] Combined ABC width.
2959 *
2960 * RETURNS
2961 * Success: S_OK
2962 * Failure: Non-zero HRESULT value.
2963 */
2964 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs,
2965 int cGlyphs, const SCRIPT_VISATTR *psva,
2966 SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
2967 {
2968 HRESULT hr;
2969 SCRIPT_GLYPHPROP *glyphProps;
2970 int i;
2971
2972 TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n", hdc, psc, pwGlyphs, cGlyphs, psva, psa,
2973 piAdvance, pGoffset, pABC);
2974
2975 if (!psva) return E_INVALIDARG;
2976 if (!pGoffset) return E_FAIL;
2977
2978 glyphProps = heap_alloc(sizeof(SCRIPT_GLYPHPROP)*cGlyphs);
2979 if (!glyphProps) return E_OUTOFMEMORY;
2980
2981 for (i = 0; i < cGlyphs; i++)
2982 glyphProps[i].sva = psva[i];
2983
2984 hr = ScriptPlaceOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, NULL, NULL, NULL, 0, pwGlyphs, glyphProps, cGlyphs, piAdvance, pGoffset, pABC);
2985
2986 heap_free(glyphProps);
2987
2988 return hr;
2989 }
2990
2991 /***********************************************************************
2992 * ScriptGetCMap (USP10.@)
2993 *
2994 * Retrieve glyph indices.
2995 *
2996 * PARAMS
2997 * hdc [I] Device context.
2998 * psc [I/O] Opaque pointer to a script cache.
2999 * pwcInChars [I] Array of Unicode characters.
3000 * cChars [I] Number of characters in pwcInChars.
3001 * dwFlags [I] Flags.
3002 * pwOutGlyphs [O] Buffer to receive the array of glyph indices.
3003 *
3004 * RETURNS
3005 * Success: S_OK
3006 * Failure: Non-zero HRESULT value.
3007 */
3008 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
3009 int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
3010 {
3011 HRESULT hr;
3012 int i;
3013
3014 TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
3015 cChars, dwFlags, pwOutGlyphs);
3016
3017 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3018
3019 hr = S_OK;
3020
3021 if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
3022 {
3023 for (i = 0; i < cChars; i++)
3024 {
3025 WCHAR inChar;
3026 if (dwFlags == SGCM_RTL)
3027 inChar = mirror_char(pwcInChars[i]);
3028 else
3029 inChar = pwcInChars[i];
3030 if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
3031 {
3032 WORD glyph;
3033 if (!hdc) return E_PENDING;
3034 if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
3035 if (glyph == 0xffff)
3036 {
3037 hr = S_FALSE;
3038 glyph = 0x0;
3039 }
3040 pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
3041 }
3042 }
3043 }
3044 else
3045 {
3046 TRACE("no glyph translation\n");
3047 for (i = 0; i < cChars; i++)
3048 {
3049 WCHAR inChar;
3050 if (dwFlags == SGCM_RTL)
3051 inChar = mirror_char(pwcInChars[i]);
3052 else
3053 inChar = pwcInChars[i];
3054 pwOutGlyphs[i] = inChar;
3055 }
3056 }
3057 return hr;
3058 }
3059
3060 /***********************************************************************
3061 * ScriptTextOut (USP10.@)
3062 *
3063 */
3064 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
3065 const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
3066 int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
3067 const int *piJustify, const GOFFSET *pGoffset)
3068 {
3069 HRESULT hr = S_OK;
3070
3071 TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
3072 hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
3073 piAdvance, piJustify, pGoffset);
3074
3075 if (!hdc || !psc) return E_INVALIDARG;
3076 if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
3077
3078 fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
3079 fuOptions |= ETO_IGNORELANGUAGE;
3080 if (!psa->fNoGlyphIndex) /* Have Glyphs? */
3081 fuOptions |= ETO_GLYPH_INDEX; /* Say don't do translation to glyph */
3082
3083 if (psa->fRTL && psa->fLogicalOrder)
3084 {
3085 int i;
3086 WORD *rtlGlyphs;
3087
3088 rtlGlyphs = heap_alloc(cGlyphs * sizeof(WORD));
3089 if (!rtlGlyphs)
3090 return E_OUTOFMEMORY;
3091
3092 for (i = 0; i < cGlyphs; i++)
3093 rtlGlyphs[i] = pwGlyphs[cGlyphs-1-i];
3094
3095 if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, rtlGlyphs, cGlyphs, NULL))
3096 hr = S_FALSE;
3097 heap_free(rtlGlyphs);
3098 }
3099 else
3100 if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
3101 hr = S_FALSE;
3102
3103 return hr;
3104 }
3105
3106 /***********************************************************************
3107 * ScriptCacheGetHeight (USP10.@)
3108 *
3109 * Retrieve the height of the font in the cache.
3110 *
3111 * PARAMS
3112 * hdc [I] Device context.
3113 * psc [I/O] Opaque pointer to a script cache.
3114 * height [O] Receives font height.
3115 *
3116 * RETURNS
3117 * Success: S_OK
3118 * Failure: Non-zero HRESULT value.
3119 */
3120 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
3121 {
3122 HRESULT hr;
3123
3124 TRACE("(%p, %p, %p)\n", hdc, psc, height);
3125
3126 if (!height) return E_INVALIDARG;
3127 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3128
3129 *height = get_cache_height(psc);
3130 return S_OK;
3131 }
3132
3133 /***********************************************************************
3134 * ScriptGetGlyphABCWidth (USP10.@)
3135 *
3136 * Retrieve the width of a glyph.
3137 *
3138 * PARAMS
3139 * hdc [I] Device context.
3140 * psc [I/O] Opaque pointer to a script cache.
3141 * glyph [I] Glyph to retrieve the width for.
3142 * abc [O] ABC widths of the glyph.
3143 *
3144 * RETURNS
3145 * Success: S_OK
3146 * Failure: Non-zero HRESULT value.
3147 */
3148 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
3149 {
3150 HRESULT hr;
3151
3152 TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
3153
3154 if (!abc) return E_INVALIDARG;
3155 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3156
3157 if (!get_cache_glyph_widths(psc, glyph, abc))
3158 {
3159 if (!hdc) return E_PENDING;
3160 if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
3161 {
3162 if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
3163 }
3164 else
3165 {
3166 INT width;
3167 if (!GetCharWidth32W(hdc, glyph, glyph, &width)) return S_FALSE;
3168 abc->abcB = width;
3169 abc->abcA = abc->abcC = 0;
3170 }
3171 set_cache_glyph_widths(psc, glyph, abc);
3172 }
3173 return S_OK;
3174 }
3175
3176 /***********************************************************************
3177 * ScriptLayout (USP10.@)
3178 *
3179 * Map embedding levels to visual and/or logical order.
3180 *
3181 * PARAMS
3182 * runs [I] Size of level array.
3183 * level [I] Array of embedding levels.
3184 * vistolog [O] Map of embedding levels from visual to logical order.
3185 * logtovis [O] Map of embedding levels from logical to visual order.
3186 *
3187 * RETURNS
3188 * Success: S_OK
3189 * Failure: Non-zero HRESULT value.
3190 *
3191 * BUGS
3192 * This stub works correctly for any sequence of a single
3193 * embedding level but not for sequences of different
3194 * embedding levels, i.e. mixtures of RTL and LTR scripts.
3195 */
3196 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
3197 {
3198 int* indexs;
3199 int ich;
3200
3201 TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
3202
3203 if (!level || (!vistolog && !logtovis))
3204 return E_INVALIDARG;
3205
3206 indexs = heap_alloc(sizeof(int) * runs);
3207 if (!indexs)
3208 return E_OUTOFMEMORY;
3209
3210
3211 if (vistolog)
3212 {
3213 for( ich = 0; ich < runs; ich++)
3214 indexs[ich] = ich;
3215
3216 ich = 0;
3217 while (ich < runs)
3218 ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
3219 for (ich = 0; ich < runs; ich++)
3220 vistolog[ich] = indexs[ich];
3221 }
3222
3223
3224 if (logtovis)
3225 {
3226 for( ich = 0; ich < runs; ich++)
3227 indexs[ich] = ich;
3228
3229 ich = 0;
3230 while (ich < runs)
3231 ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
3232 for (ich = 0; ich < runs; ich++)
3233 logtovis[ich] = indexs[ich];
3234 }
3235 heap_free(indexs);
3236
3237 return S_OK;
3238 }
3239
3240 /***********************************************************************
3241 * ScriptStringGetLogicalWidths (USP10.@)
3242 *
3243 * Returns logical widths from a string analysis.
3244 *
3245 * PARAMS
3246 * ssa [I] string analysis.
3247 * piDx [O] logical widths returned.
3248 *
3249 * RETURNS
3250 * Success: S_OK
3251 * Failure: a non-zero HRESULT.
3252 */
3253 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
3254 {
3255 int i, j, next = 0;
3256 StringAnalysis *analysis = ssa;
3257
3258 TRACE("%p, %p\n", ssa, piDx);
3259
3260 if (!analysis) return S_FALSE;
3261 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
3262
3263 for (i = 0; i < analysis->numItems; i++)
3264 {
3265 int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
3266 int direction = 1;
3267
3268 if (analysis->pItem[i].a.fRTL && ! analysis->pItem[i].a.fLogicalOrder)
3269 direction = -1;
3270
3271 for (j = 0; j < cChar; j++)
3272 {
3273 int k;
3274 int glyph = analysis->glyphs[i].pwLogClust[j];
3275 int clust_size = get_cluster_size(analysis->glyphs[i].pwLogClust,
3276 cChar, j, direction, NULL, NULL);
3277 int advance = get_glyph_cluster_advance(analysis->glyphs[i].piAdvance, analysis->glyphs[i].psva, analysis->glyphs[i].pwLogClust, analysis->glyphs[i].numGlyphs, cChar, glyph, direction);
3278
3279 for (k = 0; k < clust_size; k++)
3280 {
3281 piDx[next] = advance / clust_size;
3282 next++;
3283 if (k) j++;
3284 }
3285 }
3286 }
3287 return S_OK;
3288 }
3289
3290 /***********************************************************************
3291 * ScriptStringValidate (USP10.@)
3292 *
3293 * Validate a string analysis.
3294 *
3295 * PARAMS
3296 * ssa [I] string analysis.
3297 *
3298 * RETURNS
3299 * Success: S_OK
3300 * Failure: S_FALSE if invalid sequences are found
3301 * or a non-zero HRESULT if it fails.
3302 */
3303 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
3304 {
3305 StringAnalysis *analysis = ssa;
3306
3307 TRACE("(%p)\n", ssa);
3308
3309 if (!analysis) return E_INVALIDARG;
3310 return (analysis->invalid) ? S_FALSE : S_OK;
3311 }
3312
3313 /***********************************************************************
3314 * ScriptString_pSize (USP10.@)
3315 *
3316 * Retrieve width and height of an analysed string.
3317 *
3318 * PARAMS
3319 * ssa [I] string analysis.
3320 *
3321 * RETURNS
3322 * Success: Pointer to a SIZE structure.
3323 * Failure: NULL
3324 */
3325 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
3326 {
3327 int i, j;
3328 StringAnalysis *analysis = ssa;
3329
3330 TRACE("(%p)\n", ssa);
3331
3332 if (!analysis) return NULL;
3333 if (!(analysis->dwFlags & SSA_GLYPHS)) return NULL;
3334
3335 if (!analysis->sz)
3336 {
3337 if (!(analysis->sz = heap_alloc(sizeof(SIZE)))) return NULL;
3338 analysis->sz->cy = analysis->glyphs[0].sc->tm.tmHeight;
3339
3340 analysis->sz->cx = 0;
3341 for (i = 0; i < analysis->numItems; i++)
3342 {
3343 if (analysis->glyphs[i].sc->tm.tmHeight > analysis->sz->cy)
3344 analysis->sz->cy = analysis->glyphs[i].sc->tm.tmHeight;
3345 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
3346 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
3347 }
3348 }
3349 return analysis->sz;
3350 }
3351
3352 /***********************************************************************
3353 * ScriptString_pLogAttr (USP10.@)
3354 *
3355 * Retrieve logical attributes of an analysed string.
3356 *
3357 * PARAMS
3358 * ssa [I] string analysis.
3359 *
3360 * RETURNS
3361 * Success: Pointer to an array of SCRIPT_LOGATTR structures.
3362 * Failure: NULL
3363 */
3364 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
3365 {
3366 StringAnalysis *analysis = ssa;
3367
3368 TRACE("(%p)\n", ssa);
3369
3370 if (!analysis) return NULL;
3371 if (!(analysis->dwFlags & SSA_BREAK)) return NULL;
3372 return analysis->logattrs;
3373 }
3374
3375 /***********************************************************************
3376 * ScriptString_pcOutChars (USP10.@)
3377 *
3378 * Retrieve the length of a string after clipping.
3379 *
3380 * PARAMS
3381 * ssa [I] String analysis.
3382 *
3383 * RETURNS
3384 * Success: Pointer to the length.
3385 * Failure: NULL
3386 */
3387 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
3388 {
3389 StringAnalysis *analysis = ssa;
3390
3391 TRACE("(%p)\n", ssa);
3392
3393 if (!analysis) return NULL;
3394 return &analysis->clip_len;
3395 }
3396
3397 /***********************************************************************
3398 * ScriptStringGetOrder (USP10.@)
3399 *
3400 * Retrieve a glyph order map.
3401 *
3402 * PARAMS
3403 * ssa [I] String analysis.
3404 * order [I/O] Array of glyph positions.
3405 *
3406 * RETURNS
3407 * Success: S_OK
3408 * Failure: a non-zero HRESULT.
3409 */
3410 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
3411 {
3412 int i, j;
3413 unsigned int k;
3414 StringAnalysis *analysis = ssa;
3415
3416 TRACE("(%p)\n", ssa);
3417
3418 if (!analysis) return S_FALSE;
3419 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
3420
3421 /* FIXME: handle RTL scripts */
3422 for (i = 0, k = 0; i < analysis->numItems; i++)
3423 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
3424 order[k] = k;
3425
3426 return S_OK;
3427 }
3428
3429 /***********************************************************************
3430 * ScriptGetLogicalWidths (USP10.@)
3431 *
3432 * Convert advance widths to logical widths.
3433 *
3434 * PARAMS
3435 * sa [I] Script analysis.
3436 * nbchars [I] Number of characters.
3437 * nbglyphs [I] Number of glyphs.
3438 * glyph_width [I] Array of glyph widths.
3439 * log_clust [I] Array of logical clusters.
3440 * sva [I] Visual attributes.
3441 * widths [O] Array of logical widths.
3442 *
3443 * RETURNS
3444 * Success: S_OK
3445 * Failure: a non-zero HRESULT.
3446 */
3447 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
3448 const int *glyph_width, const WORD *log_clust,
3449 const SCRIPT_VISATTR *sva, int *widths)
3450 {
3451 int i;
3452
3453 TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
3454 sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
3455
3456 /* FIXME */
3457 for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
3458 return S_OK;
3459 }
3460
3461 /***********************************************************************
3462 * ScriptApplyLogicalWidth (USP10.@)
3463 *
3464 * Generate glyph advance widths.
3465 *
3466 * PARAMS
3467 * dx [I] Array of logical advance widths.
3468 * num_chars [I] Number of characters.
3469 * num_glyphs [I] Number of glyphs.
3470 * log_clust [I] Array of logical clusters.
3471 * sva [I] Visual attributes.
3472 * advance [I] Array of glyph advance widths.
3473 * sa [I] Script analysis.
3474 * abc [I/O] Summed ABC widths.
3475 * justify [O] Array of glyph advance widths.
3476 *
3477 * RETURNS
3478 * Success: S_OK
3479 * Failure: a non-zero HRESULT.
3480 */
3481 HRESULT WINAPI ScriptApplyLogicalWidth(const int *dx, int num_chars, int num_glyphs,
3482 const WORD *log_clust, const SCRIPT_VISATTR *sva,
3483 const int *advance, const SCRIPT_ANALYSIS *sa,
3484 ABC *abc, int *justify)
3485 {
3486 int i;
3487
3488 FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
3489 dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
3490
3491 for (i = 0; i < num_chars; i++) justify[i] = advance[i];
3492 return S_OK;
3493 }
3494
3495 HRESULT WINAPI ScriptJustify(const SCRIPT_VISATTR *sva, const int *advance,
3496 int num_glyphs, int dx, int min_kashida, int *justify)
3497 {
3498 int i;
3499
3500 FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
3501
3502 for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
3503 return S_OK;
3504 }
Maarten's multimedia branch