?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usp10: Cache FontScriptTags information.
[wine.git] / dlls / usp10 / usp10.c
blobe9278b336ec645e603a750b2f065536c618fcd3b
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 {{Script_Hebrew_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
628 {LANG_HEBREW, 0, 1, 0, 0, HEBREW_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
629 MS_MAKE_TAG('h','e','b','r'),
630 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
631 {{Script_Vietnamese_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
632 {LANG_VIETNAMESE, 0, 0, 0, 0, VIETNAMESE_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
633 MS_MAKE_TAG('l','a','t','n'),
634 {0}},
635 {{Script_Thai_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
636 {LANG_THAI, 0, 1, 0, 0, THAI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
637 MS_MAKE_TAG('t','h','a','i'),
638 {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
639 };
640
641 static const SCRIPT_PROPERTIES *script_props[] =
642 {
643 &scriptInformation[0].props, &scriptInformation[1].props,
644 &scriptInformation[2].props, &scriptInformation[3].props,
645 &scriptInformation[4].props, &scriptInformation[5].props,
646 &scriptInformation[6].props, &scriptInformation[7].props,
647 &scriptInformation[8].props, &scriptInformation[9].props,
648 &scriptInformation[10].props, &scriptInformation[11].props,
649 &scriptInformation[12].props, &scriptInformation[13].props,
650 &scriptInformation[14].props, &scriptInformation[15].props,
651 &scriptInformation[16].props, &scriptInformation[17].props,
652 &scriptInformation[18].props, &scriptInformation[19].props,
653 &scriptInformation[20].props, &scriptInformation[21].props,
654 &scriptInformation[22].props, &scriptInformation[23].props,
655 &scriptInformation[24].props, &scriptInformation[25].props,
656 &scriptInformation[26].props, &scriptInformation[27].props,
657 &scriptInformation[28].props, &scriptInformation[29].props,
658 &scriptInformation[30].props, &scriptInformation[31].props,
659 &scriptInformation[32].props, &scriptInformation[33].props,
660 &scriptInformation[34].props, &scriptInformation[35].props,
661 &scriptInformation[36].props, &scriptInformation[37].props,
662 &scriptInformation[38].props, &scriptInformation[39].props,
663 &scriptInformation[40].props, &scriptInformation[41].props,
664 &scriptInformation[42].props, &scriptInformation[43].props,
665 &scriptInformation[44].props, &scriptInformation[45].props,
666 &scriptInformation[46].props, &scriptInformation[47].props,
667 &scriptInformation[48].props, &scriptInformation[49].props,
668 &scriptInformation[50].props, &scriptInformation[51].props,
669 &scriptInformation[52].props, &scriptInformation[53].props,
670 &scriptInformation[54].props, &scriptInformation[55].props,
671 &scriptInformation[56].props, &scriptInformation[57].props,
672 &scriptInformation[58].props, &scriptInformation[59].props,
673 &scriptInformation[60].props, &scriptInformation[61].props,
674 &scriptInformation[62].props, &scriptInformation[63].props,
675 &scriptInformation[64].props, &scriptInformation[65].props,
676 &scriptInformation[66].props, &scriptInformation[67].props,
677 &scriptInformation[68].props, &scriptInformation[69].props,
678 &scriptInformation[70].props, &scriptInformation[71].props,
679 &scriptInformation[72].props, &scriptInformation[73].props,
680 &scriptInformation[74].props, &scriptInformation[75].props,
681 &scriptInformation[76].props, &scriptInformation[77].props,
682 &scriptInformation[78].props, &scriptInformation[79].props,
683 &scriptInformation[80].props, &scriptInformation[81].props
684 };
685
686 typedef struct {
687 ScriptCache *sc;
688 int numGlyphs;
689 WORD* glyphs;
690 WORD* pwLogClust;
691 int* piAdvance;
692 SCRIPT_VISATTR* psva;
693 GOFFSET* pGoffset;
694 ABC* abc;
695 int iMaxPosX;
696 HFONT fallbackFont;
697 } StringGlyphs;
698
699 typedef struct {
700 HDC hdc;
701 DWORD dwFlags;
702 BOOL invalid;
703 int clip_len;
704 int cItems;
705 int cMaxGlyphs;
706 SCRIPT_ITEM* pItem;
707 int numItems;
708 StringGlyphs* glyphs;
709 SCRIPT_LOGATTR* logattrs;
710 SIZE* sz;
711 int* logical2visual;
712 } StringAnalysis;
713
714 static inline void *heap_alloc(SIZE_T size)
715 {
716 return HeapAlloc(GetProcessHeap(), 0, size);
717 }
718
719 static inline void *heap_alloc_zero(SIZE_T size)
720 {
721 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
722 }
723
724 static inline void *heap_realloc_zero(LPVOID mem, SIZE_T size)
725 {
726 return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
727 }
728
729 static inline BOOL heap_free(LPVOID mem)
730 {
731 return HeapFree(GetProcessHeap(), 0, mem);
732 }
733
734 static inline WCHAR get_cache_default_char(SCRIPT_CACHE *psc)
735 {
736 return ((ScriptCache *)*psc)->tm.tmDefaultChar;
737 }
738
739 static inline LONG get_cache_height(SCRIPT_CACHE *psc)
740 {
741 return ((ScriptCache *)*psc)->tm.tmHeight;
742 }
743
744 static inline BYTE get_cache_pitch_family(SCRIPT_CACHE *psc)
745 {
746 return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
747 }
748
749 static inline WORD get_cache_glyph(SCRIPT_CACHE *psc, DWORD c)
750 {
751 WORD *block = ((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
752
753 if (!block) return 0;
754 return block[c & GLYPH_BLOCK_MASK];
755 }
756
757 static inline WORD set_cache_glyph(SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
758 {
759 WORD **block = &((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
760
761 if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
762 return ((*block)[c & GLYPH_BLOCK_MASK] = glyph);
763 }
764
765 static inline BOOL get_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
766 {
767 static const ABC nil;
768 ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
769
770 if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
771 memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
772 return TRUE;
773 }
774
775 static inline BOOL set_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
776 {
777 ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
778
779 if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
780 memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
781 return TRUE;
782 }
783
784 static HRESULT init_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
785 {
786 ScriptCache *sc;
787
788 if (!psc) return E_INVALIDARG;
789 if (*psc) return S_OK;
790 if (!hdc) return E_PENDING;
791
792 if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
793 if (!GetTextMetricsW(hdc, &sc->tm))
794 {
795 heap_free(sc);
796 return E_INVALIDARG;
797 }
798 if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(LOGFONTW), &sc->lf))
799 {
800 heap_free(sc);
801 return E_INVALIDARG;
802 }
803 sc->sfnt = (GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, NULL, 0)!=GDI_ERROR);
804 *psc = sc;
805 TRACE("<- %p\n", sc);
806 return S_OK;
807 }
808
809 static WCHAR mirror_char( WCHAR ch )
810 {
811 extern const WCHAR wine_mirror_map[];
812 return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
813 }
814
815 static inline DWORD decode_surrogate_pair(LPCWSTR str, INT index, INT end)
816 {
817 if (index < end-1 && IS_SURROGATE_PAIR(str[index],str[index+1]))
818 {
819 DWORD ch = 0x10000 + ((str[index] - 0xd800) << 10) + (str[index+1] - 0xdc00);
820 TRACE("Surrogate Pair %x %x => %x\n",str[index], str[index+1], ch);
821 return ch;
822 }
823 return 0;
824 }
825
826 static WORD get_char_script( LPCWSTR str, INT index, INT end, INT *consumed)
827 {
828 static const WCHAR latin_punc[] = {'#','$','&','\'',',',';','<','>','?','@','\\','^','_','`','{','|','}','~', 0x00a0, 0};
829 WORD type = 0;
830 DWORD ch;
831 int i;
832
833 *consumed = 1;
834
835 if (str[index] == 0xc || str[index] == 0x20 || str[index] == 0x202f)
836 return Script_CR;
837
838 /* These punctuation are separated out as Latin punctuation */
839 if (strchrW(latin_punc,str[index]))
840 return Script_Punctuation2;
841
842 /* These chars are itemized as Punctuation by Windows */
843 if (str[index] == 0x2212 || str[index] == 0x2044)
844 return Script_Punctuation;
845
846 /* Currency Symboles by Unicode point */
847 switch (str[index])
848 {
849 case 0x09f2:
850 case 0x09f3: return Script_Bengali_Currency;
851 case 0x0af1: return Script_Gujarati_Currency;
852 case 0x0e3f: return Script_Thai_Currency;
853 case 0x20aa: return Script_Hebrew_Currency;
854 case 0x20ab: return Script_Vietnamese_Currency;
855 case 0xfb29: return Script_Hebrew_Currency;
856 }
857
858 GetStringTypeW(CT_CTYPE1, &str[index], 1, &type);
859
860 if (type == 0)
861 return SCRIPT_UNDEFINED;
862
863 if (type & C1_CNTRL)
864 return Script_Control;
865
866 ch = decode_surrogate_pair(str, index, end);
867 if (ch)
868 *consumed = 2;
869 else
870 ch = str[index];
871
872 i = 0;
873 do
874 {
875 if (ch < scriptRanges[i].rangeFirst || scriptRanges[i].script == SCRIPT_UNDEFINED)
876 break;
877
878 if (ch >= scriptRanges[i].rangeFirst && ch <= scriptRanges[i].rangeLast)
879 {
880 if (scriptRanges[i].numericScript && type & C1_DIGIT)
881 return scriptRanges[i].numericScript;
882 if (scriptRanges[i].punctScript && type & C1_PUNCT)
883 return scriptRanges[i].punctScript;
884 return scriptRanges[i].script;
885 }
886 i++;
887 } while (1);
888
889 return SCRIPT_UNDEFINED;
890 }
891
892 /***********************************************************************
893 * DllMain
894 *
895 */
896 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
897 {
898 switch(fdwReason)
899 {
900 case DLL_PROCESS_ATTACH:
901 DisableThreadLibraryCalls(hInstDLL);
902 break;
903 case DLL_PROCESS_DETACH:
904 break;
905 }
906 return TRUE;
907 }
908
909 /***********************************************************************
910 * ScriptFreeCache (USP10.@)
911 *
912 * Free a script cache.
913 *
914 * PARAMS
915 * psc [I/O] Script cache.
916 *
917 * RETURNS
918 * Success: S_OK
919 * Failure: Non-zero HRESULT value.
920 */
921 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
922 {
923 TRACE("%p\n", psc);
924
925 if (psc && *psc)
926 {
927 unsigned int i;
928 for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
929 {
930 heap_free(((ScriptCache *)*psc)->glyphs[i]);
931 heap_free(((ScriptCache *)*psc)->widths[i]);
932 }
933 heap_free(((ScriptCache *)*psc)->GSUB_Table);
934 heap_free(((ScriptCache *)*psc)->GDEF_Table);
935 heap_free(((ScriptCache *)*psc)->CMAP_Table);
936 heap_free(((ScriptCache *)*psc)->scripts);
937 heap_free(((ScriptCache *)*psc)->features);
938 heap_free(*psc);
939 *psc = NULL;
940 }
941 return S_OK;
942 }
943
944 /***********************************************************************
945 * ScriptGetProperties (USP10.@)
946 *
947 * Retrieve a list of script properties.
948 *
949 * PARAMS
950 * props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
951 * num [I] Pointer to the number of scripts.
952 *
953 * RETURNS
954 * Success: S_OK
955 * Failure: Non-zero HRESULT value.
956 *
957 * NOTES
958 * Behaviour matches WinXP.
959 */
960 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
961 {
962 TRACE("(%p,%p)\n", props, num);
963
964 if (!props && !num) return E_INVALIDARG;
965
966 if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
967 if (props) *props = script_props;
968
969 return S_OK;
970 }
971
972 /***********************************************************************
973 * ScriptGetFontProperties (USP10.@)
974 *
975 * Get information on special glyphs.
976 *
977 * PARAMS
978 * hdc [I] Device context.
979 * psc [I/O] Opaque pointer to a script cache.
980 * sfp [O] Font properties structure.
981 */
982 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
983 {
984 HRESULT hr;
985
986 TRACE("%p,%p,%p\n", hdc, psc, sfp);
987
988 if (!sfp) return E_INVALIDARG;
989 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
990
991 if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
992 return E_INVALIDARG;
993
994 /* return something sensible? */
995 sfp->wgBlank = 0;
996 sfp->wgDefault = get_cache_default_char(psc);
997 sfp->wgInvalid = 0;
998 sfp->wgKashida = 0xffff;
999 sfp->iKashidaWidth = 0;
1000
1001 return S_OK;
1002 }
1003
1004 /***********************************************************************
1005 * ScriptRecordDigitSubstitution (USP10.@)
1006 *
1007 * Record digit substitution settings for a given locale.
1008 *
1009 * PARAMS
1010 * locale [I] Locale identifier.
1011 * sds [I] Structure to record substitution settings.
1012 *
1013 * RETURNS
1014 * Success: S_OK
1015 * Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
1016 *
1017 * SEE ALSO
1018 * http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
1019 */
1020 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
1021 {
1022 DWORD plgid, sub;
1023
1024 TRACE("0x%x, %p\n", locale, sds);
1025
1026 /* This implementation appears to be correct for all languages, but it's
1027 * not clear if sds->DigitSubstitute is ever set to anything except
1028 * CONTEXT or NONE in reality */
1029
1030 if (!sds) return E_POINTER;
1031
1032 locale = ConvertDefaultLocale(locale);
1033
1034 if (!IsValidLocale(locale, LCID_INSTALLED))
1035 return E_INVALIDARG;
1036
1037 plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
1038 sds->TraditionalDigitLanguage = plgid;
1039
1040 if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
1041 sds->NationalDigitLanguage = plgid;
1042 else
1043 sds->NationalDigitLanguage = LANG_ENGLISH;
1044
1045 if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
1046 (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
1047
1048 switch (sub)
1049 {
1050 case 0:
1051 if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
1052 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
1053 else
1054 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
1055 break;
1056 case 1:
1057 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
1058 break;
1059 case 2:
1060 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
1061 break;
1062 default:
1063 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
1064 break;
1065 }
1066
1067 sds->dwReserved = 0;
1068 return S_OK;
1069 }
1070
1071 /***********************************************************************
1072 * ScriptApplyDigitSubstitution (USP10.@)
1073 *
1074 * Apply digit substitution settings.
1075 *
1076 * PARAMS
1077 * sds [I] Structure with recorded substitution settings.
1078 * sc [I] Script control structure.
1079 * ss [I] Script state structure.
1080 *
1081 * RETURNS
1082 * Success: S_OK
1083 * Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
1084 */
1085 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds,
1086 SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
1087 {
1088 SCRIPT_DIGITSUBSTITUTE psds;
1089
1090 TRACE("%p, %p, %p\n", sds, sc, ss);
1091
1092 if (!sc || !ss) return E_POINTER;
1093 if (!sds)
1094 {
1095 sds = &psds;
1096 if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
1097 return E_INVALIDARG;
1098 }
1099
1100 sc->uDefaultLanguage = LANG_ENGLISH;
1101 sc->fContextDigits = 0;
1102 ss->fDigitSubstitute = 0;
1103
1104 switch (sds->DigitSubstitute) {
1105 case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
1106 case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
1107 case SCRIPT_DIGITSUBSTITUTE_NONE:
1108 case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
1109 return S_OK;
1110 default:
1111 return E_INVALIDARG;
1112 }
1113 }
1114
1115 static inline BOOL is_indic(WORD script)
1116 {
1117 return (script >= Script_Devanagari && script <= Script_Malayalam_Numeric);
1118 }
1119
1120 static inline WORD base_indic(WORD script)
1121 {
1122 switch (script)
1123 {
1124 case Script_Devanagari:
1125 case Script_Devanagari_Numeric: return Script_Devanagari;
1126 case Script_Bengali:
1127 case Script_Bengali_Numeric:
1128 case Script_Bengali_Currency: return Script_Bengali;
1129 case Script_Gurmukhi:
1130 case Script_Gurmukhi_Numeric: return Script_Gurmukhi;
1131 case Script_Gujarati:
1132 case Script_Gujarati_Numeric:
1133 case Script_Gujarati_Currency: return Script_Gujarati;
1134 case Script_Oriya:
1135 case Script_Oriya_Numeric: return Script_Oriya;
1136 case Script_Tamil:
1137 case Script_Tamil_Numeric: return Script_Tamil;
1138 case Script_Telugu:
1139 case Script_Telugu_Numeric: return Script_Telugu;
1140 case Script_Kannada:
1141 case Script_Kannada_Numeric: return Script_Kannada;
1142 case Script_Malayalam:
1143 case Script_Malayalam_Numeric: return Script_Malayalam;
1144 default:
1145 return -1;
1146 };
1147 }
1148
1149 /***********************************************************************
1150 * ScriptItemizeOpenType (USP10.@)
1151 *
1152 * Split a Unicode string into shapeable parts.
1153 *
1154 * PARAMS
1155 * pwcInChars [I] String to split.
1156 * cInChars [I] Number of characters in pwcInChars.
1157 * cMaxItems [I] Maximum number of items to return.
1158 * psControl [I] Pointer to a SCRIPT_CONTROL structure.
1159 * psState [I] Pointer to a SCRIPT_STATE structure.
1160 * pItems [O] Buffer to receive SCRIPT_ITEM structures.
1161 * pScriptTags [O] Buffer to receive OPENTYPE_TAGs.
1162 * pcItems [O] Number of script items returned.
1163 *
1164 * RETURNS
1165 * Success: S_OK
1166 * Failure: Non-zero HRESULT value.
1167 */
1168 HRESULT WINAPI ScriptItemizeOpenType(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
1169 const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
1170 SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
1171 {
1172
1173 #define Numeric_space 0x0020
1174 #define ZWNJ 0x200C
1175 #define ZWJ 0x200D
1176
1177 int cnt = 0, index = 0, str = 0;
1178 int New_Script = -1;
1179 int i;
1180 WORD *levels = NULL;
1181 WORD *strength = NULL;
1182 WORD *scripts = NULL;
1183 WORD baselevel = 0;
1184 BOOL new_run;
1185 WORD last_indic = -1;
1186 WORD layoutRTL = 0;
1187 BOOL forceLevels = FALSE;
1188 INT consumed = 0;
1189
1190 TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems,
1191 psControl, psState, pItems, pcItems);
1192
1193 if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
1194 return E_INVALIDARG;
1195
1196 scripts = heap_alloc(cInChars * sizeof(WORD));
1197 if (!scripts)
1198 return E_OUTOFMEMORY;
1199
1200 for (i = 0; i < cInChars; i++)
1201 {
1202 if (consumed <= 0)
1203 {
1204 scripts[i] = get_char_script(pwcInChars,i,cInChars,&consumed);
1205 consumed --;
1206 }
1207 else
1208 {
1209 scripts[i] = scripts[i-1];
1210 consumed --;
1211 }
1212 /* Devanagari danda (U+0964) and double danda (U+0965) are used for
1213 all Indic scripts */
1214 if ((pwcInChars[i] == 0x964 || pwcInChars[i] ==0x965) && last_indic > 0)
1215 scripts[i] = last_indic;
1216 else if (is_indic(scripts[i]))
1217 last_indic = base_indic(scripts[i]);
1218
1219 /* Some unicode points (Zero Width Space U+200B -
1220 Right-to-Left Mark U+200F) will force us into bidi mode */
1221 if (!forceLevels && pwcInChars[i] >= 0x200B && pwcInChars[i] <= 0x200F)
1222 forceLevels = TRUE;
1223
1224 /* Diacritical marks merge with other scripts */
1225 if (scripts[i] == Script_Diacritical && i > 0)
1226 scripts[i] = scripts[i-1];
1227 }
1228
1229 for (i = 0; i < cInChars; i++)
1230 {
1231 /* Joiners get merged preferencially right */
1232 if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ))
1233 {
1234 int j;
1235 if (i+1 == cInChars)
1236 scripts[i] = scripts[i-1];
1237 else
1238 {
1239 for (j = i+1; j < cInChars; j++)
1240 {
1241 if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ && pwcInChars[j] != Numeric_space)
1242 {
1243 scripts[i] = scripts[j];
1244 break;
1245 }
1246 }
1247 }
1248 }
1249 }
1250
1251 if (psState && psControl)
1252 {
1253 levels = heap_alloc_zero(cInChars * sizeof(WORD));
1254 if (!levels)
1255 {
1256 heap_free(scripts);
1257 return E_OUTOFMEMORY;
1258 }
1259
1260 BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels);
1261 baselevel = levels[0];
1262 for (i = 0; i < cInChars; i++)
1263 if (levels[i]!=levels[0])
1264 break;
1265 if (i >= cInChars && !odd(baselevel) && !odd(psState->uBidiLevel) && !forceLevels)
1266 {
1267 heap_free(levels);
1268 levels = NULL;
1269 }
1270 else
1271 {
1272 BOOL inNumber = FALSE;
1273 static WCHAR math_punc[] = {'#','$','%','+',',','-','.','/',':',0x2212, 0x2044, 0x00a0,0};
1274
1275 strength = heap_alloc_zero(cInChars * sizeof(WORD));
1276 if (!strength)
1277 {
1278 heap_free(scripts);
1279 heap_free(levels);
1280 return E_OUTOFMEMORY;
1281 }
1282 BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
1283
1284 /* We currently mis-level leading Diacriticals */
1285 if (scripts[0] == Script_Diacritical)
1286 for (i = 0; i < cInChars && scripts[0] == Script_Diacritical; i++)
1287 {
1288 levels[i] = odd(levels[i])?levels[i]+1:levels[i];
1289 strength[i] = BIDI_STRONG;
1290 }
1291
1292 for (i = 0; i < cInChars; i++)
1293 {
1294 /* Script_Numeric and select puncuation at level 0 get bumped to level 2 */
1295 if ((levels[i] == 0 || (odd(psState->uBidiLevel) && levels[i] == psState->uBidiLevel+1)) && inNumber && strchrW(math_punc,pwcInChars[i]))
1296 {
1297 scripts[i] = Script_Numeric;
1298 levels[i] = 2;
1299 }
1300 else if ((levels[i] == 0 || (odd(psState->uBidiLevel) && levels[i] == psState->uBidiLevel+1)) && scripts[i] == Script_Numeric)
1301 {
1302 levels[i] = 2;
1303 inNumber = TRUE;
1304 }
1305 else
1306 inNumber = FALSE;
1307
1308 /* Joiners get merged preferencially right */
1309 if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ))
1310 {
1311 int j;
1312 if (i+1 == cInChars && levels[i-1] == levels[i])
1313 strength[i] = strength[i-1];
1314 else
1315 for (j = i+1; j < cInChars && levels[i] == levels[j]; j++)
1316 if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ && pwcInChars[j] != Numeric_space)
1317 {
1318 strength[i] = strength[j];
1319 break;
1320 }
1321 }
1322 }
1323 if (psControl->fMergeNeutralItems)
1324 {
1325 /* Merge the neutrals */
1326 for (i = 0; i < cInChars; i++)
1327 {
1328 if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
1329 {
1330 int j;
1331 for (j = i; j > 0; j--)
1332 {
1333 if (levels[i] != levels[j])
1334 break;
1335 if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
1336 {
1337 scripts[i] = scripts[j];
1338 strength[i] = strength[j];
1339 break;
1340 }
1341 }
1342 }
1343 /* Try going the other way */
1344 if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
1345 {
1346 int j;
1347 for (j = i; j < cInChars; j++)
1348 {
1349 if (levels[i] != levels[j])
1350 break;
1351 if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
1352 {
1353 scripts[i] = scripts[j];
1354 strength[i] = strength[j];
1355 break;
1356 }
1357 }
1358 }
1359 }
1360 }
1361 }
1362 }
1363
1364 while ((!levels || (levels && levels[cnt+1] == levels[0])) && (pwcInChars[cnt] == Numeric_space) && cnt < cInChars)
1365 cnt++;
1366
1367 if (cnt == cInChars) /* All Spaces */
1368 {
1369 cnt = 0;
1370 New_Script = scripts[cnt];
1371 }
1372
1373 pItems[index].iCharPos = 0;
1374 pItems[index].a = scriptInformation[scripts[cnt]].a;
1375 pScriptTags[index] = scriptInformation[scripts[cnt]].scriptTag;
1376
1377 if (strength && strength[cnt] == BIDI_STRONG)
1378 str = strength[cnt];
1379 else if (strength)
1380 str = strength[0];
1381
1382 cnt = 0;
1383
1384 if (levels)
1385 {
1386 if (strength[cnt] == BIDI_STRONG)
1387 layoutRTL = (odd(levels[cnt]))?1:0;
1388 else
1389 layoutRTL = (psState->uBidiLevel || odd(levels[cnt]))?1:0;
1390 pItems[index].a.fRTL = odd(levels[cnt]);
1391 pItems[index].a.fLayoutRTL = layoutRTL;
1392 pItems[index].a.s.uBidiLevel = levels[cnt];
1393 }
1394 else if (!pItems[index].a.s.uBidiLevel)
1395 {
1396 layoutRTL = (odd(baselevel))?1:0;
1397 pItems[index].a.s.uBidiLevel = baselevel;
1398 pItems[index].a.fLayoutRTL = odd(baselevel);
1399 pItems[index].a.fRTL = odd(baselevel);
1400 }
1401
1402 TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
1403 levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
1404 pItems[index].iCharPos);
1405
1406 for (cnt=1; cnt < cInChars; cnt++)
1407 {
1408 if(pwcInChars[cnt] != Numeric_space)
1409 New_Script = scripts[cnt];
1410 else if (levels)
1411 {
1412 int j = 1;
1413 while (cnt + j < cInChars - 1 && pwcInChars[cnt+j] == Numeric_space && levels[cnt] == levels[cnt+j])
1414 j++;
1415 if (cnt + j < cInChars && levels[cnt] == levels[cnt+j])
1416 New_Script = scripts[cnt+j];
1417 else
1418 New_Script = scripts[cnt];
1419 }
1420
1421 new_run = FALSE;
1422 /* merge space strengths*/
1423 if (strength && strength[cnt] == BIDI_STRONG && str != BIDI_STRONG && New_Script == pItems[index].a.eScript)
1424 str = BIDI_STRONG;
1425
1426 if (strength && strength[cnt] == BIDI_NEUTRAL && str == BIDI_STRONG && pwcInChars[cnt] != Numeric_space && New_Script == pItems[index].a.eScript)
1427 str = BIDI_NEUTRAL;
1428
1429 /* changes in level */
1430 if (levels && (levels[cnt] != pItems[index].a.s.uBidiLevel))
1431 {
1432 TRACE("Level break(%i/%i)\n",pItems[index].a.s.uBidiLevel,levels[cnt]);
1433 new_run = TRUE;
1434 }
1435 /* changes in strength */
1436 else if (strength && pwcInChars[cnt] != Numeric_space && str != strength[cnt])
1437 {
1438 TRACE("Strength break (%i/%i)\n",str,strength[cnt]);
1439 new_run = TRUE;
1440 }
1441 /* changes in script */
1442 else if (((pwcInChars[cnt] != Numeric_space) && (New_Script != -1) && (New_Script != pItems[index].a.eScript)) || (New_Script == Script_Control))
1443 {
1444 TRACE("Script break(%i/%i)\n",pItems[index].a.eScript,New_Script);
1445 new_run = TRUE;
1446 }
1447
1448 if (!new_run && strength && str == BIDI_STRONG)
1449 {
1450 layoutRTL = odd(levels[cnt])?1:0;
1451 pItems[index].a.fLayoutRTL = layoutRTL;
1452 }
1453
1454 if (new_run)
1455 {
1456 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);
1457
1458 index++;
1459 if (index+1 > cMaxItems)
1460 return E_OUTOFMEMORY;
1461
1462 if (strength)
1463 str = strength[cnt];
1464
1465 pItems[index].iCharPos = cnt;
1466 memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
1467
1468 pItems[index].a = scriptInformation[New_Script].a;
1469 pScriptTags[index] = scriptInformation[New_Script].scriptTag;
1470 if (levels)
1471 {
1472 if (levels[cnt] == 0)
1473 layoutRTL = 0;
1474 else
1475 layoutRTL = (layoutRTL || odd(levels[cnt]))?1:0;
1476 pItems[index].a.fRTL = odd(levels[cnt]);
1477 pItems[index].a.fLayoutRTL = layoutRTL;
1478 pItems[index].a.s.uBidiLevel = levels[cnt];
1479 }
1480 else if (!pItems[index].a.s.uBidiLevel)
1481 {
1482 pItems[index].a.s.uBidiLevel = baselevel;
1483 pItems[index].a.fLayoutRTL = layoutRTL;
1484 pItems[index].a.fRTL = odd(baselevel);
1485 }
1486
1487 TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
1488 }
1489 }
1490
1491 /* While not strictly necessary according to the spec, make sure the n+1
1492 * item is set up to prevent random behaviour if the caller erroneously
1493 * checks the n+1 structure */
1494 index++;
1495 memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
1496
1497 TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
1498
1499 /* Set one SCRIPT_STATE item being returned */
1500 if (index + 1 > cMaxItems) return E_OUTOFMEMORY;
1501 if (pcItems) *pcItems = index;
1502
1503 /* Set SCRIPT_ITEM */
1504 pItems[index].iCharPos = cnt; /* the last item contains the ptr to the lastchar */
1505 heap_free(levels);
1506 heap_free(strength);
1507 heap_free(scripts);
1508 return S_OK;
1509 }
1510
1511 /***********************************************************************
1512 * ScriptItemize (USP10.@)
1513 *
1514 * Split a Unicode string into shapeable parts.
1515 *
1516 * PARAMS
1517 * pwcInChars [I] String to split.
1518 * cInChars [I] Number of characters in pwcInChars.
1519 * cMaxItems [I] Maximum number of items to return.
1520 * psControl [I] Pointer to a SCRIPT_CONTROL structure.
1521 * psState [I] Pointer to a SCRIPT_STATE structure.
1522 * pItems [O] Buffer to receive SCRIPT_ITEM structures.
1523 * pcItems [O] Number of script items returned.
1524 *
1525 * RETURNS
1526 * Success: S_OK
1527 * Failure: Non-zero HRESULT value.
1528 */
1529 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
1530 const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
1531 SCRIPT_ITEM *pItems, int *pcItems)
1532 {
1533 OPENTYPE_TAG *discarded_tags;
1534 HRESULT res;
1535
1536 discarded_tags = heap_alloc(cMaxItems * sizeof(OPENTYPE_TAG));
1537 if (!discarded_tags)
1538 return E_OUTOFMEMORY;
1539 res = ScriptItemizeOpenType(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, discarded_tags, pcItems);
1540 heap_free(discarded_tags);
1541 return res;
1542 }
1543
1544 static inline int getGivenTabWidth(ScriptCache *psc, SCRIPT_TABDEF *pTabdef, int charPos, int current_x)
1545 {
1546 int defWidth;
1547 int cTabStops=0;
1548 INT *lpTabPos = NULL;
1549 INT nTabOrg = 0;
1550 INT x = 0;
1551
1552 if (pTabdef)
1553 lpTabPos = pTabdef->pTabStops;
1554
1555 if (pTabdef && pTabdef->iTabOrigin)
1556 {
1557 if (pTabdef->iScale)
1558 nTabOrg = (pTabdef->iTabOrigin * pTabdef->iScale)/4;
1559 else
1560 nTabOrg = pTabdef->iTabOrigin * psc->tm.tmAveCharWidth;
1561 }
1562
1563 if (pTabdef)
1564 cTabStops = pTabdef->cTabStops;
1565
1566 if (cTabStops == 1)
1567 {
1568 if (pTabdef->iScale)
1569 defWidth = ((pTabdef->pTabStops[0])*pTabdef->iScale) / 4;
1570 else
1571 defWidth = (pTabdef->pTabStops[0])*psc->tm.tmAveCharWidth;
1572 cTabStops = 0;
1573 }
1574 else
1575 defWidth = 8 * psc->tm.tmAveCharWidth;
1576
1577 for (; cTabStops>0 ; lpTabPos++, cTabStops--)
1578 {
1579 int position = *lpTabPos;
1580 if (position < 0)
1581 position = -1 * position;
1582 if (pTabdef->iScale)
1583 position = (position * pTabdef->iScale) / 4;
1584 else
1585 position = position * psc->tm.tmAveCharWidth;
1586
1587 if( nTabOrg + position > current_x)
1588 {
1589 if( *lpTabPos >= 0)
1590 {
1591 /* a left aligned tab */
1592 x = (nTabOrg + *lpTabPos) - current_x;
1593 break;
1594 }
1595 else
1596 {
1597 FIXME("Negative tabstop\n");
1598 break;
1599 }
1600 }
1601 }
1602 if ((!cTabStops) && (defWidth > 0))
1603 x =((((current_x - nTabOrg) / defWidth)+1) * defWidth) - current_x;
1604 else if ((!cTabStops) && (defWidth < 0))
1605 FIXME("TODO: Negative defWidth\n");
1606
1607 return x;
1608 }
1609
1610 /***********************************************************************
1611 * Helper function for ScriptStringAnalyse
1612 */
1613 static BOOL requires_fallback(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
1614 const WCHAR *pwcInChars, int cChars )
1615 {
1616 /* FIXME: When to properly fallback is still a bit of a mystery */
1617 WORD *glyphs;
1618
1619 if (psa->fNoGlyphIndex)
1620 return FALSE;
1621
1622 if (init_script_cache(hdc, psc) != S_OK)
1623 return FALSE;
1624
1625 if (SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa) != S_OK)
1626 return TRUE;
1627
1628 glyphs = heap_alloc(sizeof(WORD) * cChars);
1629 if (!glyphs)
1630 return FALSE;
1631 if (ScriptGetCMap(hdc, psc, pwcInChars, cChars, 0, glyphs) != S_OK)
1632 {
1633 heap_free(glyphs);
1634 return TRUE;
1635 }
1636 heap_free(glyphs);
1637
1638 return FALSE;
1639 }
1640
1641 static void find_fallback_font(DWORD scriptid, LPWSTR FaceName)
1642 {
1643 HKEY hkey;
1644
1645 if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Uniscribe\\Fallback", &hkey))
1646 {
1647 static const WCHAR szFmt[] = {'%','x',0};
1648 WCHAR value[10];
1649 DWORD count = LF_FACESIZE * sizeof(WCHAR);
1650 DWORD type;
1651
1652 sprintfW(value, szFmt, scriptInformation[scriptid].scriptTag);
1653 if (RegQueryValueExW(hkey, value, 0, &type, (LPBYTE)FaceName, &count))
1654 lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
1655 RegCloseKey(hkey);
1656 }
1657 else
1658 lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
1659 }
1660
1661 /***********************************************************************
1662 * ScriptStringAnalyse (USP10.@)
1663 *
1664 */
1665 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
1666 int cGlyphs, int iCharset, DWORD dwFlags,
1667 int iReqWidth, SCRIPT_CONTROL *psControl,
1668 SCRIPT_STATE *psState, const int *piDx,
1669 SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
1670 SCRIPT_STRING_ANALYSIS *pssa)
1671 {
1672 HRESULT hr = E_OUTOFMEMORY;
1673 StringAnalysis *analysis = NULL;
1674 SCRIPT_CONTROL sControl;
1675 SCRIPT_STATE sState;
1676 int i, num_items = 255;
1677 BYTE *BidiLevel;
1678 WCHAR *iString = NULL;
1679
1680 TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
1681 hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
1682 psControl, psState, piDx, pTabdef, pbInClass, pssa);
1683
1684 if (iCharset != -1)
1685 {
1686 FIXME("Only Unicode strings are supported\n");
1687 return E_INVALIDARG;
1688 }
1689 if (cString < 1 || !pString) return E_INVALIDARG;
1690 if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
1691
1692 if (!(analysis = heap_alloc_zero(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
1693 if (!(analysis->pItem = heap_alloc_zero(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
1694
1695 /* FIXME: handle clipping */
1696 analysis->clip_len = cString;
1697 analysis->hdc = hdc;
1698 analysis->dwFlags = dwFlags;
1699
1700 if (psState)
1701 sState = *psState;
1702 else
1703 memset(&sState, 0, sizeof(SCRIPT_STATE));
1704
1705 if (psControl)
1706 sControl = *psControl;
1707 else
1708 memset(&sControl, 0, sizeof(SCRIPT_CONTROL));
1709
1710 if (dwFlags & SSA_PASSWORD)
1711 {
1712 iString = heap_alloc(sizeof(WCHAR)*cString);
1713 if (!iString)
1714 {
1715 hr = E_OUTOFMEMORY;
1716 goto error;
1717 }
1718 for (i = 0; i < cString; i++)
1719 iString[i] = *((const WCHAR *)pString);
1720 pString = iString;
1721 }
1722
1723 hr = ScriptItemize(pString, cString, num_items, &sControl, &sState, analysis->pItem,
1724 &analysis->numItems);
1725
1726 while (hr == E_OUTOFMEMORY)
1727 {
1728 SCRIPT_ITEM *tmp;
1729
1730 num_items *= 2;
1731 if (!(tmp = heap_realloc_zero(analysis->pItem, num_items * sizeof(SCRIPT_ITEM) + 1)))
1732 goto error;
1733
1734 analysis->pItem = tmp;
1735 hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
1736 &analysis->numItems);
1737 }
1738 if (hr != S_OK) goto error;
1739
1740 /* set back to out of memory for default goto error behaviour */
1741 hr = E_OUTOFMEMORY;
1742
1743 if (dwFlags & SSA_BREAK)
1744 {
1745 if ((analysis->logattrs = heap_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
1746 {
1747 for (i = 0; i < analysis->numItems; i++)
1748 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]);
1749 }
1750 else
1751 goto error;
1752 }
1753
1754 if (!(analysis->logical2visual = heap_alloc_zero(sizeof(int) * analysis->numItems)))
1755 goto error;
1756 if (!(BidiLevel = heap_alloc_zero(analysis->numItems)))
1757 goto error;
1758
1759 if (dwFlags & SSA_GLYPHS)
1760 {
1761 int tab_x = 0;
1762 if (!(analysis->glyphs = heap_alloc_zero(sizeof(StringGlyphs) * analysis->numItems)))
1763 {
1764 heap_free(BidiLevel);
1765 goto error;
1766 }
1767
1768 for (i = 0; i < analysis->numItems; i++)
1769 {
1770 SCRIPT_CACHE *sc = (SCRIPT_CACHE*)&analysis->glyphs[i].sc;
1771 int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1772 int numGlyphs = 1.5 * cChar + 16;
1773 WORD *glyphs = heap_alloc_zero(sizeof(WORD) * numGlyphs);
1774 WORD *pwLogClust = heap_alloc_zero(sizeof(WORD) * cChar);
1775 int *piAdvance = heap_alloc_zero(sizeof(int) * numGlyphs);
1776 SCRIPT_VISATTR *psva = heap_alloc_zero(sizeof(SCRIPT_VISATTR) * numGlyphs);
1777 GOFFSET *pGoffset = heap_alloc_zero(sizeof(GOFFSET) * numGlyphs);
1778 ABC *abc = heap_alloc_zero(sizeof(ABC));
1779 int numGlyphsReturned;
1780 HFONT originalFont = 0x0;
1781
1782 /* FIXME: non unicode strings */
1783 const WCHAR* pStr = (const WCHAR*)pString;
1784 analysis->glyphs[i].fallbackFont = NULL;
1785
1786 if (!glyphs || !pwLogClust || !piAdvance || !psva || !pGoffset || !abc)
1787 {
1788 heap_free (BidiLevel);
1789 heap_free (glyphs);
1790 heap_free (pwLogClust);
1791 heap_free (piAdvance);
1792 heap_free (psva);
1793 heap_free (pGoffset);
1794 heap_free (abc);
1795 hr = E_OUTOFMEMORY;
1796 goto error;
1797 }
1798
1799 if ((dwFlags & SSA_FALLBACK) && requires_fallback(hdc, sc, &analysis->pItem[i].a, &pStr[analysis->pItem[i].iCharPos], cChar))
1800 {
1801 LOGFONTW lf;
1802 GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), & lf);
1803 lf.lfCharSet = scriptInformation[analysis->pItem[i].a.eScript].props.bCharSet;
1804 lf.lfFaceName[0] = 0;
1805 find_fallback_font(analysis->pItem[i].a.eScript, lf.lfFaceName);
1806 if (lf.lfFaceName[0])
1807 {
1808 analysis->glyphs[i].fallbackFont = CreateFontIndirectW(&lf);
1809 if (analysis->glyphs[i].fallbackFont)
1810 {
1811 ScriptFreeCache(sc);
1812 originalFont = SelectObject(hdc, analysis->glyphs[i].fallbackFont);
1813 }
1814 }
1815 }
1816
1817 hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
1818 cChar, numGlyphs, &analysis->pItem[i].a,
1819 glyphs, pwLogClust, psva, &numGlyphsReturned);
1820 hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
1821 piAdvance, pGoffset, abc);
1822 if (originalFont)
1823 SelectObject(hdc,originalFont);
1824
1825 if (dwFlags & SSA_TAB)
1826 {
1827 int tabi = 0;
1828 for (tabi = 0; tabi < cChar; tabi++)
1829 {
1830 if (pStr[analysis->pItem[i].iCharPos+tabi] == 0x0009)
1831 piAdvance[tabi] = getGivenTabWidth(analysis->glyphs[i].sc, pTabdef, analysis->pItem[i].iCharPos+tabi, tab_x);
1832 tab_x+=piAdvance[tabi];
1833 }
1834 }
1835
1836 analysis->glyphs[i].numGlyphs = numGlyphsReturned;
1837 analysis->glyphs[i].glyphs = glyphs;
1838 analysis->glyphs[i].pwLogClust = pwLogClust;
1839 analysis->glyphs[i].piAdvance = piAdvance;
1840 analysis->glyphs[i].psva = psva;
1841 analysis->glyphs[i].pGoffset = pGoffset;
1842 analysis->glyphs[i].abc = abc;
1843 analysis->glyphs[i].iMaxPosX= -1;
1844
1845 BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1846 }
1847 }
1848 else
1849 {
1850 for (i = 0; i < analysis->numItems; i++)
1851 BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1852 }
1853
1854 ScriptLayout(analysis->numItems, BidiLevel, NULL, analysis->logical2visual);
1855 heap_free(BidiLevel);
1856
1857 *pssa = analysis;
1858 heap_free(iString);
1859 return S_OK;
1860
1861 error:
1862 heap_free(iString);
1863 heap_free(analysis->glyphs);
1864 heap_free(analysis->logattrs);
1865 heap_free(analysis->pItem);
1866 heap_free(analysis->logical2visual);
1867 heap_free(analysis);
1868 return hr;
1869 }
1870
1871 static inline BOOL does_glyph_start_cluster(const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cChars, int glyph, int direction)
1872 {
1873 int i;
1874
1875 if (pva[glyph].fClusterStart)
1876 return TRUE;
1877 for (i = 0; i < cChars; i++)
1878 if (pwLogClust[i] == glyph) break;
1879 if (i != cChars)
1880 return TRUE;
1881
1882 return FALSE;
1883 }
1884
1885
1886 static HRESULT SS_ItemOut( SCRIPT_STRING_ANALYSIS ssa,
1887 int iX,
1888 int iY,
1889 int iItem,
1890 int cStart,
1891 int cEnd,
1892 UINT uOptions,
1893 const RECT *prc,
1894 BOOL fSelected,
1895 BOOL fDisabled)
1896 {
1897 StringAnalysis *analysis;
1898 int off_x = 0;
1899 HRESULT hr;
1900 COLORREF BkColor = 0x0;
1901 COLORREF TextColor = 0x0;
1902 INT BkMode = 0;
1903 INT runStart, runEnd;
1904 INT iGlyph, cGlyphs;
1905 HFONT oldFont = 0x0;
1906 RECT crc;
1907 int i;
1908
1909 TRACE("(%p,%d,%d,%d,%d,%d, 0x%1x, %d, %d)\n",
1910 ssa, iX, iY, iItem, cStart, cEnd, uOptions, fSelected, fDisabled);
1911
1912 if (!(analysis = ssa)) return E_INVALIDARG;
1913
1914 if ((cStart >= 0 && analysis->pItem[iItem+1].iCharPos <= cStart) ||
1915 (cEnd >= 0 && analysis->pItem[iItem].iCharPos >= cEnd))
1916 return S_OK;
1917
1918 CopyRect(&crc,prc);
1919 if (fSelected)
1920 {
1921 BkMode = GetBkMode(analysis->hdc);
1922 SetBkMode( analysis->hdc, OPAQUE);
1923 BkColor = GetBkColor(analysis->hdc);
1924 SetBkColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHT));
1925 if (!fDisabled)
1926 {
1927 TextColor = GetTextColor(analysis->hdc);
1928 SetTextColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1929 }
1930 }
1931 if (analysis->glyphs[iItem].fallbackFont)
1932 oldFont = SelectObject(analysis->hdc, analysis->glyphs[iItem].fallbackFont);
1933
1934 if (cStart >= 0 && analysis->pItem[iItem+1].iCharPos > cStart && analysis->pItem[iItem].iCharPos <= cStart)
1935 runStart = cStart - analysis->pItem[iItem].iCharPos;
1936 else
1937 runStart = 0;
1938 if (cEnd >= 0 && analysis->pItem[iItem+1].iCharPos > cEnd && analysis->pItem[iItem].iCharPos <= cEnd)
1939 runEnd = (cEnd-1) - analysis->pItem[iItem].iCharPos;
1940 else
1941 runEnd = (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos) - 1;
1942
1943 if (analysis->pItem[iItem].a.fRTL)
1944 {
1945 if (cEnd >= 0 && cEnd < analysis->pItem[iItem+1].iCharPos)
1946 ScriptStringCPtoX(ssa, cEnd, FALSE, &off_x);
1947 else
1948 ScriptStringCPtoX(ssa, analysis->pItem[iItem+1].iCharPos-1, TRUE, &off_x);
1949 crc.left = iX + off_x;
1950 }
1951 else
1952 {
1953 if (cStart >=0 && runStart)
1954 ScriptStringCPtoX(ssa, cStart, FALSE, &off_x);
1955 else
1956 ScriptStringCPtoX(ssa, analysis->pItem[iItem].iCharPos, FALSE, &off_x);
1957 crc.left = iX + off_x;
1958 }
1959
1960 if (analysis->pItem[iItem].a.fRTL)
1961 iGlyph = analysis->glyphs[iItem].pwLogClust[runEnd];
1962 else
1963 iGlyph = analysis->glyphs[iItem].pwLogClust[runStart];
1964
1965 if (analysis->pItem[iItem].a.fRTL)
1966 cGlyphs = analysis->glyphs[iItem].pwLogClust[runStart] - iGlyph;
1967 else
1968 cGlyphs = analysis->glyphs[iItem].pwLogClust[runEnd] - iGlyph;
1969
1970 cGlyphs++;
1971
1972 /* adjust for cluster glyphs when starting */
1973 if (analysis->pItem[iItem].a.fRTL)
1974 i = analysis->pItem[iItem+1].iCharPos - 1;
1975 else
1976 i = analysis->pItem[iItem].iCharPos;
1977
1978 for (; i >=analysis->pItem[iItem].iCharPos && i < analysis->pItem[iItem+1].iCharPos; (analysis->pItem[iItem].a.fRTL)?i--:i++)
1979 {
1980 if (analysis->glyphs[iItem].pwLogClust[i - analysis->pItem[iItem].iCharPos] == iGlyph)
1981 {
1982 if (analysis->pItem[iItem].a.fRTL)
1983 ScriptStringCPtoX(ssa, i, TRUE, &off_x);
1984 else
1985 ScriptStringCPtoX(ssa, i, FALSE, &off_x);
1986 break;
1987 }
1988 }
1989
1990 if (cEnd < 0 || scriptInformation[analysis->pItem[iItem].a.eScript].props.fNeedsCaretInfo)
1991 {
1992 INT direction;
1993 INT clust_glyph;
1994
1995 clust_glyph = iGlyph + cGlyphs;
1996 if (analysis->pItem[iItem].a.fRTL)
1997 direction = -1;
1998 else
1999 direction = 1;
2000
2001 while(clust_glyph < analysis->glyphs[iItem].numGlyphs &&
2002 !does_glyph_start_cluster(analysis->glyphs[iItem].psva, analysis->glyphs[iItem].pwLogClust, (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos), clust_glyph, direction))
2003 {
2004 cGlyphs++;
2005 clust_glyph++;
2006 }
2007 }
2008
2009 hr = ScriptTextOut(analysis->hdc,
2010 (SCRIPT_CACHE *)&analysis->glyphs[iItem].sc, iX + off_x,
2011 iY, uOptions, &crc, &analysis->pItem[iItem].a, NULL, 0,
2012 &analysis->glyphs[iItem].glyphs[iGlyph], cGlyphs,
2013 &analysis->glyphs[iItem].piAdvance[iGlyph], NULL,
2014 &analysis->glyphs[iItem].pGoffset[iGlyph]);
2015
2016 TRACE("ScriptTextOut hr=%08x\n", hr);
2017
2018 if (fSelected)
2019 {
2020 SetBkColor(analysis->hdc, BkColor);
2021 SetBkMode( analysis->hdc, BkMode);
2022 if (!fDisabled)
2023 SetTextColor(analysis->hdc, TextColor);
2024 }
2025 if (analysis->glyphs[iItem].fallbackFont)
2026 SelectObject(analysis->hdc, oldFont);
2027
2028 return hr;
2029 }
2030
2031 /***********************************************************************
2032 * ScriptStringOut (USP10.@)
2033 *
2034 * This function takes the output of ScriptStringAnalyse and joins the segments
2035 * of glyphs and passes the resulting string to ScriptTextOut. ScriptStringOut
2036 * only processes glyphs.
2037 *
2038 * Parameters:
2039 * ssa [I] buffer to hold the analysed string components
2040 * iX [I] X axis displacement for output
2041 * iY [I] Y axis displacement for output
2042 * uOptions [I] flags controling output processing
2043 * prc [I] rectangle coordinates
2044 * iMinSel [I] starting pos for substringing output string
2045 * iMaxSel [I] ending pos for substringing output string
2046 * fDisabled [I] controls text highlighting
2047 *
2048 * RETURNS
2049 * Success: S_OK
2050 * Failure: is the value returned by ScriptTextOut
2051 */
2052 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
2053 int iX,
2054 int iY,
2055 UINT uOptions,
2056 const RECT *prc,
2057 int iMinSel,
2058 int iMaxSel,
2059 BOOL fDisabled)
2060 {
2061 StringAnalysis *analysis;
2062 int item;
2063 HRESULT hr;
2064
2065 TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
2066 ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
2067
2068 if (!(analysis = ssa)) return E_INVALIDARG;
2069 if (!(analysis->dwFlags & SSA_GLYPHS)) return E_INVALIDARG;
2070
2071 for (item = 0; item < analysis->numItems; item++)
2072 {
2073 hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], -1, -1, uOptions, prc, FALSE, fDisabled);
2074 if (FAILED(hr))
2075 return hr;
2076 }
2077
2078 if (iMinSel < iMaxSel && (iMinSel > 0 || iMaxSel > 0))
2079 {
2080 if (iMaxSel > 0 && iMinSel < 0)
2081 iMinSel = 0;
2082 for (item = 0; item < analysis->numItems; item++)
2083 {
2084 hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], iMinSel, iMaxSel, uOptions, prc, TRUE, fDisabled);
2085 if (FAILED(hr))
2086 return hr;
2087 }
2088 }
2089
2090 return S_OK;
2091 }
2092
2093 /***********************************************************************
2094 * ScriptStringCPtoX (USP10.@)
2095 *
2096 */
2097 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
2098 {
2099 int item;
2100 int runningX = 0;
2101 StringAnalysis* analysis = ssa;
2102
2103 TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
2104
2105 if (!ssa || !pX) return S_FALSE;
2106 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
2107
2108 /* icp out of range */
2109 if(icp < 0)
2110 {
2111 analysis->invalid = TRUE;
2112 return E_INVALIDARG;
2113 }
2114
2115 for(item=0; item<analysis->numItems; item++)
2116 {
2117 int CP, i;
2118 int offset;
2119
2120 i = analysis->logical2visual[item];
2121 CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
2122 /* initialize max extents for uninitialized runs */
2123 if (analysis->glyphs[i].iMaxPosX == -1)
2124 {
2125 if (analysis->pItem[i].a.fRTL)
2126 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2127 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2128 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2129 else
2130 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2131 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2132 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2133 }
2134
2135 if (icp >= analysis->pItem[i+1].iCharPos || icp < analysis->pItem[i].iCharPos)
2136 {
2137 runningX += analysis->glyphs[i].iMaxPosX;
2138 continue;
2139 }
2140
2141 icp -= analysis->pItem[i].iCharPos;
2142 ScriptCPtoX(icp, fTrailing, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2143 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2144 &analysis->pItem[i].a, &offset);
2145 runningX += offset;
2146
2147 *pX = runningX;
2148 return S_OK;
2149 }
2150
2151 /* icp out of range */
2152 analysis->invalid = TRUE;
2153 return E_INVALIDARG;
2154 }
2155
2156 /***********************************************************************
2157 * ScriptStringXtoCP (USP10.@)
2158 *
2159 */
2160 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing)
2161 {
2162 StringAnalysis* analysis = ssa;
2163 int item;
2164
2165 TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
2166
2167 if (!ssa || !piCh || !piTrailing) return S_FALSE;
2168 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
2169
2170 /* out of range */
2171 if(iX < 0)
2172 {
2173 if (analysis->pItem[0].a.fRTL)
2174 {
2175 *piCh = 1;
2176 *piTrailing = FALSE;
2177 }
2178 else
2179 {
2180 *piCh = -1;
2181 *piTrailing = TRUE;
2182 }
2183 return S_OK;
2184 }
2185
2186 for(item=0; item<analysis->numItems; item++)
2187 {
2188 int i;
2189 int CP;
2190
2191 for (i = 0; i < analysis->numItems && analysis->logical2visual[i] != item; i++)
2192 /* nothing */;
2193
2194 CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
2195 /* initialize max extents for uninitialized runs */
2196 if (analysis->glyphs[i].iMaxPosX == -1)
2197 {
2198 if (analysis->pItem[i].a.fRTL)
2199 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2200 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2201 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2202 else
2203 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2204 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2205 &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2206 }
2207
2208 if (iX > analysis->glyphs[i].iMaxPosX)
2209 {
2210 iX -= analysis->glyphs[i].iMaxPosX;
2211 continue;
2212 }
2213
2214 ScriptXtoCP(iX, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2215 analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2216 &analysis->pItem[i].a, piCh, piTrailing);
2217 *piCh += analysis->pItem[i].iCharPos;
2218
2219 return S_OK;
2220 }
2221
2222 /* out of range */
2223 *piCh = analysis->pItem[analysis->numItems].iCharPos;
2224 *piTrailing = FALSE;
2225
2226 return S_OK;
2227 }
2228
2229
2230 /***********************************************************************
2231 * ScriptStringFree (USP10.@)
2232 *
2233 * Free a string analysis.
2234 *
2235 * PARAMS
2236 * pssa [I] string analysis.
2237 *
2238 * RETURNS
2239 * Success: S_OK
2240 * Failure: Non-zero HRESULT value.
2241 */
2242 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
2243 {
2244 StringAnalysis* analysis;
2245 BOOL invalid;
2246 int i;
2247
2248 TRACE("(%p)\n", pssa);
2249
2250 if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
2251
2252 invalid = analysis->invalid;
2253
2254 if (analysis->glyphs)
2255 {
2256 for (i = 0; i < analysis->numItems; i++)
2257 {
2258 heap_free(analysis->glyphs[i].glyphs);
2259 heap_free(analysis->glyphs[i].pwLogClust);
2260 heap_free(analysis->glyphs[i].piAdvance);
2261 heap_free(analysis->glyphs[i].psva);
2262 heap_free(analysis->glyphs[i].pGoffset);
2263 heap_free(analysis->glyphs[i].abc);
2264 if (analysis->glyphs[i].fallbackFont)
2265 DeleteObject(analysis->glyphs[i].fallbackFont);
2266 ScriptFreeCache((SCRIPT_CACHE *)&analysis->glyphs[i].sc);
2267 heap_free(analysis->glyphs[i].sc);
2268 }
2269 heap_free(analysis->glyphs);
2270 }
2271
2272 heap_free(analysis->pItem);
2273 heap_free(analysis->logattrs);
2274 heap_free(analysis->sz);
2275 heap_free(analysis->logical2visual);
2276 heap_free(analysis);
2277
2278 if (invalid) return E_INVALIDARG;
2279 return S_OK;
2280 }
2281
2282 static inline int get_cluster_size(const WORD *pwLogClust, int cChars, int item,
2283 int direction, int* iCluster, int *check_out)
2284 {
2285 int clust_size = 1;
2286 int check;
2287 WORD clust = pwLogClust[item];
2288
2289 for (check = item+direction; check < cChars && check >= 0; check+=direction)
2290 {
2291 if (pwLogClust[check] == clust)
2292 {
2293 clust_size ++;
2294 if (iCluster && *iCluster == -1)
2295 *iCluster = item;
2296 }
2297 else break;
2298 }
2299
2300 if (check_out)
2301 *check_out = check;
2302
2303 return clust_size;
2304 }
2305
2306 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)
2307 {
2308 int advance;
2309 int log_clust_max = 0;
2310 int i;
2311
2312 advance = piAdvance[glyph];
2313
2314 for (i = 0; i < cChars; i++)
2315 {
2316 if (pwLogClust[i] > log_clust_max)
2317 log_clust_max = pwLogClust[i];
2318 }
2319
2320 if (glyph > log_clust_max)
2321 return advance;
2322
2323 for (glyph+=direction; glyph < cGlyphs && glyph >= 0; glyph +=direction)
2324 {
2325
2326 if (does_glyph_start_cluster(pva, pwLogClust, cChars, glyph, direction))
2327 break;
2328 if (glyph > log_clust_max)
2329 break;
2330 advance += piAdvance[glyph];
2331 }
2332
2333 return advance;
2334 }
2335
2336 /***********************************************************************
2337 * ScriptCPtoX (USP10.@)
2338 *
2339 */
2340 HRESULT WINAPI ScriptCPtoX(int iCP,
2341 BOOL fTrailing,
2342 int cChars,
2343 int cGlyphs,
2344 const WORD *pwLogClust,
2345 const SCRIPT_VISATTR *psva,
2346 const int *piAdvance,
2347 const SCRIPT_ANALYSIS *psa,
2348 int *piX)
2349 {
2350 int item;
2351 float iPosX;
2352 int iSpecial = -1;
2353 int iCluster = -1;
2354 int clust_size = 1;
2355 float special_size = 0.0;
2356 int iMaxPos = 0;
2357 int advance = 0;
2358 BOOL rtl = FALSE;
2359
2360 TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
2361 iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
2362 psa, piX);
2363
2364 if (psa->fRTL && ! psa->fLogicalOrder)
2365 rtl = TRUE;
2366
2367 if (fTrailing)
2368 iCP++;
2369
2370 if (rtl)
2371 {
2372 int max_clust = pwLogClust[0];
2373
2374 for (item=0; item < cGlyphs; item++)
2375 if (pwLogClust[item] > max_clust)
2376 {
2377 ERR("We do not handle non reversed clusters properly\n");
2378 break;
2379 }
2380
2381 iMaxPos = 0;
2382 for (item = max_clust; item >=0; item --)
2383 iMaxPos += piAdvance[item];
2384 }
2385
2386 iPosX = 0.0;
2387 for (item=0; item < iCP && item < cChars; item++)
2388 {
2389 if (iSpecial == -1 && (iCluster == -1 || (iCluster != -1 && iCluster+clust_size <= item)))
2390 {
2391 int check;
2392 int clust = pwLogClust[item];
2393
2394 iCluster = -1;
2395 clust_size = get_cluster_size(pwLogClust, cChars, item, 1, &iCluster,
2396 &check);
2397
2398 advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, 1);
2399
2400 if (check >= cChars && !iMaxPos)
2401 {
2402 for (check = clust; check < cChars; check++)
2403 special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, check, 1);
2404 iSpecial = item;
2405 special_size /= (cChars - item);
2406 iPosX += special_size;
2407 }
2408 else
2409 {
2410 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2411 {
2412 clust_size --;
2413 if (clust_size == 0)
2414 iPosX += advance;
2415 }
2416 else
2417 iPosX += advance / (float)clust_size;
2418 }
2419 }
2420 else if (iSpecial != -1)
2421 iPosX += special_size;
2422 else /* (iCluster != -1) */
2423 {
2424 int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], 1);
2425 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2426 {
2427 clust_size --;
2428 if (clust_size == 0)
2429 iPosX += adv;
2430 }
2431 else
2432 iPosX += adv / (float)clust_size;
2433 }
2434 }
2435
2436 if (iMaxPos > 0)
2437 {
2438 iPosX = iMaxPos - iPosX;
2439 if (iPosX < 0)
2440 iPosX = 0;
2441 }
2442
2443 *piX = iPosX;
2444 TRACE("*piX=%d\n", *piX);
2445 return S_OK;
2446 }
2447
2448 /***********************************************************************
2449 * ScriptXtoCP (USP10.@)
2450 *
2451 */
2452 HRESULT WINAPI ScriptXtoCP(int iX,
2453 int cChars,
2454 int cGlyphs,
2455 const WORD *pwLogClust,
2456 const SCRIPT_VISATTR *psva,
2457 const int *piAdvance,
2458 const SCRIPT_ANALYSIS *psa,
2459 int *piCP,
2460 int *piTrailing)
2461 {
2462 int item;
2463 float iPosX;
2464 float iLastPosX;
2465 int iSpecial = -1;
2466 int iCluster = -1;
2467 int clust_size = 1;
2468 int cjump = 0;
2469 int advance;
2470 float special_size = 0.0;
2471 int direction = 1;
2472
2473 TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
2474 iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
2475 psa, piCP, piTrailing);
2476
2477 if (psa->fRTL && ! psa->fLogicalOrder)
2478 direction = -1;
2479
2480 if (direction<0)
2481 {
2482 int max_clust = pwLogClust[0];
2483
2484 if (iX < 0)
2485 {
2486 *piCP = cChars;
2487 *piTrailing = 0;
2488 return S_OK;
2489 }
2490
2491 for (item=0; item < cChars; item++)
2492 if (pwLogClust[item] > max_clust)
2493 {
2494 ERR("We do not handle non reversed clusters properly\n");
2495 break;
2496 }
2497 }
2498
2499 if (iX < 0)
2500 {
2501 *piCP = -1;
2502 *piTrailing = 1;
2503 return S_OK;
2504 }
2505
2506 iPosX = iLastPosX = 0;
2507 if (direction > 0)
2508 item = 0;
2509 else
2510 item = cChars - 1;
2511 for (; iPosX <= iX && item < cChars && item >= 0; item+=direction)
2512 {
2513 iLastPosX = iPosX;
2514 if (iSpecial == -1 &&
2515 (iCluster == -1 ||
2516 (iCluster != -1 &&
2517 ((direction > 0 && iCluster+clust_size <= item) ||
2518 (direction < 0 && iCluster-clust_size >= item))
2519 )
2520 )
2521 )
2522 {
2523 int check;
2524 int clust = pwLogClust[item];
2525
2526 iCluster = -1;
2527 cjump = 0;
2528 clust_size = get_cluster_size(pwLogClust, cChars, item, direction,
2529 &iCluster, &check);
2530 advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, direction);
2531
2532 if (check >= cChars && direction > 0)
2533 {
2534 for (check = clust; check < cChars; check++)
2535 special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, check, direction);
2536 iSpecial = item;
2537 special_size /= (cChars - item);
2538 iPosX += special_size;
2539 }
2540 else
2541 {
2542 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2543 {
2544 if (!cjump)
2545 iPosX += advance;
2546 cjump++;
2547 }
2548 else
2549 iPosX += advance / (float)clust_size;
2550 }
2551 }
2552 else if (iSpecial != -1)
2553 iPosX += special_size;
2554 else /* (iCluster != -1) */
2555 {
2556 int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], direction);
2557 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2558 {
2559 if (!cjump)
2560 iPosX += adv;
2561 cjump++;
2562 }
2563 else
2564 iPosX += adv / (float)clust_size;
2565 }
2566 }
2567
2568 if (direction > 0)
2569 {
2570 if (iPosX > iX)
2571 item--;
2572 if (item < cChars && ((iPosX - iLastPosX) / 2.0) + iX >= iPosX)
2573 {
2574 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo && clust_size > 1)
2575 item+=(clust_size-1);
2576 *piTrailing = 1;
2577 }
2578 else
2579 *piTrailing = 0;
2580 }
2581 else
2582 {
2583 if (iX == iLastPosX)
2584 item++;
2585 if (iX >= iLastPosX && iX <= iPosX)
2586 item++;
2587
2588 if (iLastPosX == iX)
2589 *piTrailing = 0;
2590 else if (item < 0 || ((iLastPosX - iPosX) / 2.0) + iX <= iLastPosX)
2591 {
2592 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo && clust_size > 1)
2593 item-=(clust_size-1);
2594 *piTrailing = 1;
2595 }
2596 else
2597 *piTrailing = 0;
2598 }
2599
2600 *piCP = item;
2601
2602 TRACE("*piCP=%d\n", *piCP);
2603 TRACE("*piTrailing=%d\n", *piTrailing);
2604 return S_OK;
2605 }
2606
2607 /***********************************************************************
2608 * ScriptBreak (USP10.@)
2609 *
2610 * Retrieve line break information.
2611 *
2612 * PARAMS
2613 * chars [I] Array of characters.
2614 * sa [I] String analysis.
2615 * la [I] Array of logical attribute structures.
2616 *
2617 * RETURNS
2618 * Success: S_OK
2619 * Failure: S_FALSE
2620 */
2621 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
2622 {
2623 TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
2624
2625 if (!la) return S_FALSE;
2626
2627 BREAK_line(chars, count, sa, la);
2628
2629 return S_OK;
2630 }
2631
2632 /***********************************************************************
2633 * ScriptIsComplex (USP10.@)
2634 *
2635 * Determine if a string is complex.
2636 *
2637 * PARAMS
2638 * chars [I] Array of characters to test.
2639 * len [I] Length in characters.
2640 * flag [I] Flag.
2641 *
2642 * RETURNS
2643 * Success: S_OK
2644 * Failure: S_FALSE
2645 *
2646 */
2647 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
2648 {
2649 int i;
2650 INT consumed = 0;
2651
2652 TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
2653
2654 for (i = 0; i < len; i+=consumed)
2655 {
2656 int script;
2657 if (i >= len)
2658 break;
2659
2660 if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
2661 return S_OK;
2662
2663 script = get_char_script(chars,i,len, &consumed);
2664 if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
2665 (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
2666 return S_OK;
2667 }
2668 return S_FALSE;
2669 }
2670
2671 /***********************************************************************
2672 * ScriptShapeOpenType (USP10.@)
2673 *
2674 * Produce glyphs and visual attributes for a run.
2675 *
2676 * PARAMS
2677 * hdc [I] Device context.
2678 * psc [I/O] Opaque pointer to a script cache.
2679 * psa [I/O] Script analysis.
2680 * tagScript [I] The OpenType tag for the Script
2681 * tagLangSys [I] The OpenType tag for the Language
2682 * rcRangeChars[I] Array of Character counts in each range
2683 * rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
2684 * cRanges [I] Count of ranges
2685 * pwcChars [I] Array of characters specifying the run.
2686 * cChars [I] Number of characters in pwcChars.
2687 * cMaxGlyphs [I] Length of pwOutGlyphs.
2688 * pwLogClust [O] Array of logical cluster info.
2689 * pCharProps [O] Array of character property values
2690 * pwOutGlyphs [O] Array of glyphs.
2691 * pOutGlyphProps [O] Array of attributes for the retrieved glyphs
2692 * pcGlyphs [O] Number of glyphs returned.
2693 *
2694 * RETURNS
2695 * Success: S_OK
2696 * Failure: Non-zero HRESULT value.
2697 */
2698 HRESULT WINAPI ScriptShapeOpenType( HDC hdc, SCRIPT_CACHE *psc,
2699 SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript,
2700 OPENTYPE_TAG tagLangSys, int *rcRangeChars,
2701 TEXTRANGE_PROPERTIES **rpRangeProperties,
2702 int cRanges, const WCHAR *pwcChars, int cChars,
2703 int cMaxGlyphs, WORD *pwLogClust,
2704 SCRIPT_CHARPROP *pCharProps, WORD *pwOutGlyphs,
2705 SCRIPT_GLYPHPROP *pOutGlyphProps, int *pcGlyphs)
2706 {
2707 HRESULT hr;
2708 unsigned int i,g;
2709 BOOL rtl;
2710 int cluster;
2711
2712 TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %d, %d, %p, %p, %p, %p, %p )\n",
2713 hdc, psc, psa,
2714 debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
2715 rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
2716 cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
2717
2718 if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
2719 psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
2720
2721 if (!pOutGlyphProps || !pcGlyphs || !pCharProps) return E_INVALIDARG;
2722 if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
2723
2724 if (cRanges)
2725 FIXME("Ranges not supported yet\n");
2726
2727 rtl = (psa && !psa->fLogicalOrder && psa->fRTL);
2728
2729 *pcGlyphs = cChars;
2730 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2731 if (!pwLogClust) return E_FAIL;
2732
2733 ((ScriptCache *)*psc)->userScript = tagScript;
2734 ((ScriptCache *)*psc)->userLang = tagLangSys;
2735
2736 /* set fNoGlyphIndex non truetype/opentype fonts */
2737 if (!psa->fNoGlyphIndex && !((ScriptCache *)*psc)->sfnt)
2738 psa->fNoGlyphIndex = TRUE;
2739
2740 /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
2741 for (i = 0; i < cChars; i++)
2742 {
2743 int idx = i;
2744 if (rtl) idx = cChars - 1 - i;
2745 /* FIXME: set to better values */
2746 pOutGlyphProps[i].sva.uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
2747 pOutGlyphProps[i].sva.fClusterStart = 1;
2748 pOutGlyphProps[i].sva.fDiacritic = 0;
2749 pOutGlyphProps[i].sva.fZeroWidth = 0;
2750 pOutGlyphProps[i].sva.fReserved = 0;
2751 pOutGlyphProps[i].sva.fShapeReserved = 0;
2752
2753 /* FIXME: have the shaping engine set this */
2754 pCharProps[i].fCanGlyphAlone = 0;
2755
2756 pwLogClust[i] = idx;
2757 }
2758
2759 if (psa && !psa->fNoGlyphIndex)
2760 {
2761 WCHAR *rChars;
2762 if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
2763
2764 rChars = heap_alloc(sizeof(WCHAR) * cChars);
2765 if (!rChars) return E_OUTOFMEMORY;
2766 for (i = 0, g = 0, cluster = 0; i < cChars; i++)
2767 {
2768 int idx = i;
2769 DWORD chInput;
2770
2771 if (rtl) idx = cChars - 1 - i;
2772 if (!cluster)
2773 {
2774 chInput = decode_surrogate_pair(pwcChars, idx, cChars);
2775 if (!chInput)
2776 {
2777 if (psa->fRTL)
2778 chInput = mirror_char(pwcChars[idx]);
2779 else
2780 chInput = pwcChars[idx];
2781 /* special case for tabs */
2782 if (chInput == 0x0009)
2783 chInput = 0x0020;
2784 rChars[i] = chInput;
2785 }
2786 else
2787 {
2788 rChars[i] = pwcChars[idx];
2789 rChars[i+1] = pwcChars[(rtl)?idx-1:idx+1];
2790 cluster = 1;
2791 }
2792 if (!(pwOutGlyphs[g] = get_cache_glyph(psc, chInput)))
2793 {
2794 WORD glyph;
2795 if (!hdc)
2796 {
2797 heap_free(rChars);
2798 return E_PENDING;
2799 }
2800 if (CMAP_GetGlyphIndex(hdc, (ScriptCache *)*psc, chInput, &glyph, 0) == GDI_ERROR)
2801 {
2802 heap_free(rChars);
2803 return S_FALSE;
2804 }
2805 pwOutGlyphs[g] = set_cache_glyph(psc, chInput, glyph);
2806 }
2807 g++;
2808 }
2809 else
2810 {
2811 int k;
2812 cluster--;
2813 pwLogClust[idx] = (rtl)?pwLogClust[idx+1]:pwLogClust[idx-1];
2814 for (k = (rtl)?idx-1:idx+1; k >= 0 && k < cChars; (rtl)?k--:k++)
2815 pwLogClust[k]--;
2816 }
2817 }
2818 *pcGlyphs = g;
2819
2820 SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
2821 SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
2822 SHAPE_CharGlyphProp(hdc, (ScriptCache *)*psc, psa, pwcChars, cChars, pwOutGlyphs, *pcGlyphs, pwLogClust, pCharProps, pOutGlyphProps);
2823 heap_free(rChars);
2824 }
2825 else
2826 {
2827 TRACE("no glyph translation\n");
2828 for (i = 0; i < cChars; i++)
2829 {
2830 int idx = i;
2831 /* No mirroring done here */
2832 if (rtl) idx = cChars - 1 - i;
2833 pwOutGlyphs[i] = pwcChars[idx];
2834 }
2835 }
2836
2837 return S_OK;
2838 }
2839
2840
2841 /***********************************************************************
2842 * ScriptShape (USP10.@)
2843 *
2844 * Produce glyphs and visual attributes for a run.
2845 *
2846 * PARAMS
2847 * hdc [I] Device context.
2848 * psc [I/O] Opaque pointer to a script cache.
2849 * pwcChars [I] Array of characters specifying the run.
2850 * cChars [I] Number of characters in pwcChars.
2851 * cMaxGlyphs [I] Length of pwOutGlyphs.
2852 * psa [I/O] Script analysis.
2853 * pwOutGlyphs [O] Array of glyphs.
2854 * pwLogClust [O] Array of logical cluster info.
2855 * psva [O] Array of visual attributes.
2856 * pcGlyphs [O] Number of glyphs returned.
2857 *
2858 * RETURNS
2859 * Success: S_OK
2860 * Failure: Non-zero HRESULT value.
2861 */
2862 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars,
2863 int cChars, int cMaxGlyphs,
2864 SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
2865 SCRIPT_VISATTR *psva, int *pcGlyphs)
2866 {
2867 HRESULT hr;
2868 int i;
2869 SCRIPT_CHARPROP *charProps;
2870 SCRIPT_GLYPHPROP *glyphProps;
2871
2872 if (!psva || !pcGlyphs) return E_INVALIDARG;
2873 if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
2874
2875 charProps = heap_alloc_zero(sizeof(SCRIPT_CHARPROP)*cChars);
2876 if (!charProps) return E_OUTOFMEMORY;
2877 glyphProps = heap_alloc_zero(sizeof(SCRIPT_GLYPHPROP)*cMaxGlyphs);
2878 if (!glyphProps)
2879 {
2880 heap_free(charProps);
2881 return E_OUTOFMEMORY;
2882 }
2883
2884 hr = ScriptShapeOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, pwcChars, cChars, cMaxGlyphs, pwLogClust, charProps, pwOutGlyphs, glyphProps, pcGlyphs);
2885
2886 if (SUCCEEDED(hr))
2887 {
2888 for (i = 0; i < *pcGlyphs; i++)
2889 psva[i] = glyphProps[i].sva;
2890 }
2891
2892 heap_free(charProps);
2893 heap_free(glyphProps);
2894
2895 return hr;
2896 }
2897
2898 /***********************************************************************
2899 * ScriptPlaceOpenType (USP10.@)
2900 *
2901 * Produce advance widths for a run.
2902 *
2903 * PARAMS
2904 * hdc [I] Device context.
2905 * psc [I/O] Opaque pointer to a script cache.
2906 * psa [I/O] String analysis.
2907 * tagScript [I] The OpenType tag for the Script
2908 * tagLangSys [I] The OpenType tag for the Language
2909 * rcRangeChars[I] Array of Character counts in each range
2910 * rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
2911 * cRanges [I] Count of ranges
2912 * pwcChars [I] Array of characters specifying the run.
2913 * pwLogClust [I] Array of logical cluster info
2914 * pCharProps [I] Array of character property values
2915 * cChars [I] Number of characters in pwcChars.
2916 * pwGlyphs [I] Array of glyphs.
2917 * pGlyphProps [I] Array of attributes for the retrieved glyphs
2918 * cGlyphs [I] Count of Glyphs
2919 * piAdvance [O] Array of advance widths.
2920 * pGoffset [O] Glyph offsets.
2921 * pABC [O] Combined ABC width.
2922 *
2923 * RETURNS
2924 * Success: S_OK
2925 * Failure: Non-zero HRESULT value.
2926 */
2927
2928 HRESULT WINAPI ScriptPlaceOpenType( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
2929 OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys,
2930 int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties,
2931 int cRanges, const WCHAR *pwcChars, WORD *pwLogClust,
2932 SCRIPT_CHARPROP *pCharProps, int cChars,
2933 const WORD *pwGlyphs, const SCRIPT_GLYPHPROP *pGlyphProps,
2934 int cGlyphs, int *piAdvance,
2935 GOFFSET *pGoffset, ABC *pABC
2936 )
2937 {
2938 HRESULT hr;
2939 int i;
2940
2941 TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %p, %p, %d, %p, %p, %d, %p %p %p)\n",
2942 hdc, psc, psa,
2943 debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
2944 rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
2945 pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance,
2946 pGoffset, pABC);
2947
2948 if (!pGlyphProps) return E_INVALIDARG;
2949 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2950 if (!pGoffset) return E_FAIL;
2951
2952 if (cRanges)
2953 FIXME("Ranges not supported yet\n");
2954
2955 ((ScriptCache *)*psc)->userScript = tagScript;
2956 ((ScriptCache *)*psc)->userLang = tagLangSys;
2957
2958 if (pABC) memset(pABC, 0, sizeof(ABC));
2959 for (i = 0; i < cGlyphs; i++)
2960 {
2961 ABC abc;
2962 if (!get_cache_glyph_widths(psc, pwGlyphs[i], &abc))
2963 {
2964 if (!hdc) return E_PENDING;
2965 if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE) && !psa->fNoGlyphIndex)
2966 {
2967 if (!GetCharABCWidthsI(hdc, 0, 1, (WORD *)&pwGlyphs[i], &abc)) return S_FALSE;
2968 }
2969 else
2970 {
2971 INT width;
2972 if (!GetCharWidth32W(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
2973 abc.abcB = width;
2974 abc.abcA = abc.abcC = 0;
2975 }
2976 set_cache_glyph_widths(psc, pwGlyphs[i], &abc);
2977 }
2978 if (pABC)
2979 {
2980 pABC->abcA += abc.abcA;
2981 pABC->abcB += abc.abcB;
2982 pABC->abcC += abc.abcC;
2983 }
2984 /* FIXME: set to more reasonable values */
2985 pGoffset[i].du = pGoffset[i].dv = 0;
2986 if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
2987 }
2988
2989 if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
2990 return S_OK;
2991 }
2992
2993 /***********************************************************************
2994 * ScriptPlace (USP10.@)
2995 *
2996 * Produce advance widths for a run.
2997 *
2998 * PARAMS
2999 * hdc [I] Device context.
3000 * psc [I/O] Opaque pointer to a script cache.
3001 * pwGlyphs [I] Array of glyphs.
3002 * cGlyphs [I] Number of glyphs in pwGlyphs.
3003 * psva [I] Array of visual attributes.
3004 * psa [I/O] String analysis.
3005 * piAdvance [O] Array of advance widths.
3006 * pGoffset [O] Glyph offsets.
3007 * pABC [O] Combined ABC width.
3008 *
3009 * RETURNS
3010 * Success: S_OK
3011 * Failure: Non-zero HRESULT value.
3012 */
3013 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs,
3014 int cGlyphs, const SCRIPT_VISATTR *psva,
3015 SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
3016 {
3017 HRESULT hr;
3018 SCRIPT_GLYPHPROP *glyphProps;
3019 int i;
3020
3021 TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n", hdc, psc, pwGlyphs, cGlyphs, psva, psa,
3022 piAdvance, pGoffset, pABC);
3023
3024 if (!psva) return E_INVALIDARG;
3025 if (!pGoffset) return E_FAIL;
3026
3027 glyphProps = heap_alloc(sizeof(SCRIPT_GLYPHPROP)*cGlyphs);
3028 if (!glyphProps) return E_OUTOFMEMORY;
3029
3030 for (i = 0; i < cGlyphs; i++)
3031 glyphProps[i].sva = psva[i];
3032
3033 hr = ScriptPlaceOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, NULL, NULL, NULL, 0, pwGlyphs, glyphProps, cGlyphs, piAdvance, pGoffset, pABC);
3034
3035 heap_free(glyphProps);
3036
3037 return hr;
3038 }
3039
3040 /***********************************************************************
3041 * ScriptGetCMap (USP10.@)
3042 *
3043 * Retrieve glyph indices.
3044 *
3045 * PARAMS
3046 * hdc [I] Device context.
3047 * psc [I/O] Opaque pointer to a script cache.
3048 * pwcInChars [I] Array of Unicode characters.
3049 * cChars [I] Number of characters in pwcInChars.
3050 * dwFlags [I] Flags.
3051 * pwOutGlyphs [O] Buffer to receive the array of glyph indices.
3052 *
3053 * RETURNS
3054 * Success: S_OK
3055 * Failure: Non-zero HRESULT value.
3056 */
3057 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
3058 int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
3059 {
3060 HRESULT hr;
3061 int i;
3062
3063 TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
3064 cChars, dwFlags, pwOutGlyphs);
3065
3066 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3067
3068 hr = S_OK;
3069
3070 if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
3071 {
3072 for (i = 0; i < cChars; i++)
3073 {
3074 WCHAR inChar;
3075 if (dwFlags == SGCM_RTL)
3076 inChar = mirror_char(pwcInChars[i]);
3077 else
3078 inChar = pwcInChars[i];
3079 if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
3080 {
3081 WORD glyph;
3082 if (!hdc) return E_PENDING;
3083 if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
3084 if (glyph == 0xffff)
3085 {
3086 hr = S_FALSE;
3087 glyph = 0x0;
3088 }
3089 pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
3090 }
3091 }
3092 }
3093 else
3094 {
3095 TRACE("no glyph translation\n");
3096 for (i = 0; i < cChars; i++)
3097 {
3098 WCHAR inChar;
3099 if (dwFlags == SGCM_RTL)
3100 inChar = mirror_char(pwcInChars[i]);
3101 else
3102 inChar = pwcInChars[i];
3103 pwOutGlyphs[i] = inChar;
3104 }
3105 }
3106 return hr;
3107 }
3108
3109 /***********************************************************************
3110 * ScriptTextOut (USP10.@)
3111 *
3112 */
3113 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
3114 const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
3115 int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
3116 const int *piJustify, const GOFFSET *pGoffset)
3117 {
3118 HRESULT hr = S_OK;
3119
3120 TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
3121 hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
3122 piAdvance, piJustify, pGoffset);
3123
3124 if (!hdc || !psc) return E_INVALIDARG;
3125 if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
3126
3127 fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
3128 fuOptions |= ETO_IGNORELANGUAGE;
3129 if (!psa->fNoGlyphIndex) /* Have Glyphs? */
3130 fuOptions |= ETO_GLYPH_INDEX; /* Say don't do translation to glyph */
3131
3132 if (psa->fRTL && psa->fLogicalOrder)
3133 {
3134 int i;
3135 WORD *rtlGlyphs;
3136
3137 rtlGlyphs = heap_alloc(cGlyphs * sizeof(WORD));
3138 if (!rtlGlyphs)
3139 return E_OUTOFMEMORY;
3140
3141 for (i = 0; i < cGlyphs; i++)
3142 rtlGlyphs[i] = pwGlyphs[cGlyphs-1-i];
3143
3144 if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, rtlGlyphs, cGlyphs, NULL))
3145 hr = S_FALSE;
3146 heap_free(rtlGlyphs);
3147 }
3148 else
3149 if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
3150 hr = S_FALSE;
3151
3152 return hr;
3153 }
3154
3155 /***********************************************************************
3156 * ScriptCacheGetHeight (USP10.@)
3157 *
3158 * Retrieve the height of the font in the cache.
3159 *
3160 * PARAMS
3161 * hdc [I] Device context.
3162 * psc [I/O] Opaque pointer to a script cache.
3163 * height [O] Receives font height.
3164 *
3165 * RETURNS
3166 * Success: S_OK
3167 * Failure: Non-zero HRESULT value.
3168 */
3169 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
3170 {
3171 HRESULT hr;
3172
3173 TRACE("(%p, %p, %p)\n", hdc, psc, height);
3174
3175 if (!height) return E_INVALIDARG;
3176 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3177
3178 *height = get_cache_height(psc);
3179 return S_OK;
3180 }
3181
3182 /***********************************************************************
3183 * ScriptGetGlyphABCWidth (USP10.@)
3184 *
3185 * Retrieve the width of a glyph.
3186 *
3187 * PARAMS
3188 * hdc [I] Device context.
3189 * psc [I/O] Opaque pointer to a script cache.
3190 * glyph [I] Glyph to retrieve the width for.
3191 * abc [O] ABC widths of the glyph.
3192 *
3193 * RETURNS
3194 * Success: S_OK
3195 * Failure: Non-zero HRESULT value.
3196 */
3197 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
3198 {
3199 HRESULT hr;
3200
3201 TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
3202
3203 if (!abc) return E_INVALIDARG;
3204 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3205
3206 if (!get_cache_glyph_widths(psc, glyph, abc))
3207 {
3208 if (!hdc) return E_PENDING;
3209 if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
3210 {
3211 if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
3212 }
3213 else
3214 {
3215 INT width;
3216 if (!GetCharWidth32W(hdc, glyph, glyph, &width)) return S_FALSE;
3217 abc->abcB = width;
3218 abc->abcA = abc->abcC = 0;
3219 }
3220 set_cache_glyph_widths(psc, glyph, abc);
3221 }
3222 return S_OK;
3223 }
3224
3225 /***********************************************************************
3226 * ScriptLayout (USP10.@)
3227 *
3228 * Map embedding levels to visual and/or logical order.
3229 *
3230 * PARAMS
3231 * runs [I] Size of level array.
3232 * level [I] Array of embedding levels.
3233 * vistolog [O] Map of embedding levels from visual to logical order.
3234 * logtovis [O] Map of embedding levels from logical to visual order.
3235 *
3236 * RETURNS
3237 * Success: S_OK
3238 * Failure: Non-zero HRESULT value.
3239 *
3240 * BUGS
3241 * This stub works correctly for any sequence of a single
3242 * embedding level but not for sequences of different
3243 * embedding levels, i.e. mixtures of RTL and LTR scripts.
3244 */
3245 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
3246 {
3247 int* indexs;
3248 int ich;
3249
3250 TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
3251
3252 if (!level || (!vistolog && !logtovis))
3253 return E_INVALIDARG;
3254
3255 indexs = heap_alloc(sizeof(int) * runs);
3256 if (!indexs)
3257 return E_OUTOFMEMORY;
3258
3259
3260 if (vistolog)
3261 {
3262 for( ich = 0; ich < runs; ich++)
3263 indexs[ich] = ich;
3264
3265 ich = 0;
3266 while (ich < runs)
3267 ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
3268 for (ich = 0; ich < runs; ich++)
3269 vistolog[ich] = indexs[ich];
3270 }
3271
3272
3273 if (logtovis)
3274 {
3275 for( ich = 0; ich < runs; ich++)
3276 indexs[ich] = ich;
3277
3278 ich = 0;
3279 while (ich < runs)
3280 ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
3281 for (ich = 0; ich < runs; ich++)
3282 logtovis[ich] = indexs[ich];
3283 }
3284 heap_free(indexs);
3285
3286 return S_OK;
3287 }
3288
3289 /***********************************************************************
3290 * ScriptStringGetLogicalWidths (USP10.@)
3291 *
3292 * Returns logical widths from a string analysis.
3293 *
3294 * PARAMS
3295 * ssa [I] string analysis.
3296 * piDx [O] logical widths returned.
3297 *
3298 * RETURNS
3299 * Success: S_OK
3300 * Failure: a non-zero HRESULT.
3301 */
3302 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
3303 {
3304 int i, j, next = 0;
3305 StringAnalysis *analysis = ssa;
3306
3307 TRACE("%p, %p\n", ssa, piDx);
3308
3309 if (!analysis) return S_FALSE;
3310 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
3311
3312 for (i = 0; i < analysis->numItems; i++)
3313 {
3314 int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
3315 int direction = 1;
3316
3317 if (analysis->pItem[i].a.fRTL && ! analysis->pItem[i].a.fLogicalOrder)
3318 direction = -1;
3319
3320 for (j = 0; j < cChar; j++)
3321 {
3322 int k;
3323 int glyph = analysis->glyphs[i].pwLogClust[j];
3324 int clust_size = get_cluster_size(analysis->glyphs[i].pwLogClust,
3325 cChar, j, direction, NULL, NULL);
3326 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);
3327
3328 for (k = 0; k < clust_size; k++)
3329 {
3330 piDx[next] = advance / clust_size;
3331 next++;
3332 if (k) j++;
3333 }
3334 }
3335 }
3336 return S_OK;
3337 }
3338
3339 /***********************************************************************
3340 * ScriptStringValidate (USP10.@)
3341 *
3342 * Validate a string analysis.
3343 *
3344 * PARAMS
3345 * ssa [I] string analysis.
3346 *
3347 * RETURNS
3348 * Success: S_OK
3349 * Failure: S_FALSE if invalid sequences are found
3350 * or a non-zero HRESULT if it fails.
3351 */
3352 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
3353 {
3354 StringAnalysis *analysis = ssa;
3355
3356 TRACE("(%p)\n", ssa);
3357
3358 if (!analysis) return E_INVALIDARG;
3359 return (analysis->invalid) ? S_FALSE : S_OK;
3360 }
3361
3362 /***********************************************************************
3363 * ScriptString_pSize (USP10.@)
3364 *
3365 * Retrieve width and height of an analysed string.
3366 *
3367 * PARAMS
3368 * ssa [I] string analysis.
3369 *
3370 * RETURNS
3371 * Success: Pointer to a SIZE structure.
3372 * Failure: NULL
3373 */
3374 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
3375 {
3376 int i, j;
3377 StringAnalysis *analysis = ssa;
3378
3379 TRACE("(%p)\n", ssa);
3380
3381 if (!analysis) return NULL;
3382 if (!(analysis->dwFlags & SSA_GLYPHS)) return NULL;
3383
3384 if (!analysis->sz)
3385 {
3386 if (!(analysis->sz = heap_alloc(sizeof(SIZE)))) return NULL;
3387 analysis->sz->cy = analysis->glyphs[0].sc->tm.tmHeight;
3388
3389 analysis->sz->cx = 0;
3390 for (i = 0; i < analysis->numItems; i++)
3391 {
3392 if (analysis->glyphs[i].sc->tm.tmHeight > analysis->sz->cy)
3393 analysis->sz->cy = analysis->glyphs[i].sc->tm.tmHeight;
3394 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
3395 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
3396 }
3397 }
3398 return analysis->sz;
3399 }
3400
3401 /***********************************************************************
3402 * ScriptString_pLogAttr (USP10.@)
3403 *
3404 * Retrieve logical attributes of an analysed string.
3405 *
3406 * PARAMS
3407 * ssa [I] string analysis.
3408 *
3409 * RETURNS
3410 * Success: Pointer to an array of SCRIPT_LOGATTR structures.
3411 * Failure: NULL
3412 */
3413 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
3414 {
3415 StringAnalysis *analysis = ssa;
3416
3417 TRACE("(%p)\n", ssa);
3418
3419 if (!analysis) return NULL;
3420 if (!(analysis->dwFlags & SSA_BREAK)) return NULL;
3421 return analysis->logattrs;
3422 }
3423
3424 /***********************************************************************
3425 * ScriptString_pcOutChars (USP10.@)
3426 *
3427 * Retrieve the length of a string after clipping.
3428 *
3429 * PARAMS
3430 * ssa [I] String analysis.
3431 *
3432 * RETURNS
3433 * Success: Pointer to the length.
3434 * Failure: NULL
3435 */
3436 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
3437 {
3438 StringAnalysis *analysis = ssa;
3439
3440 TRACE("(%p)\n", ssa);
3441
3442 if (!analysis) return NULL;
3443 return &analysis->clip_len;
3444 }
3445
3446 /***********************************************************************
3447 * ScriptStringGetOrder (USP10.@)
3448 *
3449 * Retrieve a glyph order map.
3450 *
3451 * PARAMS
3452 * ssa [I] String analysis.
3453 * order [I/O] Array of glyph positions.
3454 *
3455 * RETURNS
3456 * Success: S_OK
3457 * Failure: a non-zero HRESULT.
3458 */
3459 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
3460 {
3461 int i, j;
3462 unsigned int k;
3463 StringAnalysis *analysis = ssa;
3464
3465 TRACE("(%p)\n", ssa);
3466
3467 if (!analysis) return S_FALSE;
3468 if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
3469
3470 /* FIXME: handle RTL scripts */
3471 for (i = 0, k = 0; i < analysis->numItems; i++)
3472 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
3473 order[k] = k;
3474
3475 return S_OK;
3476 }
3477
3478 /***********************************************************************
3479 * ScriptGetLogicalWidths (USP10.@)
3480 *
3481 * Convert advance widths to logical widths.
3482 *
3483 * PARAMS
3484 * sa [I] Script analysis.
3485 * nbchars [I] Number of characters.
3486 * nbglyphs [I] Number of glyphs.
3487 * glyph_width [I] Array of glyph widths.
3488 * log_clust [I] Array of logical clusters.
3489 * sva [I] Visual attributes.
3490 * widths [O] Array of logical widths.
3491 *
3492 * RETURNS
3493 * Success: S_OK
3494 * Failure: a non-zero HRESULT.
3495 */
3496 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
3497 const int *glyph_width, const WORD *log_clust,
3498 const SCRIPT_VISATTR *sva, int *widths)
3499 {
3500 int i;
3501
3502 TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
3503 sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
3504
3505 /* FIXME */
3506 for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
3507 return S_OK;
3508 }
3509
3510 /***********************************************************************
3511 * ScriptApplyLogicalWidth (USP10.@)
3512 *
3513 * Generate glyph advance widths.
3514 *
3515 * PARAMS
3516 * dx [I] Array of logical advance widths.
3517 * num_chars [I] Number of characters.
3518 * num_glyphs [I] Number of glyphs.
3519 * log_clust [I] Array of logical clusters.
3520 * sva [I] Visual attributes.
3521 * advance [I] Array of glyph advance widths.
3522 * sa [I] Script analysis.
3523 * abc [I/O] Summed ABC widths.
3524 * justify [O] Array of glyph advance widths.
3525 *
3526 * RETURNS
3527 * Success: S_OK
3528 * Failure: a non-zero HRESULT.
3529 */
3530 HRESULT WINAPI ScriptApplyLogicalWidth(const int *dx, int num_chars, int num_glyphs,
3531 const WORD *log_clust, const SCRIPT_VISATTR *sva,
3532 const int *advance, const SCRIPT_ANALYSIS *sa,
3533 ABC *abc, int *justify)
3534 {
3535 int i;
3536
3537 FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
3538 dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
3539
3540 for (i = 0; i < num_chars; i++) justify[i] = advance[i];
3541 return S_OK;
3542 }
3543
3544 HRESULT WINAPI ScriptJustify(const SCRIPT_VISATTR *sva, const int *advance,
3545 int num_glyphs, int dx, int min_kashida, int *justify)
3546 {
3547 int i;
3548
3549 FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
3550
3551 for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
3552 return S_OK;
3553 }
3554
3555 HRESULT WINAPI ScriptGetFontScriptTags( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
3556 {
3557 HRESULT hr;
3558 if (!pScriptTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
3559 if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3560
3561 return SHAPE_GetFontScriptTags(hdc, (ScriptCache *)*psc, psa, cMaxTags, pScriptTags, pcTags);
3562 }
Windows API implementation