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