?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Check more thoroughly if a stage references a texture.
[wine/hacks.git] / dlls / usp10 / usp10.c
blob3e1258dc2f1d6f5e2a9f84e2eb42476f187a72fa
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 if (pABC)
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 if (pABC)
1334 {
1335 pABC->abcA += lpABC[wcnt].abcA;
1336 pABC->abcB += lpABC[wcnt].abcB;
1337 pABC->abcC += lpABC[wcnt].abcC;
1338 }
1339 piAdvance[wcnt] = lpABC[wcnt].abcA + lpABC[wcnt].abcB + lpABC[wcnt].abcC;
1340 pGoffset[wcnt].du = 0;
1341 pGoffset[wcnt].dv = 0;
1342 }
1343 }
1344 if (pABC)
1345 TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
1346
1347 usp_free(lpABC);
1348 return S_OK;
1349 }
1350
1351 /***********************************************************************
1352 * ScriptGetCMap (USP10.@)
1353 *
1354 * Retrieve glyph indices.
1355 *
1356 * PARAMS
1357 * hdc [I] Device context.
1358 * psc [I/O] Opaque pointer to a script cache.
1359 * pwcInChars [I] Array of Unicode characters.
1360 * cChars [I] Number of characters in pwcInChars.
1361 * dwFlags [I] Flags.
1362 * pwOutGlyphs [O] Buffer to receive the array of glyph indices.
1363 *
1364 * RETURNS
1365 * Success: S_OK
1366 * Failure: Non-zero HRESULT value.
1367 */
1368 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
1369 int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
1370 {
1371 int cnt;
1372 HRESULT hr;
1373
1374 TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
1375 cChars, dwFlags, pwOutGlyphs);
1376
1377 if ((hr = get_script_cache(hdc, psc))) return hr;
1378
1379 TRACE("Before: ");
1380 for (cnt = 0; cnt < cChars; cnt++)
1381 TRACE("%4x",pwcInChars[cnt]);
1382 TRACE("\n");
1383
1384 GetGlyphIndicesW(get_cache_hdc(psc), pwcInChars, cChars, pwOutGlyphs, 0);
1385
1386 TRACE("After: ");
1387 for (cnt = 0; cnt < cChars; cnt++) {
1388 TRACE("%04x",pwOutGlyphs[cnt]);
1389 }
1390 TRACE("\n");
1391
1392 return S_OK;
1393 }
1394
1395 /***********************************************************************
1396 * ScriptTextOut (USP10.@)
1397 *
1398 */
1399 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
1400 const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
1401 int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
1402 const int *piJustify, const GOFFSET *pGoffset)
1403 {
1404 HRESULT hr;
1405
1406 TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
1407 hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
1408 piAdvance, piJustify, pGoffset);
1409
1410 if (!hdc && psc && !*psc) return E_INVALIDARG;
1411 if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
1412 if ((hr = get_script_cache(hdc, psc))) return hr;
1413
1414 fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
1415 if (!psa->fNoGlyphIndex) /* Have Glyphs? */
1416 fuOptions |= ETO_GLYPH_INDEX; /* Say don't do translation to glyph */
1417
1418 if (!ExtTextOutW(get_cache_hdc(psc), x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
1419 return S_FALSE;
1420
1421 return S_OK;
1422 }
1423
1424 /***********************************************************************
1425 * ScriptCacheGetHeight (USP10.@)
1426 *
1427 * Retrieve the height of the font in the cache.
1428 *
1429 * PARAMS
1430 * hdc [I] Device context.
1431 * psc [I/O] Opaque pointer to a script cache.
1432 * height [O] Receives font height.
1433 *
1434 * RETURNS
1435 * Success: S_OK
1436 * Failure: Non-zero HRESULT value.
1437 */
1438 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
1439 {
1440 HRESULT hr;
1441
1442 TRACE("(%p, %p, %p)\n", hdc, psc, height);
1443
1444 if (!height) return E_INVALIDARG;
1445 if ((hr = get_script_cache(hdc, psc))) return hr;
1446
1447 *height = get_cache_height(psc);
1448 return S_OK;
1449 }
1450
1451 /***********************************************************************
1452 * ScriptGetGlyphABCWidth (USP10.@)
1453 *
1454 * Retrieve the width of a glyph.
1455 *
1456 * PARAMS
1457 * hdc [I] Device context.
1458 * psc [I/O] Opaque pointer to a script cache.
1459 * glyph [I] Glyph to retrieve the width for.
1460 * abc [O] ABC widths of the glyph.
1461 *
1462 * RETURNS
1463 * Success: S_OK
1464 * Failure: Non-zero HRESULT value.
1465 */
1466 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
1467 {
1468 HRESULT hr;
1469
1470 TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
1471
1472 if ((hr = get_script_cache(hdc, psc))) return hr;
1473
1474 /* FIXME: get this from the cache */
1475 if (!GetCharABCWidthsW(get_cache_hdc(psc), glyph, glyph, abc)) return E_HANDLE;
1476 return S_OK;
1477 }
1478
1479 /***********************************************************************
1480 * ScriptLayout (USP10.@)
1481 *
1482 * Map embedding levels to visual and/or logical order.
1483 *
1484 * PARAMS
1485 * runs [I] Size of level array.
1486 * level [I] Array of embedding levels.
1487 * vistolog [O] Map of embedding levels from visual to logical order.
1488 * logtovis [O] Map of embedding levels from logical to visual order.
1489 *
1490 * RETURNS
1491 * Success: S_OK
1492 * Failure: Non-zero HRESULT value.
1493 *
1494 * BUGS
1495 * This stub works correctly for any sequence of a single
1496 * embedding level but not for sequences of different
1497 * embedding levels, i.e. mixtures of RTL and LTR scripts.
1498 */
1499 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
1500 {
1501 int i, j = runs - 1, k = 0;
1502
1503 TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
1504
1505 if (!level || (!vistolog && !logtovis))
1506 return E_INVALIDARG;
1507
1508 for (i = 0; i < runs; i++)
1509 {
1510 if (level[i] % 2)
1511 {
1512 if (vistolog) *vistolog++ = j;
1513 if (logtovis) *logtovis++ = j;
1514 j--;
1515 }
1516 else
1517 {
1518 if (vistolog) *vistolog++ = k;
1519 if (logtovis) *logtovis++ = k;
1520 k++;
1521 }
1522 }
1523 return S_OK;
1524 }
1525
1526 /***********************************************************************
1527 * ScriptStringGetLogicalWidths (USP10.@)
1528 *
1529 * Returns logical widths from a string analysis.
1530 *
1531 * PARAMS
1532 * ssa [I] string analysis.
1533 * piDx [O] logical widths returned.
1534 *
1535 * RETURNS
1536 * Success: S_OK
1537 * Failure: a non-zero HRESULT.
1538 */
1539 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
1540 {
1541 int i, j, next = 0;
1542 StringAnalysis *analysis = ssa;
1543
1544 TRACE("%p, %p\n", ssa, piDx);
1545
1546 if (!analysis) return S_FALSE;
1547
1548 for (i = 0; i < analysis->numItems; i++)
1549 {
1550 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
1551 {
1552 piDx[next] = analysis->glyphs[i].piAdvance[j];
1553 next++;
1554 }
1555 }
1556 return S_OK;
1557 }
1558
1559 /***********************************************************************
1560 * ScriptStringValidate (USP10.@)
1561 *
1562 * Validate a string analysis.
1563 *
1564 * PARAMS
1565 * ssa [I] string analysis.
1566 *
1567 * RETURNS
1568 * Success: S_OK
1569 * Failure: S_FALSE if invalid sequences are found
1570 * or a non-zero HRESULT if it fails.
1571 */
1572 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
1573 {
1574 StringAnalysis *analysis = ssa;
1575
1576 TRACE("(%p)\n", ssa);
1577
1578 if (!analysis) return E_INVALIDARG;
1579 return (analysis->invalid) ? S_FALSE : S_OK;
1580 }
1581
1582 /***********************************************************************
1583 * ScriptString_pSize (USP10.@)
1584 *
1585 * Retrieve width and height of an analysed string.
1586 *
1587 * PARAMS
1588 * ssa [I] string analysis.
1589 *
1590 * RETURNS
1591 * Success: Pointer to a SIZE structure.
1592 * Failure: NULL
1593 */
1594 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
1595 {
1596 unsigned int i, j;
1597 StringAnalysis *analysis = ssa;
1598
1599 TRACE("(%p)\n", ssa);
1600
1601 if (!analysis) return NULL;
1602
1603 if (!analysis->sz)
1604 {
1605 if (!(analysis->sz = usp_alloc(sizeof(SIZE)))) return NULL;
1606 analysis->sz->cy = analysis->sc->height;
1607
1608 analysis->sz->cx = 0;
1609 for (i = 0; i < analysis->numItems; i++)
1610 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
1611 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
1612 }
1613 return analysis->sz;
1614 }
1615
1616 /***********************************************************************
1617 * ScriptString_pLogAttr (USP10.@)
1618 *
1619 * Retrieve logical attributes of an analysed string.
1620 *
1621 * PARAMS
1622 * ssa [I] string analysis.
1623 *
1624 * RETURNS
1625 * Success: Pointer to an array of SCRIPT_LOGATTR structures.
1626 * Failure: NULL
1627 */
1628 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
1629 {
1630 StringAnalysis *analysis = ssa;
1631
1632 TRACE("(%p)\n", ssa);
1633
1634 if (!analysis) return NULL;
1635 return analysis->logattrs;
1636 }
1637
1638 /***********************************************************************
1639 * ScriptString_pcOutChars (USP10.@)
1640 *
1641 * Retrieve the length of a string after clipping.
1642 *
1643 * PARAMS
1644 * ssa [I] String analysis.
1645 *
1646 * RETURNS
1647 * Success: Pointer to the length.
1648 * Failure: NULL
1649 */
1650 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
1651 {
1652 StringAnalysis *analysis = ssa;
1653
1654 TRACE("(%p)\n", ssa);
1655
1656 if (!analysis) return NULL;
1657 return &analysis->clip_len;
1658 }
1659
1660 /***********************************************************************
1661 * ScriptStringGetOrder (USP10.@)
1662 *
1663 * Retrieve a glyph order map.
1664 *
1665 * PARAMS
1666 * ssa [I] String analysis.
1667 * order [I/O] Array of glyph positions.
1668 *
1669 * RETURNS
1670 * Success: S_OK
1671 * Failure: a non-zero HRESULT.
1672 */
1673 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
1674 {
1675 unsigned int i, j, k;
1676 StringAnalysis *analysis = ssa;
1677
1678 TRACE("(%p)\n", ssa);
1679
1680 if (!analysis) return S_FALSE;
1681
1682 /* FIXME: handle RTL scripts */
1683 for (i = 0, k = 0; i < analysis->numItems; i++)
1684 for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
1685 order[k] = k;
1686
1687 return S_OK;
1688 }
1689
1690 /***********************************************************************
1691 * ScriptGetLogicalWidths (USP10.@)
1692 *
1693 * Convert advance widths to logical widths.
1694 *
1695 * PARAMS
1696 * sa [I] Script analysis.
1697 * nbchars [I] Number of characters.
1698 * nbglyphs [I] Number of glyphs.
1699 * glyph_width [I] Array of glyph widths.
1700 * log_clust [I] Array of logical clusters.
1701 * sva [I] Visual attributes.
1702 * widths [O] Array of logical widths.
1703 *
1704 * RETURNS
1705 * Success: S_OK
1706 * Failure: a non-zero HRESULT.
1707 */
1708 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
1709 const int *glyph_width, const WORD *log_clust,
1710 const SCRIPT_VISATTR *sva, int *widths)
1711 {
1712 int i;
1713
1714 TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
1715 sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
1716
1717 /* FIXME */
1718 for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
1719 return S_OK;
1720 }
useful hacks and other patches not (yet) suitable for mainline