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