projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Copied remotely
[reactos.git] / reactos / dll / win32 / usp10 / usp10.c
1 /*
2 * Implementation of Uniscribe Script Processor (usp10.dll)
3 *
4 * Copyright 2005 Steven Edwards for CodeWeavers
5 * Copyright 2006 Hans Leidekker
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * Notes:
22 * Uniscribe allows for processing of complex scripts such as joining
23 * and filtering characters and bi-directional text with custom line breaks.
24 */
25
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winnls.h"
33 #include "usp10.h"
34
35 #include "wine/debug.h"
36 #include "wine/unicode.h"
37
38 /**
39 * some documentation here:
40 * http://www.microsoft.com/typography/developers/uniscribe/uniscribe.htm
41 */
42
43 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
44
45 static const SCRIPT_PROPERTIES props[] =
46 {
47 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
48 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
49 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
50 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
51 { 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
52 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
53 { 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
54 { 8, 0, 0, 0, 0, 161, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
55 { 25, 0, 0, 0, 0, 204, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
56 { 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
57 { 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
58 { 42, 0, 0, 0, 0, 163, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
59 { 9, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
60 { 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0 },
61 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
62 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
63 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
64 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
65 { 18, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
66 { 18, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
67 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
68 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
69 { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
70 { 9, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0 },
71 { 13, 0, 1, 0, 1, 177, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
72 { 13, 0, 1, 0, 0, 177, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
73 { 1, 0, 1, 0, 0, 178, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
74 { 1, 1, 1, 0, 0, 178, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
75 { 41, 1, 1, 0, 0, 178, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
76 { 32, 1, 1, 0, 0, 178, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
77 { 90, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0 },
78 { 30, 0, 1, 1, 1, 222, 0, 0, 1, 0, 1, 0, 0, 0, 1 },
79 { 30, 1, 1, 0, 0, 222, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
80 { 30, 0, 1, 0, 0, 222, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
81 { 57, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
82 { 57, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
83 { 73, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
84 { 73, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
85 { 69, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
86 { 69, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
87 { 69, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
88 { 70, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
89 { 70, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
90 { 71, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
91 { 71, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
92 { 72, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
93 { 72, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
94 { 74, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
95 { 74, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
96 { 75, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
97 { 75, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
98 { 76, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
99 { 76, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
100 { 81, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
101 { 81, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
102 { 84, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
103 { 84, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
104 { 83, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
105 { 83, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
106 { 85, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
107 { 85, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
108 { 80, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
109 { 80, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
110 { 94, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
111 { 94, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
112 { 101, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
113 { 93, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
114 { 92, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
115 { 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
116 { 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
117 { 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
118 { 91, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
119 { 9, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 },
120 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
121 };
122
123 static const SCRIPT_PROPERTIES *script_props[] =
124 {
125 &props[0], &props[1], &props[2], &props[3],
126 &props[4], &props[5], &props[6], &props[7],
127 &props[8], &props[9], &props[11], &props[12],
128 &props[13], &props[14], &props[15], &props[16],
129 &props[17], &props[18], &props[19], &props[20],
130 &props[21], &props[22], &props[23], &props[24],
131 &props[25], &props[26], &props[27], &props[28],
132 &props[29], &props[30], &props[31], &props[32],
133 &props[33], &props[34], &props[35], &props[36],
134 &props[37], &props[38], &props[39], &props[40],
135 &props[41], &props[42], &props[43], &props[44],
136 &props[45], &props[46], &props[47], &props[48],
137 &props[49], &props[50], &props[51], &props[52],
138 &props[53], &props[54], &props[55], &props[56],
139 &props[57], &props[58], &props[59], &props[60],
140 &props[61], &props[62], &props[63], &props[64],
141 &props[65], &props[66], &props[67], &props[68],
142 &props[69], &props[70], &props[71], &props[72],
143 &props[73]
144 };
145
146 typedef struct {
147 HDC hdc;
148 LONG height;
149 WCHAR default_char;
150 } ScriptCache;
151
152 typedef struct {
153 int numGlyphs;
154 WORD* glyphs;
155 WORD* pwLogClust;
156 int* piAdvance;
157 SCRIPT_VISATTR* psva;
158 GOFFSET* pGoffset;
159 ABC* abc;
160 } StringGlyphs;
161
162 typedef struct {
163 BOOL invalid;
164 int clip_len;
165 ScriptCache *sc;
166 int cItems;
167 int cMaxGlyphs;
168 SCRIPT_ITEM* pItem;
169 int numItems;
170 StringGlyphs* glyphs;
171 SCRIPT_LOGATTR* logattrs;
172 SIZE* sz;
173 } StringAnalysis;
174
175 static inline void *usp_alloc(SIZE_T size)
176 {
177 return HeapAlloc(GetProcessHeap(), 0, size);
178 }
179
180 static inline void *usp_zero_alloc(SIZE_T size)
181 {
182 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
183 }
184
185 static inline void *usp_zero_realloc(LPVOID mem, SIZE_T size)
186 {
187 return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
188 }
189
190 static inline void usp_free(LPVOID mem)
191 {
192 HeapFree(GetProcessHeap(), 0, mem);
193 }
194
195 static HDC get_cache_hdc(SCRIPT_CACHE *psc)
196 {
197 return ((ScriptCache *)*psc)->hdc;
198 }
199
200 static WCHAR get_cache_default_char(SCRIPT_CACHE *psc)
201 {
202 return ((ScriptCache *)*psc)->default_char;
203 }
204
205 static LONG get_cache_height(SCRIPT_CACHE *psc)
206 {
207 return ((ScriptCache *)*psc)->height;
208 }
209
210 static HRESULT init_script_cache(const HDC hdc, ScriptCache *sc)
211 {
212 TEXTMETRICW metric;
213
214 if (!GetTextMetricsW(hdc, &metric)) return E_INVALIDARG;
215 sc->height = metric.tmHeight;
216 sc->default_char = metric.tmDefaultChar;
217 sc->hdc = hdc;
218 return S_OK;
219 }
220
221 static HRESULT get_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
222 {
223 if (!psc) return E_INVALIDARG;
224 if (!*psc)
225 {
226 HRESULT ret;
227 ScriptCache *sc;
228
229 if (!hdc) return E_PENDING;
230 if (!(sc = usp_zero_alloc(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
231 if ((ret = init_script_cache(hdc, sc)))
232 {
233 usp_free(sc);
234 return ret;
235 }
236 *psc = sc;
237 }
238 TRACE("<- %p\n", *psc);
239 return S_OK;
240 }
241
242 /***********************************************************************
243 * DllMain
244 *
245 */
246 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
247 {
248 switch(fdwReason)
249 {
250 case DLL_PROCESS_ATTACH:
251 DisableThreadLibraryCalls(hInstDLL);
252 break;
253 case DLL_PROCESS_DETACH:
254 break;
255 }
256 return TRUE;
257 }
258
259 /***********************************************************************
260 * ScriptFreeCache (USP10.@)
261 *
262 * Free a script cache.
263 *
264 * PARAMS
265 * psc [I/O] Script cache.
266 *
267 * RETURNS
268 * Success: S_OK
269 * Failure: Non-zero HRESULT value.
270 */
271 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
272 {
273 TRACE("%p\n", psc);
274
275 if (psc)
276 {
277 usp_free(*psc);
278 *psc = NULL;
279 }
280 return S_OK;
281 }
282
283 /***********************************************************************
284 * ScriptGetProperties (USP10.@)
285 *
286 * Retrieve a list of script properties.
287 *
288 * PARAMS
289 * props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
290 * num [I] Pointer to the number of scripts.
291 *
292 * RETURNS
293 * Success: S_OK
294 * Failure: Non-zero HRESULT value.
295 *
296 * NOTES
297 * Behaviour matches WinXP.
298 */
299 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
300 {
301 TRACE("(%p,%p)\n", props, num);
302
303 if (!props && !num) return E_INVALIDARG;
304
305 if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
306 if (props) *props = script_props;
307
308 return S_OK;
309 }
310
311 /***********************************************************************
312 * ScriptGetFontProperties (USP10.@)
313 *
314 * Get information on special glyphs.
315 *
316 * PARAMS
317 * hdc [I] Device context.
318 * psc [I/O] Opaque pointer to a script cache.
319 * sfp [O] Font properties structure.
320 */
321 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
322 {
323 HRESULT hr;
324
325 TRACE("%p,%p,%p\n", hdc, psc, sfp);
326
327 if (!sfp) return E_INVALIDARG;
328 if ((hr = get_script_cache(hdc, psc))) return hr;
329
330 if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
331 return E_INVALIDARG;
332
333 /* return something sensible? */
334 sfp->wgBlank = 0;
335 sfp->wgDefault = get_cache_default_char(psc);
336 sfp->wgInvalid = 0;
337 sfp->wgKashida = 0xffff;
338 sfp->iKashidaWidth = 0;
339
340 return S_OK;
341 }
342
343 /***********************************************************************
344 * ScriptRecordDigitSubstitution (USP10.@)
345 *
346 * Record digit substitution settings for a given locale.
347 *
348 * PARAMS
349 * locale [I] Locale identifier.
350 * sds [I] Structure to record substitution settings.
351 *
352 * RETURNS
353 * Success: S_OK
354 * Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
355 *
356 * SEE ALSO
357 * http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
358 */
359 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
360 {
361 DWORD plgid, sub;
362
363 TRACE("0x%x, %p\n", locale, sds);
364
365 /* This implementation appears to be correct for all languages, but it's
366 * not clear if sds->DigitSubstitute is ever set to anything except
367 * CONTEXT or NONE in reality */
368
369 if (!sds) return E_POINTER;
370
371 locale = ConvertDefaultLocale(locale);
372
373 if (!IsValidLocale(locale, LCID_INSTALLED))
374 return E_INVALIDARG;
375
376 plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
377 sds->TraditionalDigitLanguage = plgid;
378
379 if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
380 sds->NationalDigitLanguage = plgid;
381 else
382 sds->NationalDigitLanguage = LANG_ENGLISH;
383
384 if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
385 (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
386
387 switch (sub)
388 {
389 case 0:
390 if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
391 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
392 else
393 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
394 break;
395 case 1:
396 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
397 break;
398 case 2:
399 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
400 break;
401 default:
402 sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
403 break;
404 }
405
406 sds->dwReserved = 0;
407 return S_OK;
408 }
409
410 /***********************************************************************
411 * ScriptApplyDigitSubstitution (USP10.@)
412 *
413 * Apply digit substitution settings.
414 *
415 * PARAMS
416 * sds [I] Structure with recorded substitution settings.
417 * sc [I] Script control structure.
418 * ss [I] Script state structure.
419 *
420 * RETURNS
421 * Success: S_OK
422 * Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
423 */
424 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds,
425 SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
426 {
427 SCRIPT_DIGITSUBSTITUTE psds;
428
429 TRACE("%p, %p, %p\n", sds, sc, ss);
430
431 if (!sc || !ss) return E_POINTER;
432 if (!sds)
433 {
434 sds = &psds;
435 if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
436 return E_INVALIDARG;
437 }
438
439 sc->uDefaultLanguage = LANG_ENGLISH;
440 sc->fContextDigits = 0;
441 ss->fDigitSubstitute = 0;
442
443 switch (sds->DigitSubstitute) {
444 case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
445 case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
446 case SCRIPT_DIGITSUBSTITUTE_NONE:
447 case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
448 return S_OK;
449 default:
450 return E_INVALIDARG;
451 }
452 }
453
454 /***********************************************************************
455 * ScriptItemize (USP10.@)
456 *
457 * Split a Unicode string into shapeable parts.
458 *
459 * PARAMS
460 * pwcInChars [I] String to split.
461 * cInChars [I] Number of characters in pwcInChars.
462 * cMaxItems [I] Maximum number of items to return.
463 * psControl [I] Pointer to a SCRIPT_CONTROL structure.
464 * psState [I] Pointer to a SCRIPT_STATE structure.
465 * pItems [O] Buffer to receive SCRIPT_ITEM structures.
466 * pcItems [O] Number of script items returned.
467 *
468 * RETURNS
469 * Success: S_OK
470 * Failure: Non-zero HRESULT value.
471 */
472 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
473 const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
474 SCRIPT_ITEM *pItems, int *pcItems)
475 {
476
477 #define Numeric_start 0x0030
478 #define Numeric_stop 0x0039
479 #define Numeric_space 0x0020
480 #define Arabic_start 0x0600
481 #define Arabic_stop 0x06ff
482 #define Latin_start 0x0001
483 #define Latin_stop 0x024f
484 #define Script_Arabic 6
485 #define Script_Latin 1
486 #define Script_Numeric 5
487
488 int cnt = 0, index = 0;
489 int New_Script = SCRIPT_UNDEFINED;
490
491 TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems,
492 psControl, psState, pItems, pcItems);
493
494 if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
495 return E_INVALIDARG;
496
497 pItems[index].iCharPos = 0;
498 memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
499
500 if (pwcInChars[cnt] >= Numeric_start && pwcInChars[cnt] <= Numeric_stop)
501 pItems[index].a.eScript = Script_Numeric;
502 else
503 if (pwcInChars[cnt] >= Arabic_start && pwcInChars[cnt] <= Arabic_stop)
504 pItems[index].a.eScript = Script_Arabic;
505 else
506 if (pwcInChars[cnt] >= Latin_start && pwcInChars[cnt] <= Latin_stop)
507 pItems[index].a.eScript = Script_Latin;
508
509 if (pItems[index].a.eScript == Script_Arabic)
510 pItems[index].a.s.uBidiLevel = 1;
511
512 TRACE("New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
513 New_Script, pItems[index].a.eScript, index, cnt,
514 pItems[index].iCharPos = cnt);
515
516 for (cnt=0; cnt < cInChars; cnt++)
517 {
518 if ((pwcInChars[cnt] >= Numeric_start && pwcInChars[cnt] <= Numeric_stop)
519 || (New_Script == Script_Numeric && pwcInChars[cnt] == Numeric_space))
520 New_Script = Script_Numeric;
521 else
522 if ((pwcInChars[cnt] >= Arabic_start && pwcInChars[cnt] <= Arabic_stop)
523 || (New_Script == Script_Arabic && pwcInChars[cnt] == Numeric_space))
524 New_Script = Script_Arabic;
525 else
526 if ((WCHAR) pwcInChars[cnt] >= Latin_start && (WCHAR) pwcInChars[cnt] <= Latin_stop)
527 New_Script = Script_Latin;
528 else
529 New_Script = SCRIPT_UNDEFINED;
530
531 if (New_Script != pItems[index].a.eScript)
532 {
533 TRACE("New_Script=%d, eScript=%d ", New_Script, pItems[index].a.eScript);
534 index++;
535 if (index+1 > cMaxItems)
536 return E_OUTOFMEMORY;
537
538 pItems[index].iCharPos = cnt;
539 memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
540
541 if (New_Script == Script_Arabic)
542 pItems[index].a.s.uBidiLevel = 1;
543
544 pItems[index].a.eScript = New_Script;
545 if (New_Script == Script_Arabic)
546 pItems[index].a.s.uBidiLevel = 1;
547
548 TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos = cnt);
549 }
550 }
551
552 /* While not strictly necessary according to the spec, make sure the n+1
553 * item is set up to prevent random behaviour if the caller erroneously
554 * checks the n+1 structure */
555 memset(&pItems[index+1].a, 0, sizeof(SCRIPT_ANALYSIS));
556
557 TRACE("index=%d cnt=%d iCharPos=%d\n", index+1, cnt, pItems[index+1].iCharPos = cnt);
558
559 /* Set one SCRIPT_STATE item being returned */
560 *pcItems = index + 1;
561
562 /* Set SCRIPT_ITEM */
563 pItems[index+1].iCharPos = cnt; /* the last + 1 item
564 contains the ptr to the lastchar */
565 return S_OK;
566 }
567
568 /***********************************************************************
569 * ScriptStringAnalyse (USP10.@)
570 *
571 */
572 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
573 int cGlyphs, int iCharset, DWORD dwFlags,
574 int iReqWidth, SCRIPT_CONTROL *psControl,
575 SCRIPT_STATE *psState, const int *piDx,
576 SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
577 SCRIPT_STRING_ANALYSIS *pssa)
578 {
579 HRESULT hr = E_OUTOFMEMORY;
580 StringAnalysis *analysis = NULL;
581 int i, num_items = 255;
582
583 TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
584 hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
585 psControl, psState, piDx, pTabdef, pbInClass, pssa);
586
587 if (iCharset != -1)
588 {
589 FIXME("Only Unicode strings are supported\n");
590 return E_INVALIDARG;
591 }
592 if (cString < 1 || !pString) return E_INVALIDARG;
593 if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
594
595 if (!(analysis = usp_zero_alloc(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
596 if (!(analysis->pItem = usp_zero_alloc(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
597
598 /* FIXME: handle clipping */
599 analysis->clip_len = cString;
600
601 hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
602 &analysis->numItems);
603
604 while (hr == E_OUTOFMEMORY)
605 {
606 SCRIPT_ITEM *tmp;
607
608 num_items *= 2;
609 if (!(tmp = usp_zero_realloc(analysis->pItem, num_items * sizeof(SCRIPT_ITEM) + 1)))
610 goto error;
611
612 analysis->pItem = tmp;
613 hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
614 &analysis->numItems);
615 }
616 if (hr) goto error;
617
618 if ((analysis->logattrs = usp_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
619 ScriptBreak(pString, cString, (SCRIPT_STRING_ANALYSIS)analysis, analysis->logattrs);
620 else
621 goto error;
622
623 if (!(analysis->glyphs = usp_zero_alloc(sizeof(StringGlyphs) * analysis->numItems)))
624 goto error;
625
626 for (i = 0; i < analysis->numItems; i++)
627 {
628 SCRIPT_CACHE *sc = (SCRIPT_CACHE *)&analysis->sc;
629 int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
630 int numGlyphs = 1.5 * cChar + 16;
631 WORD *glyphs = usp_zero_alloc(sizeof(WORD) * numGlyphs);
632 WORD *pwLogClust = usp_zero_alloc(sizeof(WORD) * cChar);
633 int *piAdvance = usp_zero_alloc(sizeof(int) * numGlyphs);
634 SCRIPT_VISATTR *psva = usp_zero_alloc(sizeof(SCRIPT_VISATTR) * cChar);
635 GOFFSET *pGoffset = usp_zero_alloc(sizeof(GOFFSET) * numGlyphs);
636 ABC *abc = usp_zero_alloc(sizeof(ABC));
637 int numGlyphsReturned;
638
639 /* FIXME: non unicode strings */
640 WCHAR* pStr = (WCHAR*)pString;
641 hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
642 cChar, numGlyphs, &analysis->pItem[i].a,
643 glyphs, pwLogClust, psva, &numGlyphsReturned);
644 hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
645 piAdvance, pGoffset, abc);
646
647 analysis->glyphs[i].numGlyphs = numGlyphsReturned;
648 analysis->glyphs[i].glyphs = glyphs;
649 analysis->glyphs[i].pwLogClust = pwLogClust;
650 analysis->glyphs[i].piAdvance = piAdvance;
651 analysis->glyphs[i].psva = psva;
652 analysis->glyphs[i].pGoffset = pGoffset;
653 analysis->glyphs[i].abc = abc;
654 }
655
656 *pssa = analysis;
657 return S_OK;
658
659 error:
660 usp_free(analysis->glyphs);
661 usp_free(analysis->logattrs);
662 usp_free(analysis->pItem);
663 usp_free(analysis);
664 return hr;
665 }
666
667 /***********************************************************************
668 * ScriptStringOut (USP10.@)
669 *
670 * This function takes the output of ScriptStringAnalyse and joins the segments
671 * of glyphs and passes the resulting string to ScriptTextOut. ScriptStringOut
672 * only processes glyphs.
673 *
674 * Parameters:
675 * ssa [I] buffer to hold the analysed string components
676 * iX [I] X axis displacement for output
677 * iY [I] Y axis displacement for output
678 * uOptions [I] flags controling output processing
679 * prc [I] rectangle coordinates
680 * iMinSel [I] starting pos for substringing output string
681 * iMaxSel [I] ending pos for substringing output string
682 * fDisabled [I] controls text highlighting
683 *
684 * RETURNS
685 * Success: S_OK
686 * Failure: is the value returned by ScriptTextOut
687 */
688 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
689 int iX,
690 int iY,
691 UINT uOptions,
692 const RECT *prc,
693 int iMinSel,
694 int iMaxSel,
695 BOOL fDisabled)
696 {
697 StringAnalysis *analysis;
698 WORD *glyphs;
699 int item, cnt, x;
700 HRESULT hr;
701
702 TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
703 ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
704
705 if (!(analysis = ssa)) return E_INVALIDARG;
706
707 /*
708 * Get storage for the output buffer for the consolidated strings
709 */
710 cnt = 0;
711 for (item = 0; item < analysis->numItems; item++)
712 {
713 cnt += analysis->glyphs[item].numGlyphs;
714 }
715 if (!(glyphs = usp_alloc(sizeof(WCHAR) * cnt))) return E_OUTOFMEMORY;
716
717 /*
718 * ScriptStringOut only processes glyphs hence set ETO_GLYPH_INDEX
719 */
720 uOptions |= ETO_GLYPH_INDEX;
721 analysis->pItem[0].a.fNoGlyphIndex = FALSE; /* say that we have glyphs */
722
723 /*
724 * Copy the string items into the output buffer
725 */
726
727 TRACE("numItems %d\n", analysis->numItems);
728
729 cnt = 0;
730 for (item = 0; item < analysis->numItems; item++)
731 {
732 memcpy(&glyphs[cnt], analysis->glyphs[item].glyphs,
733 sizeof(WCHAR) * analysis->glyphs[item].numGlyphs);
734
735 TRACE("Item %d, Glyphs %d ", item, analysis->glyphs[item].numGlyphs);
736 for (x = cnt; x < analysis->glyphs[item].numGlyphs + cnt; x ++)
737 TRACE("%04x", glyphs[x]);
738 TRACE("\n");
739
740 cnt += analysis->glyphs[item].numGlyphs; /* point to the end of the copied text */
741 }
742
743 hr = ScriptTextOut(analysis->sc->hdc, (SCRIPT_CACHE *)&analysis->sc, iX, iY,
744 uOptions, prc, &analysis->pItem->a, NULL, 0, glyphs, cnt,
745 analysis->glyphs->piAdvance, NULL, analysis->glyphs->pGoffset);
746 TRACE("ScriptTextOut hr=%08x\n", hr);
747
748 /*
749 * Free the output buffer and script cache
750 */
751 usp_free(glyphs);
752 return hr;
753 }
754
755 /***********************************************************************
756 * ScriptStringCPtoX (USP10.@)
757 *
758 */
759 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
760 {
761 int i, j;
762 int runningX = 0;
763 int runningCp = 0;
764 StringAnalysis* analysis = ssa;
765
766 TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
767
768 if (!ssa || !pX) return S_FALSE;
769
770 /* icp out of range */
771 if(icp < 0)
772 {
773 analysis->invalid = TRUE;
774 return E_INVALIDARG;
775 }
776
777 for(i=0; i<analysis->numItems; i++)
778 {
779 for(j=0; j<analysis->glyphs[i].numGlyphs; j++)
780 {
781 if(runningCp == icp && fTrailing == FALSE)
782 {
783 *pX = runningX;
784 return S_OK;
785 }
786 runningX += analysis->glyphs[i].piAdvance[j];
787 if(runningCp == icp && fTrailing == TRUE)
788 {
789 *pX = runningX;
790 return S_OK;
791 }
792 runningCp++;
793 }
794 }
795
796 /* icp out of range */
797 analysis->invalid = TRUE;
798 return E_INVALIDARG;
799 }
800
801 /***********************************************************************
802 * ScriptStringXtoCP (USP10.@)
803 *
804 */
805 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing)
806 {
807 StringAnalysis* analysis = ssa;
808 int i;
809 int j;
810 int runningX = 0;
811 int runningCp = 0;
812 int width;
813
814 TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
815
816 if (!ssa || !piCh || !piTrailing) return S_FALSE;
817
818 /* out of range */
819 if(iX < 0)
820 {
821 *piCh = -1;
822 *piTrailing = TRUE;
823 return S_OK;
824 }
825
826 for(i=0; i<analysis->numItems; i++)
827 {
828 for(j=0; j<analysis->glyphs[i].numGlyphs; j++)
829 {
830 width = analysis->glyphs[i].piAdvance[j];
831 if(iX < (runningX + width))
832 {
833 *piCh = runningCp;
834 if((iX - runningX) > width/2)
835 *piTrailing = TRUE;
836 else
837 *piTrailing = FALSE;
838 return S_OK;
839 }
840 runningX += width;
841 runningCp++;
842 }
843 }
844
845 /* out of range */
846 *piCh = analysis->pItem[analysis->numItems].iCharPos;
847 *piTrailing = FALSE;
848
849 return S_OK;
850 }
851
852
853 /***********************************************************************
854 * ScriptStringFree (USP10.@)
855 *
856 * Free a string analysis.
857 *
858 * PARAMS
859 * pssa [I] string analysis.
860 *
861 * RETURNS
862 * Success: S_OK
863 * Failure: Non-zero HRESULT value.
864 */
865 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
866 {
867 StringAnalysis* analysis;
868 BOOL invalid;
869 int i;
870
871 TRACE("(%p)\n", pssa);
872
873 if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
874 invalid = analysis->invalid;
875
876 for (i = 0; i < analysis->numItems; i++)
877 {
878 usp_free(analysis->glyphs[i].glyphs);
879 usp_free(analysis->glyphs[i].pwLogClust);
880 usp_free(analysis->glyphs[i].piAdvance);
881 usp_free(analysis->glyphs[i].psva);
882 usp_free(analysis->glyphs[i].pGoffset);
883 usp_free(analysis->glyphs[i].abc);
884 }
885
886 usp_free(analysis->glyphs);
887 usp_free(analysis->pItem);
888 usp_free(analysis->logattrs);
889 usp_free(analysis->sz);
890 usp_free(analysis);
891
892 if (invalid) return E_INVALIDARG;
893 return S_OK;
894 }
895
896 /***********************************************************************
897 * ScriptCPtoX (USP10.@)
898 *
899 */
900 HRESULT WINAPI ScriptCPtoX(int iCP,
901 BOOL fTrailing,
902 int cChars,
903 int cGlyphs,
904 const WORD *pwLogClust,
905 const SCRIPT_VISATTR *psva,
906 const int *piAdvance,
907 const SCRIPT_ANALYSIS *psa,
908 int *piX)
909 {
910 int item;
911 int iPosX;
912 float fMaxPosX = 0;
913 TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
914 iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
915 psa, piX);
916 for (item=0; item < cGlyphs; item++) /* total piAdvance */
917 fMaxPosX += piAdvance[item];
918 iPosX = (fMaxPosX/cGlyphs)*(iCP+fTrailing);
919 if (iPosX > fMaxPosX)
920 iPosX = fMaxPosX;
921 *piX = iPosX; /* Return something in range */
922
923 TRACE("*piX=%d\n", *piX);
924 return S_OK;
925 }
926
927 /***********************************************************************
928 * ScriptXtoCP (USP10.@)
929 *
930 */
931 HRESULT WINAPI ScriptXtoCP(int iX,
932 int cChars,
933 int cGlyphs,
934 const WORD *pwLogClust,
935 const SCRIPT_VISATTR *psva,
936 const int *piAdvance,
937 const SCRIPT_ANALYSIS *psa,
938 int *piCP,
939 int *piTrailing)
940 {
941 int item;
942 int iPosX;
943 float fMaxPosX = 1;
944 float fAvePosX;
945 TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
946 iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
947 psa, piCP, piTrailing);
948 if (iX < 0) /* iX is before start of run */
949 {
950 *piCP = -1;
951 *piTrailing = TRUE;
952 return S_OK;
953 }
954
955 for (item=0; item < cGlyphs; item++) /* total piAdvance */
956 fMaxPosX += piAdvance[item];
957
958 if (iX >= fMaxPosX) /* iX too large */
959 {
960 *piCP = cChars;
961 *piTrailing = FALSE;
962 return S_OK;
963 }
964
965 fAvePosX = fMaxPosX / cGlyphs;
966 iPosX = fAvePosX;
967 for (item = 1; item < cGlyphs && iPosX < iX; item++)
968 iPosX += fAvePosX;
969 if (iPosX - iX > fAvePosX/2)
970 *piTrailing = 0;
971 else
972 *piTrailing = 1; /* yep we are over halfway */
973
974 *piCP = item -1; /* Return character position */
975 TRACE("*piCP=%d iPposX=%d\n", *piCP, iPosX);
976 return S_OK;
977 }
978
979 /***********************************************************************
980 * ScriptBreak (USP10.@)
981 *
982 * Retrieve line break information.
983 *
984 * PARAMS
985 * chars [I] Array of characters.
986 * sa [I] String analysis.
987 * la [I] Array of logical attribute structures.
988 *
989 * RETURNS
990 * Success: S_OK
991 * Failure: S_FALSE
992 */
993 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
994 {
995 unsigned int i;
996
997 TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
998
999 if (!la) return S_FALSE;
1000
1001 for (i = 0; i < count; i++)
1002 {
1003 memset(&la[i], 0, sizeof(SCRIPT_LOGATTR));
1004
1005 /* FIXME: set the other flags */
1006 la[i].fWhiteSpace = isspaceW(chars[i]);
1007 la[i].fCharStop = 1;
1008 }
1009 return S_OK;
1010 }
1011
1012 static const struct
1013 {
1014 WCHAR start;
1015 WCHAR end;
1016 DWORD flag;
1017 }
1018 complex_ranges[] =
1019 {
1020 { 0, 0x0b, SIC_COMPLEX },
1021 { 0x0c, 0x0c, SIC_NEUTRAL },
1022 { 0x0d, 0x1f, SIC_COMPLEX },
1023 { 0x20, 0x2f, SIC_NEUTRAL },
1024 { 0x30, 0x39, SIC_ASCIIDIGIT },
1025 { 0x3a, 0x40, SIC_NEUTRAL },
1026 { 0x5b, 0x60, SIC_NEUTRAL },
1027 { 0x7b, 0x7e, SIC_NEUTRAL },
1028 { 0x7f, 0x9f, SIC_COMPLEX },
1029 { 0xa0, 0xa5, SIC_NEUTRAL },
1030 { 0xa7, 0xa8, SIC_NEUTRAL },
1031 { 0xab, 0xab, SIC_NEUTRAL },
1032 { 0xad, 0xad, SIC_NEUTRAL },
1033 { 0xaf, 0xaf, SIC_NEUTRAL },
1034 { 0xb0, 0xb1, SIC_NEUTRAL },
1035 { 0xb4, 0xb4, SIC_NEUTRAL },
1036 { 0xb6, 0xb8, SIC_NEUTRAL },
1037 { 0xbb, 0xbf, SIC_NEUTRAL },
1038 { 0xd7, 0xd7, SIC_NEUTRAL },
1039 { 0xf7, 0xf7, SIC_NEUTRAL },
1040 { 0x2b9, 0x2ba, SIC_NEUTRAL },
1041 { 0x2c2, 0x2cf, SIC_NEUTRAL },
1042 { 0x2d2, 0x2df, SIC_NEUTRAL },
1043 { 0x2e5, 0x2e9, SIC_COMPLEX },
1044 { 0x2ea, 0x2ed, SIC_NEUTRAL },
1045 { 0x300, 0x362, SIC_COMPLEX },
1046 { 0x530, 0x60b, SIC_COMPLEX },
1047 { 0x60c, 0x60d, SIC_NEUTRAL },
1048 { 0x60e, 0x669, SIC_COMPLEX },
1049 { 0x66a, 0x66a, SIC_NEUTRAL },
1050 { 0x66b, 0x6e8, SIC_COMPLEX },
1051 { 0x6e9, 0x6e9, SIC_NEUTRAL },
1052 { 0x6ea, 0x7bf, SIC_COMPLEX },
1053 { 0x900, 0x1360, SIC_COMPLEX },
1054 { 0x137d, 0x137f, SIC_COMPLEX },
1055 { 0x1680, 0x1680, SIC_NEUTRAL },
1056 { 0x1780, 0x18af, SIC_COMPLEX },
1057 { 0x2000, 0x200a, SIC_NEUTRAL },
1058 { 0x200b, 0x200f, SIC_COMPLEX },
1059 { 0x2010, 0x2016, SIC_NEUTRAL },
1060 { 0x2018, 0x2022, SIC_NEUTRAL },
1061 { 0x2024, 0x2028, SIC_NEUTRAL },
1062 { 0x2029, 0x202e, SIC_COMPLEX },
1063 { 0x202f, 0x2037, SIC_NEUTRAL },
1064 { 0x2039, 0x203c, SIC_NEUTRAL },
1065 { 0x2044, 0x2046, SIC_NEUTRAL },
1066 { 0x206a, 0x206f, SIC_COMPLEX },
1067 { 0x207a, 0x207e, SIC_NEUTRAL },
1068 { 0x208a, 0x20aa, SIC_NEUTRAL },
1069 { 0x20ac, 0x20cf, SIC_NEUTRAL },
1070 { 0x20d0, 0x20ff, SIC_COMPLEX },
1071 { 0x2103, 0x2103, SIC_NEUTRAL },
1072 { 0x2105, 0x2105, SIC_NEUTRAL },
1073 { 0x2109, 0x2109, SIC_NEUTRAL },
1074 { 0x2116, 0x2116, SIC_NEUTRAL },
1075 { 0x2121, 0x2122, SIC_NEUTRAL },
1076 { 0x212e, 0x212e, SIC_NEUTRAL },
1077 { 0x2153, 0x2154, SIC_NEUTRAL },
1078 { 0x215b, 0x215e, SIC_NEUTRAL },
1079 { 0x2190, 0x2199, SIC_NEUTRAL },
1080 { 0x21b8, 0x21b9, SIC_NEUTRAL },
1081 { 0x21d2, 0x21d2, SIC_NEUTRAL },
1082 { 0x21d4, 0x21d4, SIC_NEUTRAL },
1083 { 0x21e7, 0x21e7, SIC_NEUTRAL },
1084 { 0x2200, 0x2200, SIC_NEUTRAL },
1085 { 0x2202, 0x2203, SIC_NEUTRAL },
1086 { 0x2207, 0x2208, SIC_NEUTRAL },
1087 { 0x220b, 0x220b, SIC_NEUTRAL },
1088 { 0x220f, 0x220f, SIC_NEUTRAL },
1089 { 0x2211, 0x2213, SIC_NEUTRAL },
1090 { 0x2215, 0x2215, SIC_NEUTRAL },
1091 { 0x221a, 0x221a, SIC_NEUTRAL },
1092 { 0x221d, 0x2220, SIC_NEUTRAL },
1093 { 0x2223, 0x2223, SIC_NEUTRAL },
1094 { 0x2225, 0x2225, SIC_NEUTRAL },
1095 { 0x2227, 0x222c, SIC_NEUTRAL },
1096 { 0x222e, 0x222e, SIC_NEUTRAL },
1097 { 0x2234, 0x2237, SIC_NEUTRAL },
1098 { 0x223c, 0x223d, SIC_NEUTRAL },
1099 { 0x2248, 0x2248, SIC_NEUTRAL },
1100 { 0x224c, 0x224c, SIC_NEUTRAL },
1101 { 0x2252, 0x2252, SIC_NEUTRAL },
1102 { 0x2260, 0x2261, SIC_NEUTRAL },
1103 { 0x2264, 0x2267, SIC_NEUTRAL },
1104 { 0x226a, 0x226b, SIC_NEUTRAL },
1105 { 0x226e, 0x226f, SIC_NEUTRAL },
1106 { 0x2282, 0x2283, SIC_NEUTRAL },
1107 { 0x2286, 0x2287, SIC_NEUTRAL },
1108 { 0x2295, 0x2295, SIC_NEUTRAL },
1109 { 0x2299, 0x2299, SIC_NEUTRAL },
1110 { 0x22a5, 0x22a5, SIC_NEUTRAL },
1111 { 0x22bf, 0x22bf, SIC_NEUTRAL },
1112 { 0x2312, 0x2312, SIC_NEUTRAL },
1113 { 0x24ea, 0x24ea, SIC_COMPLEX },
1114 { 0x2500, 0x254b, SIC_NEUTRAL },
1115 { 0x2550, 0x256d, SIC_NEUTRAL },
1116 { 0x256e, 0x2574, SIC_NEUTRAL },
1117 { 0x2581, 0x258f, SIC_NEUTRAL },
1118 { 0x2592, 0x2595, SIC_NEUTRAL },
1119 { 0x25a0, 0x25a1, SIC_NEUTRAL },
1120 { 0x25a3, 0x25a9, SIC_NEUTRAL },
1121 { 0x25b2, 0x25b3, SIC_NEUTRAL },
1122 { 0x25b6, 0x25b7, SIC_NEUTRAL },
1123 { 0x25bc, 0x25bd, SIC_NEUTRAL },
1124 { 0x25c0, 0x25c1, SIC_NEUTRAL },
1125 { 0x25c6, 0x25c8, SIC_NEUTRAL },
1126 { 0x25cb, 0x25cb, SIC_NEUTRAL },
1127 { 0x25ce, 0x25d1, SIC_NEUTRAL },
1128 { 0x25e2, 0x25e5, SIC_NEUTRAL },
1129 { 0x25ef, 0x25ef, SIC_NEUTRAL },
1130 { 0x2605, 0x2606, SIC_NEUTRAL },
1131 { 0x2609, 0x2609, SIC_NEUTRAL },
1132 { 0x260e, 0x260f, SIC_NEUTRAL },
1133 { 0x261c, 0x261c, SIC_NEUTRAL },
1134 { 0x261e, 0x261e, SIC_NEUTRAL },
1135 { 0x2640, 0x2640, SIC_NEUTRAL },
1136 { 0x2642, 0x2642, SIC_NEUTRAL },
1137 { 0x2660, 0x2661, SIC_NEUTRAL },
1138 { 0x2663, 0x2665, SIC_NEUTRAL },
1139 { 0x2667, 0x266a, SIC_NEUTRAL },
1140 { 0x266c, 0x266d, SIC_NEUTRAL },
1141 { 0x266f, 0x266f, SIC_NEUTRAL },
1142 { 0x273d, 0x273d, SIC_NEUTRAL },
1143 { 0x2e80, 0x312f, SIC_COMPLEX },
1144 { 0x3190, 0x31bf, SIC_COMPLEX },
1145 { 0x31f0, 0x31ff, SIC_COMPLEX },
1146 { 0x3220, 0x325f, SIC_COMPLEX },
1147 { 0x3280, 0xa4ff, SIC_COMPLEX },
1148 { 0xd800, 0xdfff, SIC_COMPLEX },
1149 { 0xe000, 0xf8ff, SIC_NEUTRAL },
1150 { 0xf900, 0xfaff, SIC_COMPLEX },
1151 { 0xfb13, 0xfb28, SIC_COMPLEX },
1152 { 0xfb29, 0xfb29, SIC_NEUTRAL },
1153 { 0xfb2a, 0xfb4f, SIC_COMPLEX },
1154 { 0xfd3e, 0xfd3f, SIC_NEUTRAL },
1155 { 0xfdd0, 0xfdef, SIC_COMPLEX },
1156 { 0xfe20, 0xfe6f, SIC_COMPLEX },
1157 { 0xfeff, 0xfeff, SIC_COMPLEX },
1158 { 0xff01, 0xff5e, SIC_COMPLEX },
1159 { 0xff61, 0xff9f, SIC_COMPLEX },
1160 { 0xffe0, 0xffe6, SIC_COMPLEX },
1161 { 0xffe8, 0xffee, SIC_COMPLEX },
1162 { 0xfff9, 0xfffb, SIC_COMPLEX },
1163 { 0xfffe, 0xfffe, SIC_COMPLEX }
1164 };
1165
1166 /***********************************************************************
1167 * ScriptIsComplex (USP10.@)
1168 *
1169 * Determine if a string is complex.
1170 *
1171 * PARAMS
1172 * chars [I] Array of characters to test.
1173 * len [I] Length in characters.
1174 * flag [I] Flag.
1175 *
1176 * RETURNS
1177 * Success: S_OK
1178 * Failure: S_FALSE
1179 *
1180 * NOTES
1181 * Behaviour matches that of WinXP.
1182 */
1183 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
1184 {
1185 unsigned int i, j;
1186
1187 TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
1188
1189 for (i = 0; i < len; i++)
1190 {
1191 for (j = 0; j < sizeof(complex_ranges)/sizeof(complex_ranges[0]); j++)
1192 {
1193 if (chars[i] >= complex_ranges[j].start &&
1194 chars[i] <= complex_ranges[j].end &&
1195 (flag & complex_ranges[j].flag)) return S_OK;
1196 }
1197 }
1198 return S_FALSE;
1199 }
1200
1201 /***********************************************************************
1202 * ScriptShape (USP10.@)
1203 *
1204 * Produce glyphs and visual attributes for a run.
1205 *
1206 * PARAMS
1207 * hdc [I] Device context.
1208 * psc [I/O] Opaque pointer to a script cache.
1209 * pwcChars [I] Array of characters specifying the run.
1210 * cChars [I] Number of characters in pwcChars.
1211 * cMaxGlyphs [I] Length of pwOutGlyphs.
1212 * psa [I/O] String analysis.
1213 * pwOutGlyphs [O] Array of glyphs.
1214 * pwLogClust [O] Array of logical cluster info.
1215 * psva [O] Array of visual attributes.
1216 * pcGlyphs [O] Number of glyphs returned.
1217 *
1218 * RETURNS
1219 * Success: S_OK
1220 * Failure: Non-zero HRESULT value.
1221 */
1222 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars,
1223 int cChars, int cMaxGlyphs,
1224 SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
1225 SCRIPT_VISATTR *psva, int *pcGlyphs)
1226 {
1227 int cnt;
1228 HRESULT hr;
1229 *pcGlyphs = cChars;
1230
1231 TRACE("(%p, %p, %p, %d, %d, %p)\n", hdc, psc, pwcChars, cChars, cMaxGlyphs, psa);
1232 if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
1233 psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
1234
1235 if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
1236 if ((hr = get_script_cache(hdc, psc))) return hr;
1237
1238 TRACE("Before: ");
1239 for (cnt = 0; cnt < cChars; cnt++)
1240 TRACE("%4x",pwcChars[cnt]);
1241 TRACE("\n");
1242
1243 if (!psa->fNoGlyphIndex) { /* Glyph translate */
1244 if (!(GetGlyphIndicesW(get_cache_hdc(psc), pwcChars, cChars, pwOutGlyphs, 0)))
1245 return S_FALSE;
1246
1247 TRACE("After: ");
1248 for (cnt = 0; cnt < cChars; cnt++) {
1249 TRACE("%04x",pwOutGlyphs[cnt]);
1250 }
1251 TRACE("\n");
1252 }
1253 else {
1254 TRACE("After: ");
1255 for (cnt = 0; cnt < cChars; cnt++) { /* no translate so set up */
1256 pwOutGlyphs[cnt] = pwcChars[cnt]; /* copy in to out and */
1257 TRACE("%04x",pwOutGlyphs[cnt]);
1258 }
1259 TRACE("\n");
1260 }
1261
1262 /* Set up a valid SCRIPT_VISATTR and LogClust for each char in this run */
1263 for (cnt = 0; cnt < cChars; cnt++) {
1264 /* FIXME: set to better values */
1265 psva[cnt].uJustification = 2;
1266 psva[cnt].fClusterStart = 1;
1267 psva[cnt].fDiacritic = 0;
1268 psva[cnt].fZeroWidth = 0;
1269 pwLogClust[cnt] = cnt;
1270 }
1271 return S_OK;
1272 }
1273
1274 /***********************************************************************
1275 * ScriptPlace (USP10.@)
1276 *
1277 * Produce advance widths for a run.
1278 *
1279 * PARAMS
1280 * hdc [I] Device context.
1281 * psc [I/O] Opaque pointer to a script cache.
1282 * pwGlyphs [I] Array of glyphs.
1283 * cGlyphs [I] Number of glyphs in pwGlyphs.
1284 * psva [I] Array of visual attributes.
1285 * psa [I/O] String analysis.
1286 * piAdvance [O] Array of advance widths.
1287 * pGoffset [O] Glyph offsets.
1288 * pABC [O] Combined ABC width.
1289 *
1290 * RETURNS
1291 * Success: S_OK
1292 * Failure: Non-zero HRESULT value.
1293 */
1294 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs,
1295 int cGlyphs, const SCRIPT_VISATTR *psva,
1296 SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
1297 {
1298 int wcnt;
1299 HRESULT hr;
1300 LPABC lpABC;
1301
1302 TRACE("(%p, %p, %p, %s, %d, %p, %p, %p)\n", hdc, psc, pwGlyphs,
1303 debugstr_wn(pwGlyphs, cGlyphs), cGlyphs, psva, psa, piAdvance);
1304
1305 if ((hr = get_script_cache(hdc, psc))) return hr;
1306
1307 /* Here we need to calculate the width of the run unit. At this point the input string
1308 * has been converted to glyphs and we still need to translate back to the original chars
1309 * to get the correct ABC widths. */
1310
1311 if (!(lpABC = usp_zero_alloc(sizeof(ABC) * cGlyphs))) return E_OUTOFMEMORY;
1312
1313 memset(pABC, 0, sizeof(ABC));
1314
1315 /* FIXME: set pGoffset to more reasonable values */
1316 if (!GetCharABCWidthsI(get_cache_hdc(psc), 0, cGlyphs, (WORD *) pwGlyphs, lpABC ))
1317 {
1318 WARN("Could not get ABC values\n");
1319 for (wcnt = 0; wcnt < cGlyphs; wcnt++) {
1320 piAdvance[wcnt] = 0;
1321 pGoffset[wcnt].du = 0;
1322 pGoffset[wcnt].dv = 0;
1323 }
1324 }
1325 else
1326 {
1327 for (wcnt = 0; wcnt < cGlyphs ; wcnt++) { /* add up the char lengths */
1328 TRACE(" Glyph=%04x, abcA=%d, abcB=%d, abcC=%d wcnt=%d\n",
1329 pwGlyphs[wcnt],
1330 lpABC[wcnt].abcA,
1331 lpABC[wcnt].abcB,
1332 lpABC[wcnt].abcC, wcnt);
1333 pABC->abcA += lpABC[wcnt].abcA;
1334 pABC->abcB += lpABC[wcnt].abcB;
1335 pABC->abcC += lpABC[wcnt].abcC;
1336 piAdvance[wcnt] = lpABC[wcnt].abcA + lpABC[wcnt].abcB + lpABC[wcnt].abcC;
1337 pGoffset[wcnt].du = 0;
1338 pGoffset[wcnt].dv = 0;
1339 }
1340 }
1341 TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
1342
1343 usp_free(lpABC);
1344 return S_OK;
1345 }
1346
1347 /***********************************************************************
1348 * ScriptGetCMap (USP10.@)
1349 *
1350 * Retrieve glyph indices.
1351 *
1352 * PARAMS
1353 * hdc [I] Device context.
1354 * psc [I/O] Opaque pointer to a script cache.
1355 * pwcInChars [I] Array of Unicode characters.
1356 * cChars [I] Number of characters in pwcInChars.
1357 * dwFlags [I] Flags.
1358 * pwOutGlyphs [O] Buffer to receive the array of glyph indices.
1359 *
1360 * RETURNS
1361 * Success: S_OK
1362 * Failure: Non-zero HRESULT value.
1363 */
1364 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
1365 int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
1366 {
1367 int cnt;
1368 HRESULT hr;
1369
1370 TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
1371 cChars, dwFlags, pwOutGlyphs);
1372
1373 if ((hr = get_script_cache(hdc, psc))) return hr;
1374
1375 TRACE("Before: ");
1376 for (cnt = 0; cnt < cChars; cnt++)
1377 TRACE("%4x",pwcInChars[cnt]);
1378 TRACE("\n");
1379
1380 GetGlyphIndicesW(get_cache_hdc(psc), pwcInChars, cChars, pwOutGlyphs, 0);
1381
1382 TRACE("After: ");
1383 for (cnt = 0; cnt < cChars; cnt++) {
1384 TRACE("%04x",pwOutGlyphs[cnt]);
1385 }
1386 TRACE("\n");
1387
1388 return S_OK;
1389 }
1390
1391 /***********************************************************************
1392 * ScriptTextOut (USP10.@)
1393 *
1394 */
1395 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
1396 const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
1397 int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
1398 const int *piJustify, const GOFFSET *pGoffset)
1399 {
1400 HRESULT hr;
1401
1402 TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
1403 hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
1404 piAdvance, piJustify, pGoffset);
1405
1406 if (!hdc && psc && !*psc) return E_INVALIDARG;
1407 if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
1408 if ((hr = get_script_cache(hdc, psc))) return hr;
1409
1410 fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
1411 if (!psa->fNoGlyphIndex) /* Have Glyphs? */
1412 fuOptions |= ETO_GLYPH_INDEX; /* Say don't do translation to glyph */
1413
1414 if (!ExtTextOutW(get_cache_hdc(psc), x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
1415 return S_FALSE;
1416
1417 return S_OK;
1418 }
1419
1420 /***********************************************************************
1421 * ScriptCacheGetHeight (USP10.@)
1422 *
1423 * Retrieve the height of the font in the cache.
1424 *
1425 * PARAMS
1426 * hdc [I] Device context.
1427 * psc [I/O] Opaque pointer to a script cache.
1428 * height [O] Receives font height.
1429 *
1430 * RETURNS
1431 * Success: S_OK
1432 * Failure: Non-zero HRESULT value.
1433 */
1434 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
1435 {
1436 HRESULT hr;
1437
1438 TRACE("(%p, %p, %p)\n", hdc, psc, height);
1439
1440 if (!height) return E_INVALIDARG;
1441 if ((hr = get_script_cache(hdc, psc))) return hr;
1442
1443 *height = get_cache_height(psc);
1444 return S_OK;
1445 }
1446
1447 /***********************************************************************
1448 * ScriptGetGlyphABCWidth (USP10.@)
1449 *
1450 * Retrieve the width of a glyph.
1451 *
1452 * PARAMS
1453 * hdc [I] Device context.
1454 * psc [I/O] Opaque pointer to a script cache.
1455 * glyph [I] Glyph to retrieve the width for.
1456 * abc [O] ABC widths of the glyph.
1457 *
1458 * RETURNS
1459 * Success: S_OK
1460 * Failure: Non-zero HRESULT value.
1461 */
1462 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
1463 {
1464 HRESULT hr;
1465
1466 TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
1467
1468 if ((hr = get_script_cache(hdc, psc))) return hr;
1469
1470 /* FIXME: get this from the cache */
1471 if (!GetCharABCWidthsW(get_cache_hdc(psc), glyph, glyph, abc)) return E_HANDLE;
1472 return S_OK;
1473 }
1474
1475 /***********************************************************************
1476 * ScriptLayout (USP10.@)
1477 *
1478 * Map embedding levels to visual and/or logical order.
1479 *
1480 * PARAMS
1481 * runs [I] Size of level array.
1482 * level [I] Array of embedding levels.
1483 * vistolog [O] Map of embedding levels from visual to logical order.
1484 * logtovis [O] Map of embedding levels from logical to visual order.
1485 *
1486 * RETURNS
1487 * Success: S_OK
1488 * Failure: Non-zero HRESULT value.
1489 *
1490 * BUGS
1491 * This stub works correctly for any sequence of a single
1492 * embedding level but not for sequences of different
1493 * embedding levels, i.e. mixtures of RTL and LTR scripts.
1494 */
1495 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
1496 {
1497 int i, j = runs - 1, k = 0;
1498
1499 TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
1500
1501 if (!level || (!vistolog && !logtovis))
1502 return E_INVALIDARG;
1503
1504 for (i = 0; i < runs; i++)
1505 {
1506 if (level[i] % 2)
1507 {
1508 if (vistolog) *vistolog++ = j;
1509 if (logtovis) *logtovis++ = j;
1510 j--;
1511 }
1512 else
1513 {
1514 if (vistolog) *vistolog++ = k;
1515 if (logtovis) *logtovis++ = k;
1516 k++;
1517 }
1518 }
1519 return S_OK;
1520 }
1521
1522 /***********************************************************************
1523 * ScriptStringGetLogicalWidths (USP10.@)
1524 *
1525 * Returns logical widths from a string analysis.
1526 *
1527 * PARAMS
1528 * ssa [I] string analysis.
1529 * piDx [O] logical widths returned.
1530 *
1531 * RETURNS
1532 * Success: S_OK
1533 * Failure: a non-zero HRESULT.
1534 */
1535 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
1536 {
1537 int i, j, next = 0;
1538 StringAnalysis *analysis = ssa;
1539
1540 TRACE("%p, %p\n", ssa, piDx);
1541
1542 if (!analysis) return S_FALSE;
1543
1544 for (i = 0; i < analysis->numItems; i++)
1545 {
1546 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
1547 {
1548 piDx[next] = analysis->glyphs[i].piAdvance[j];
1549 next++;
1550 }
1551 }
1552 return S_OK;
1553 }
1554
1555 /***********************************************************************
1556 * ScriptStringValidate (USP10.@)
1557 *
1558 * Validate a string analysis.
1559 *
1560 * PARAMS
1561 * ssa [I] string analysis.
1562 *
1563 * RETURNS
1564 * Success: S_OK
1565 * Failure: S_FALSE if invalid sequences are found
1566 * or a non-zero HRESULT if it fails.
1567 */
1568 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
1569 {
1570 StringAnalysis *analysis = ssa;
1571
1572 TRACE("(%p)\n", ssa);
1573
1574 if (!analysis) return E_INVALIDARG;
1575 return (analysis->invalid) ? S_FALSE : S_OK;
1576 }
1577
1578 /***********************************************************************
1579 * ScriptString_pSize (USP10.@)
1580 *
1581 * Retrieve width and height of an analysed string.
1582 *
1583 * PARAMS
1584 * ssa [I] string analysis.
1585 *
1586 * RETURNS
1587 * Success: Pointer to a SIZE structure.
1588 * Failure: NULL
1589 */
1590 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
1591 {
1592 unsigned int i, j;
1593 StringAnalysis *analysis = ssa;
1594
1595 TRACE("(%p)\n", ssa);
1596
1597 if (!analysis) return NULL;
1598
1599 if (!analysis->sz)
1600 {
1601 if (!(analysis->sz = usp_alloc(sizeof(SIZE)))) return NULL;
1602 analysis->sz->cy = analysis->sc->height;
1603
1604 analysis->sz->cx = 0;
1605 for (i = 0; i < analysis->numItems; i++)
1606 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
1607 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
1608 }
1609 return analysis->sz;
1610 }
1611
1612 /***********************************************************************
1613 * ScriptString_pLogAttr (USP10.@)
1614 *
1615 * Retrieve logical attributes of an analysed string.
1616 *
1617 * PARAMS
1618 * ssa [I] string analysis.
1619 *
1620 * RETURNS
1621 * Success: Pointer to an array of SCRIPT_LOGATTR structures.
1622 * Failure: NULL
1623 */
1624 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
1625 {
1626 StringAnalysis *analysis = ssa;
1627
1628 TRACE("(%p)\n", ssa);
1629
1630 if (!analysis) return NULL;
1631 return analysis->logattrs;
1632 }
1633
1634 /***********************************************************************
1635 * ScriptString_pcOutChars (USP10.@)
1636 *
1637 * Retrieve the length of a string after clipping.
1638 *
1639 * PARAMS
1640 * ssa [I] String analysis.
1641 *
1642 * RETURNS
1643 * Success: Pointer to the length.
1644 * Failure: NULL
1645 */
1646 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
1647 {
1648 StringAnalysis *analysis = ssa;
1649
1650 TRACE("(%p)\n", ssa);
1651
1652 if (!analysis) return NULL;
1653 return &analysis->clip_len;
1654 }
1655
1656 /***********************************************************************
1657 * ScriptStringGetOrder (USP10.@)
1658 *
1659 * Retrieve a glyph order map.
1660 *
1661 * PARAMS
1662 * ssa [I] String analysis.
1663 * order [I/O] Array of glyph positions.
1664 *
1665 * RETURNS
1666 * Success: S_OK
1667 * Failure: a non-zero HRESULT.
1668 */
1669 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
1670 {
1671 unsigned int i, j, k;
1672 StringAnalysis *analysis = ssa;
1673
1674 TRACE("(%p)\n", ssa);
1675
1676 if (!analysis) return S_FALSE;
1677
1678 /* FIXME: handle RTL scripts */
1679 for (i = 0, k = 0; i < analysis->numItems; i++)
1680 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
1681 order[k] = k;
1682
1683 return S_OK;
1684 }
A free Windows-compatible Operating System