gdiplus: Add test for ImageLockModeUserInputBuf.
[wine] / dlls / 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  * Copyright 2010 CodeWeavers, Aric Stewart
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  *
22  * Notes:
23  * Uniscribe allows for processing of complex scripts such as joining
24  * and filtering characters and bi-directional text with custom line breaks.
25  */
26
27 #include <stdarg.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "winnls.h"
34 #include "usp10.h"
35
36 #include "usp10_internal.h"
37
38 #include "wine/debug.h"
39 #include "wine/unicode.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
42
43 typedef struct _scriptRange
44 {
45     WORD script;
46     WORD rangeFirst;
47     WORD rangeLast;
48     WORD numericScript;
49     WORD punctScript;
50 } scriptRange;
51
52 static const scriptRange scriptRanges[] = {
53     /* Basic Latin: U+0000–U+007A */
54     /* Latin-1 Supplement: U+0080–U+00FF */
55     /* Latin Extended-A: U+0100–U+017F */
56     /* Latin Extended-B: U+0180–U+024F */
57     /* IPA Extensions: U+0250–U+02AF */
58     { Script_Latin,      0x00,   0x2af ,  Script_Numeric, Script_Punctuation},
59     /* Greek: U+0370–U+03FF */
60     { Script_Greek,      0x370,  0x3ff,  0, 0},
61     /* Cyrillic: U+0400–U+04FF */
62     /* Cyrillic Supplement: U+0500–U+052F */
63     { Script_Cyrillic,   0x400,  0x52f,  0, 0},
64     /* Armenian: U+0530–U+058F */
65     { Script_Armenian,   0x530,  0x58f,  0, 0},
66     /* Hebrew: U+0590–U+05FF */
67     { Script_Hebrew,     0x590,  0x5ff,  0, 0},
68     /* Arabic: U+0600–U+06FF */
69     { Script_Arabic,     0x600,  0x6ef,  Script_Arabic_Numeric, 0},
70     /* Defined by Windows */
71     { Script_Persian,    0x6f0,  0x6f9,  0, 0},
72     /* Continue Arabic: U+0600–U+06FF */
73     { Script_Arabic,     0x6fa,  0x6ff,  0, 0},
74     /* Syriac: U+0700–U+074F*/
75     { Script_Syriac,     0x700,  0x74f,  0, 0},
76     /* Arabic Supplement: U+0750–U+077F */
77     { Script_Arabic,     0x750,  0x77f,  0, 0},
78     /* Thaana: U+0780–U+07BF */
79     { Script_Thaana,     0x780,  0x7bf,  0, 0},
80     /* Sinhala: U+0D80–U+0DFF */
81     { Script_Sinhala,   0xd80,  0xdff,  0, 0},
82     /* Thai: U+0E00–U+0E7F */
83     { Script_Thai,      0xe00,  0xe7f,  Script_Thai_Numeric, 0},
84     /* Lao: U+0E80–U+0EFF */
85     { Script_Lao,       0xe80,  0xeff,  Script_Lao_Numeric, 0},
86     /* Tibetan: U+0F00–U+0FFF */
87     { Script_Tibetan,   0xf00,  0xfff,  Script_Tibetan_Numeric, 0},
88     /* Georgian: U+10A0–U+10FF */
89     { Script_Georgian,   0x10a0,  0x10ff,  0, 0},
90     /* Phonetic Extensions: U+1D00–U+1DBF */
91     { Script_Latin,      0x1d00, 0x1dbf, 0, 0},
92     /* Latin Extended Additional: U+1E00–U+1EFF */
93     { Script_Latin,      0x1e00, 0x1eff, 0, 0},
94     /* Greek Extended: U+1F00–U+1FFF */
95     { Script_Greek,      0x1f00, 0x1fff, 0, 0},
96     /* Latin Extended-C: U+2C60–U+2C7F */
97     { Script_Latin,      0x2c60, 0x2c7f, 0, 0},
98     /* Georgian: U+2D00–U+2D2F */
99     { Script_Georgian,   0x2d00,  0x2d2f,  0, 0},
100     /* Cyrillic Extended-A: U+2DE0–U+2DFF */
101     { Script_Cyrillic,   0x2de0, 0x2dff,  0, 0},
102     /* Cyrillic Extended-B: U+A640–U+A69F */
103     { Script_Cyrillic,   0xa640, 0xa69f,  0, 0},
104     /* Modifier Tone Letters: U+A700–U+A71F */
105     /* Latin Extended-D: U+A720–U+A7FF */
106     { Script_Latin,      0xa700, 0xa7ff, 0, 0},
107     /* Phags-pa: U+A840–U+A87F */
108     { Script_Phags_pa,   0xa840, 0xa87f, 0, 0},
109     /* Latin Ligatures: U+FB00–U+FB06 */
110     { Script_Latin,      0xfb00, 0xfb06, 0, 0},
111     /* Armenian ligatures U+FB13..U+FB17 */
112     { Script_Armenian,   0xfb13, 0xfb17,  0, 0},
113     /* Alphabetic Presentation Forms: U+FB1D–U+FB4F */
114     { Script_Hebrew,     0xfb1d, 0xfb4f, 0, 0},
115     /* Arabic Presentation Forms-A: U+FB50–U+FDFF*/
116     { Script_Arabic,     0xfb50, 0xfdff, 0, 0},
117     /* Arabic Presentation Forms-B: U+FE70–U+FEFF*/
118     { Script_Arabic,     0xfe70, 0xfeff, 0, 0},
119     /* END */
120     { SCRIPT_UNDEFINED,  0, 0, 0}
121 };
122
123 typedef struct _scriptData
124 {
125     SCRIPT_ANALYSIS a;
126     SCRIPT_PROPERTIES props;
127 } scriptData;
128
129 /* the must be in order so that the index matches the Script value */
130 static const scriptData scriptInformation[] = {
131     {{SCRIPT_UNDEFINED, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
132      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
133     {{Script_Latin, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
134      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
135     {{Script_CR, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
136      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
137     {{Script_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
138      {LANG_ENGLISH, 1, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
139     {{Script_Control, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
140      {LANG_ENGLISH, 0, 1, 0, 0, ANSI_CHARSET, 1, 0, 0, 0, 0, 0, 1, 0, 0}},
141     {{Script_Punctuation, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
142      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
143     {{Script_Arabic, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
144      {LANG_ARABIC, 0, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 1, 0}},
145     {{Script_Arabic_Numeric, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
146      {LANG_ARABIC, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
147     {{Script_Hebrew, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
148      {LANG_HEBREW, 0, 1, 0, 1, HEBREW_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
149     {{Script_Syriac, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
150      {LANG_SYRIAC, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 1, 0}},
151     {{Script_Persian, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
152      {LANG_PERSIAN, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
153     {{Script_Thaana, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
154      {LANG_DIVEHI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
155     {{Script_Greek, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
156      {LANG_GREEK, 0, 0, 0, 0, GREEK_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
157     {{Script_Cyrillic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
158      {LANG_RUSSIAN, 0, 0, 0, 0, RUSSIAN_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
159     {{Script_Armenian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
160      {LANG_ARMENIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
161     {{Script_Georgian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
162      {LANG_GEORGIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
163     {{Script_Sinhala, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
164      {LANG_SINHALESE, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
165     {{Script_Tibetan, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
166      {LANG_TIBETAN, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0}},
167     {{Script_Tibetan_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
168      {LANG_TIBETAN, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
169     {{Script_Phags_pa, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
170      {LANG_MONGOLIAN, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
171     {{Script_Thai, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
172      {LANG_THAI, 0, 1, 1, 1, THAI_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 1}},
173     {{Script_Thai_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
174      {LANG_THAI, 1, 1, 0, 0, THAI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
175     {{Script_Lao, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
176      {LANG_LAO, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0}},
177     {{Script_Lao_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
178      {LANG_LAO, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
179 };
180
181 static const SCRIPT_PROPERTIES *script_props[] =
182 {
183     &scriptInformation[0].props, &scriptInformation[1].props,
184     &scriptInformation[2].props, &scriptInformation[3].props,
185     &scriptInformation[4].props, &scriptInformation[5].props,
186     &scriptInformation[6].props, &scriptInformation[7].props,
187     &scriptInformation[8].props, &scriptInformation[9].props,
188     &scriptInformation[10].props, &scriptInformation[11].props,
189     &scriptInformation[12].props, &scriptInformation[13].props,
190     &scriptInformation[14].props, &scriptInformation[15].props,
191     &scriptInformation[16].props, &scriptInformation[17].props,
192     &scriptInformation[18].props, &scriptInformation[19].props,
193     &scriptInformation[20].props, &scriptInformation[21].props,
194     &scriptInformation[22].props, &scriptInformation[23].props
195 };
196
197 typedef struct {
198     int numGlyphs;
199     WORD* glyphs;
200     WORD* pwLogClust;
201     int* piAdvance;
202     SCRIPT_VISATTR* psva;
203     GOFFSET* pGoffset;
204     ABC* abc;
205 } StringGlyphs;
206
207 typedef struct {
208     HDC hdc;
209     BOOL invalid;
210     int clip_len;
211     ScriptCache *sc;
212     int cItems;
213     int cMaxGlyphs;
214     SCRIPT_ITEM* pItem;
215     int numItems;
216     StringGlyphs* glyphs;
217     SCRIPT_LOGATTR* logattrs;
218     SIZE* sz;
219 } StringAnalysis;
220
221 static inline void *heap_alloc(SIZE_T size)
222 {
223     return HeapAlloc(GetProcessHeap(), 0, size);
224 }
225
226 static inline void *heap_alloc_zero(SIZE_T size)
227 {
228     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
229 }
230
231 static inline void *heap_realloc_zero(LPVOID mem, SIZE_T size)
232 {
233     return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
234 }
235
236 static inline BOOL heap_free(LPVOID mem)
237 {
238     return HeapFree(GetProcessHeap(), 0, mem);
239 }
240
241 static inline WCHAR get_cache_default_char(SCRIPT_CACHE *psc)
242 {
243     return ((ScriptCache *)*psc)->tm.tmDefaultChar;
244 }
245
246 static inline LONG get_cache_height(SCRIPT_CACHE *psc)
247 {
248     return ((ScriptCache *)*psc)->tm.tmHeight;
249 }
250
251 static inline BYTE get_cache_pitch_family(SCRIPT_CACHE *psc)
252 {
253     return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
254 }
255
256 static inline WORD get_cache_glyph(SCRIPT_CACHE *psc, WCHAR c)
257 {
258     WORD *block = ((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
259
260     if (!block) return 0;
261     return block[c & GLYPH_BLOCK_MASK];
262 }
263
264 static inline WORD set_cache_glyph(SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
265 {
266     WORD **block = &((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
267
268     if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
269     return ((*block)[c & GLYPH_BLOCK_MASK] = glyph);
270 }
271
272 static inline BOOL get_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
273 {
274     static const ABC nil;
275     ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
276
277     if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
278     memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
279     return TRUE;
280 }
281
282 static inline BOOL set_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
283 {
284     ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
285
286     if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
287     memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
288     return TRUE;
289 }
290
291 static HRESULT init_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
292 {
293     ScriptCache *sc;
294
295     if (!psc) return E_INVALIDARG;
296     if (*psc) return S_OK;
297     if (!hdc) return E_PENDING;
298
299     if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
300     if (!GetTextMetricsW(hdc, &sc->tm))
301     {
302         heap_free(sc);
303         return E_INVALIDARG;
304     }
305     if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(LOGFONTW), &sc->lf))
306     {
307         heap_free(sc);
308         return E_INVALIDARG;
309     }
310     *psc = sc;
311     TRACE("<- %p\n", sc);
312     return S_OK;
313 }
314
315 static WCHAR mirror_char( WCHAR ch )
316 {
317     extern const WCHAR wine_mirror_map[];
318     return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
319 }
320
321 static WORD get_char_script( WCHAR ch)
322 {
323     WORD type = 0;
324     int i;
325
326     if (ch == 0xc || ch == 0x20 || ch == 0x202f)
327         return Script_CR;
328
329     GetStringTypeW(CT_CTYPE1, &ch, 1, &type);
330
331     if (type == 0)
332         return SCRIPT_UNDEFINED;
333
334     if (type & C1_CNTRL)
335         return Script_Control;
336
337     i = 0;
338     do
339     {
340         if (ch < scriptRanges[i].rangeFirst || scriptRanges[i].script == SCRIPT_UNDEFINED)
341             break;
342
343         if (ch >= scriptRanges[i].rangeFirst && ch <= scriptRanges[i].rangeLast)
344         {
345             if (scriptRanges[i].numericScript && type & C1_DIGIT)
346                 return scriptRanges[i].numericScript;
347             if (scriptRanges[i].punctScript && type & C1_PUNCT)
348                 return scriptRanges[i].punctScript;
349             return scriptRanges[i].script;
350         }
351         i++;
352     } while (1);
353
354     return SCRIPT_UNDEFINED;
355 }
356
357 /***********************************************************************
358  *      DllMain
359  *
360  */
361 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
362 {
363     switch(fdwReason)
364     {
365     case DLL_PROCESS_ATTACH:
366         DisableThreadLibraryCalls(hInstDLL);
367         break;
368     case DLL_PROCESS_DETACH:
369         break;
370     }
371     return TRUE;
372 }
373
374 /***********************************************************************
375  *      ScriptFreeCache (USP10.@)
376  *
377  * Free a script cache.
378  *
379  * PARAMS
380  *   psc [I/O] Script cache.
381  *
382  * RETURNS
383  *  Success: S_OK
384  *  Failure: Non-zero HRESULT value.
385  */
386 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
387 {
388     TRACE("%p\n", psc);
389
390     if (psc && *psc)
391     {
392         unsigned int i;
393         for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
394         {
395             heap_free(((ScriptCache *)*psc)->glyphs[i]);
396             heap_free(((ScriptCache *)*psc)->widths[i]);
397         }
398         heap_free(((ScriptCache *)*psc)->GSUB_Table);
399         heap_free(((ScriptCache *)*psc)->features);
400         heap_free(*psc);
401         *psc = NULL;
402     }
403     return S_OK;
404 }
405
406 /***********************************************************************
407  *      ScriptGetProperties (USP10.@)
408  *
409  * Retrieve a list of script properties.
410  *
411  * PARAMS
412  *  props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
413  *  num   [I] Pointer to the number of scripts.
414  *
415  * RETURNS
416  *  Success: S_OK
417  *  Failure: Non-zero HRESULT value.
418  *
419  * NOTES
420  *  Behaviour matches WinXP.
421  */
422 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
423 {
424     TRACE("(%p,%p)\n", props, num);
425
426     if (!props && !num) return E_INVALIDARG;
427
428     if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
429     if (props) *props = script_props;
430
431     return S_OK;
432 }
433
434 /***********************************************************************
435  *      ScriptGetFontProperties (USP10.@)
436  *
437  * Get information on special glyphs.
438  *
439  * PARAMS
440  *  hdc [I]   Device context.
441  *  psc [I/O] Opaque pointer to a script cache.
442  *  sfp [O]   Font properties structure.
443  */
444 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
445 {
446     HRESULT hr;
447
448     TRACE("%p,%p,%p\n", hdc, psc, sfp);
449
450     if (!sfp) return E_INVALIDARG;
451     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
452
453     if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
454         return E_INVALIDARG;
455
456     /* return something sensible? */
457     sfp->wgBlank = 0;
458     sfp->wgDefault = get_cache_default_char(psc);
459     sfp->wgInvalid = 0;
460     sfp->wgKashida = 0xffff;
461     sfp->iKashidaWidth = 0;
462
463     return S_OK;
464 }
465
466 /***********************************************************************
467  *      ScriptRecordDigitSubstitution (USP10.@)
468  *
469  *  Record digit substitution settings for a given locale.
470  *
471  *  PARAMS
472  *   locale [I] Locale identifier.
473  *   sds    [I] Structure to record substitution settings.
474  *
475  *  RETURNS
476  *   Success: S_OK
477  *   Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
478  *
479  *  SEE ALSO
480  *   http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
481  */
482 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
483 {
484     DWORD plgid, sub;
485
486     TRACE("0x%x, %p\n", locale, sds);
487
488     /* This implementation appears to be correct for all languages, but it's
489      * not clear if sds->DigitSubstitute is ever set to anything except 
490      * CONTEXT or NONE in reality */
491
492     if (!sds) return E_POINTER;
493
494     locale = ConvertDefaultLocale(locale);
495
496     if (!IsValidLocale(locale, LCID_INSTALLED))
497         return E_INVALIDARG;
498
499     plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
500     sds->TraditionalDigitLanguage = plgid;
501
502     if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
503         sds->NationalDigitLanguage = plgid;
504     else
505         sds->NationalDigitLanguage = LANG_ENGLISH;
506
507     if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
508                         (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
509
510     switch (sub)
511     {
512     case 0: 
513         if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
514             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
515         else
516             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
517         break;
518     case 1:
519         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
520         break;
521     case 2:
522         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
523         break;
524     default:
525         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
526         break;
527     }
528
529     sds->dwReserved = 0;
530     return S_OK;
531 }
532
533 /***********************************************************************
534  *      ScriptApplyDigitSubstitution (USP10.@)
535  *
536  *  Apply digit substitution settings.
537  *
538  *  PARAMS
539  *   sds [I] Structure with recorded substitution settings.
540  *   sc  [I] Script control structure.
541  *   ss  [I] Script state structure.
542  *
543  *  RETURNS
544  *   Success: S_OK
545  *   Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
546  */
547 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds, 
548                                             SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
549 {
550     SCRIPT_DIGITSUBSTITUTE psds;
551
552     TRACE("%p, %p, %p\n", sds, sc, ss);
553
554     if (!sc || !ss) return E_POINTER;
555     if (!sds)
556     {
557         sds = &psds;
558         if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
559             return E_INVALIDARG;
560     }
561
562     sc->uDefaultLanguage = LANG_ENGLISH;
563     sc->fContextDigits = 0;
564     ss->fDigitSubstitute = 0;
565
566     switch (sds->DigitSubstitute) {
567         case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
568         case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
569         case SCRIPT_DIGITSUBSTITUTE_NONE:
570         case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
571             return S_OK;
572         default:
573             return E_INVALIDARG;
574     }
575 }
576
577 /***********************************************************************
578  *      ScriptItemize (USP10.@)
579  *
580  * Split a Unicode string into shapeable parts.
581  *
582  * PARAMS
583  *  pwcInChars [I] String to split.
584  *  cInChars   [I] Number of characters in pwcInChars.
585  *  cMaxItems  [I] Maximum number of items to return.
586  *  psControl  [I] Pointer to a SCRIPT_CONTROL structure.
587  *  psState    [I] Pointer to a SCRIPT_STATE structure.
588  *  pItems     [O] Buffer to receive SCRIPT_ITEM structures.
589  *  pcItems    [O] Number of script items returned.
590  *
591  * RETURNS
592  *  Success: S_OK
593  *  Failure: Non-zero HRESULT value.
594  */
595 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
596                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
597                              SCRIPT_ITEM *pItems, int *pcItems)
598 {
599
600 #define Numeric_space 0x0020
601
602     int   cnt = 0, index = 0, str = 0;
603     int   New_Script = SCRIPT_UNDEFINED;
604     WORD  *levels = NULL;
605     WORD  *strength = NULL;
606     WORD  baselevel = 0;
607
608     TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems, 
609           psControl, psState, pItems, pcItems);
610
611     if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
612         return E_INVALIDARG;
613
614     if (psState && psControl)
615     {
616         int i;
617         levels = heap_alloc_zero(cInChars * sizeof(WORD));
618         if (!levels)
619             return E_OUTOFMEMORY;
620
621         BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels);
622         baselevel = levels[0];
623         for (i = 0; i < cInChars; i++)
624             if (levels[i]!=levels[0])
625                 break;
626         if (i >= cInChars && !odd(baselevel))
627         {
628             heap_free(levels);
629             levels = NULL;
630         }
631         else
632         {
633             if (!psControl->fMergeNeutralItems)
634             {
635                 strength = heap_alloc_zero(cInChars * sizeof(WORD));
636                 BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
637             }
638         }
639     }
640
641     while (pwcInChars[cnt] == Numeric_space && cnt < cInChars)
642         cnt++;
643
644     if (cnt == cInChars) /* All Spaces */
645     {
646         cnt = 0;
647         New_Script = get_char_script(pwcInChars[cnt]);
648     }
649
650     pItems[index].iCharPos = 0;
651     pItems[index].a = scriptInformation[get_char_script(pwcInChars[cnt])].a;
652
653     if (strength)
654         str = strength[cnt];
655
656     cnt = 0;
657     if (levels)
658     {
659         pItems[index].a.fRTL = odd(levels[cnt]);
660         pItems[index].a.fLayoutRTL = odd(levels[cnt]);
661         pItems[index].a.s.uBidiLevel = levels[cnt];
662     }
663     else if (!pItems[index].a.s.uBidiLevel)
664     {
665         pItems[index].a.s.uBidiLevel = baselevel;
666         pItems[index].a.fLayoutRTL = odd(baselevel);
667         pItems[index].a.fRTL = odd(baselevel);
668     }
669
670     TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
671           levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
672           pItems[index].iCharPos);
673
674     for (cnt=1; cnt < cInChars; cnt++)
675     {
676         if (levels && (levels[cnt] == pItems[index].a.s.uBidiLevel && (!strength || (strength[cnt] == 0 || strength[cnt] == str))))
677             continue;
678
679         if(pwcInChars[cnt] != Numeric_space)
680             New_Script = get_char_script(pwcInChars[cnt]);
681         else if (levels)
682         {
683             int j = 1;
684             while (cnt + j < cInChars - 1 && pwcInChars[cnt+j] == Numeric_space)
685                 j++;
686             New_Script = get_char_script(pwcInChars[cnt+j]);
687         }
688
689         if ((levels && (levels[cnt] != pItems[index].a.s.uBidiLevel || (strength && (strength[cnt] != str)))) || New_Script != pItems[index].a.eScript || New_Script == Script_Control)
690         {
691             TRACE("New_Level = %i, New_Strength = %i, New_Script=%d, eScript=%d\n", levels?levels[cnt]:-1, strength?strength[cnt]:str, New_Script, pItems[index].a.eScript);
692
693             if (strength && strength[cnt] != 0)
694                 str = strength[cnt];
695
696             index++;
697             if  (index+1 > cMaxItems)
698                 return E_OUTOFMEMORY;
699
700             pItems[index].iCharPos = cnt;
701             memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
702
703             pItems[index].a = scriptInformation[New_Script].a;
704             if (levels)
705             {
706                 pItems[index].a.fRTL = odd(levels[cnt]);
707                 pItems[index].a.fLayoutRTL = odd(levels[cnt]);
708                 pItems[index].a.s.uBidiLevel = levels[cnt];
709             }
710             else if (!pItems[index].a.s.uBidiLevel)
711             {
712                 pItems[index].a.s.uBidiLevel = baselevel;
713                 pItems[index].a.fLayoutRTL = odd(baselevel);
714                 pItems[index].a.fRTL = odd(baselevel);
715             }
716
717             TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
718         }
719     }
720
721     /* While not strictly necessary according to the spec, make sure the n+1
722      * item is set up to prevent random behaviour if the caller erroneously
723      * checks the n+1 structure                                              */
724     index++;
725     memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
726
727     TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
728
729     /*  Set one SCRIPT_STATE item being returned  */
730     if  (index + 1 > cMaxItems) return E_OUTOFMEMORY;
731     if (pcItems) *pcItems = index;
732
733     /*  Set SCRIPT_ITEM                                     */
734     pItems[index].iCharPos = cnt;         /* the last item contains the ptr to the lastchar */
735     heap_free(levels);
736     heap_free(strength);
737     return S_OK;
738 }
739
740 /***********************************************************************
741  *      ScriptStringAnalyse (USP10.@)
742  *
743  */
744 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
745                                    int cGlyphs, int iCharset, DWORD dwFlags,
746                                    int iReqWidth, SCRIPT_CONTROL *psControl,
747                                    SCRIPT_STATE *psState, const int *piDx,
748                                    SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
749                                    SCRIPT_STRING_ANALYSIS *pssa)
750 {
751     HRESULT hr = E_OUTOFMEMORY;
752     StringAnalysis *analysis = NULL;
753     int i, num_items = 255;
754
755     TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
756           hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
757           psControl, psState, piDx, pTabdef, pbInClass, pssa);
758
759     if (iCharset != -1)
760     {
761         FIXME("Only Unicode strings are supported\n");
762         return E_INVALIDARG;
763     }
764     if (cString < 1 || !pString) return E_INVALIDARG;
765     if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
766
767     if (!(analysis = heap_alloc_zero(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
768     if (!(analysis->pItem = heap_alloc_zero(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
769
770     /* FIXME: handle clipping */
771     analysis->clip_len = cString;
772     analysis->hdc = hdc;
773
774     hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
775                        &analysis->numItems);
776
777     while (hr == E_OUTOFMEMORY)
778     {
779         SCRIPT_ITEM *tmp;
780
781         num_items *= 2;
782         if (!(tmp = heap_realloc_zero(analysis->pItem, num_items * sizeof(SCRIPT_ITEM) + 1)))
783             goto error;
784
785         analysis->pItem = tmp;
786         hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
787                            &analysis->numItems);
788     }
789     if (hr != S_OK) goto error;
790
791     if ((analysis->logattrs = heap_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
792         ScriptBreak(pString, cString, (SCRIPT_STRING_ANALYSIS)analysis, analysis->logattrs);
793     else
794         goto error;
795
796     if (!(analysis->glyphs = heap_alloc_zero(sizeof(StringGlyphs) * analysis->numItems)))
797         goto error;
798
799     for (i = 0; i < analysis->numItems; i++)
800     {
801         SCRIPT_CACHE *sc = (SCRIPT_CACHE *)&analysis->sc;
802         int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
803         int numGlyphs = 1.5 * cChar + 16;
804         WORD *glyphs = heap_alloc_zero(sizeof(WORD) * numGlyphs);
805         WORD *pwLogClust = heap_alloc_zero(sizeof(WORD) * cChar);
806         int *piAdvance = heap_alloc_zero(sizeof(int) * numGlyphs);
807         SCRIPT_VISATTR *psva = heap_alloc_zero(sizeof(SCRIPT_VISATTR) * cChar);
808         GOFFSET *pGoffset = heap_alloc_zero(sizeof(GOFFSET) * numGlyphs);
809         ABC *abc = heap_alloc_zero(sizeof(ABC));
810         int numGlyphsReturned;
811
812         /* FIXME: non unicode strings */
813         const WCHAR* pStr = (const WCHAR*)pString;
814         hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
815                          cChar, numGlyphs, &analysis->pItem[i].a,
816                          glyphs, pwLogClust, psva, &numGlyphsReturned);
817         hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
818                          piAdvance, pGoffset, abc);
819
820         analysis->glyphs[i].numGlyphs = numGlyphsReturned;
821         analysis->glyphs[i].glyphs = glyphs;
822         analysis->glyphs[i].pwLogClust = pwLogClust;
823         analysis->glyphs[i].piAdvance = piAdvance;
824         analysis->glyphs[i].psva = psva;
825         analysis->glyphs[i].pGoffset = pGoffset;
826         analysis->glyphs[i].abc = abc;
827     }
828
829     *pssa = analysis;
830     return S_OK;
831
832 error:
833     heap_free(analysis->glyphs);
834     heap_free(analysis->logattrs);
835     heap_free(analysis->pItem);
836     heap_free(analysis->sc);
837     heap_free(analysis);
838     return hr;
839 }
840
841 /***********************************************************************
842  *      ScriptStringOut (USP10.@)
843  *
844  * This function takes the output of ScriptStringAnalyse and joins the segments
845  * of glyphs and passes the resulting string to ScriptTextOut.  ScriptStringOut
846  * only processes glyphs.
847  *
848  * Parameters:
849  *  ssa       [I] buffer to hold the analysed string components
850  *  iX        [I] X axis displacement for output
851  *  iY        [I] Y axis displacement for output
852  *  uOptions  [I] flags controling output processing
853  *  prc       [I] rectangle coordinates
854  *  iMinSel   [I] starting pos for substringing output string
855  *  iMaxSel   [I] ending pos for substringing output string
856  *  fDisabled [I] controls text highlighting
857  *
858  *  RETURNS
859  *   Success: S_OK
860  *   Failure: is the value returned by ScriptTextOut
861  */
862 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
863                                int iX,
864                                int iY, 
865                                UINT uOptions, 
866                                const RECT *prc, 
867                                int iMinSel, 
868                                int iMaxSel,
869                                BOOL fDisabled)
870 {
871     StringAnalysis *analysis;
872     WORD *glyphs;
873     int   item, cnt, x;
874     HRESULT hr;
875
876     TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
877          ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
878
879     if (!(analysis = ssa)) return E_INVALIDARG;
880
881     /*
882      * Get storage for the output buffer for the consolidated strings
883      */
884     cnt = 0;
885     for (item = 0; item < analysis->numItems; item++)
886     {
887         cnt += analysis->glyphs[item].numGlyphs;
888     }
889     if (!(glyphs = heap_alloc(sizeof(WCHAR) * cnt))) return E_OUTOFMEMORY;
890
891     /*
892      * ScriptStringOut only processes glyphs hence set ETO_GLYPH_INDEX
893      */
894     uOptions |= ETO_GLYPH_INDEX;
895     analysis->pItem[0].a.fNoGlyphIndex = FALSE; /* say that we have glyphs */
896
897     /*
898      * Copy the string items into the output buffer
899      */
900
901     TRACE("numItems %d\n", analysis->numItems);
902
903     cnt = 0;
904     for (item = 0; item < analysis->numItems; item++)
905     {
906         memcpy(&glyphs[cnt], analysis->glyphs[item].glyphs,
907               sizeof(WCHAR) * analysis->glyphs[item].numGlyphs);
908
909         TRACE("Item %d, Glyphs %d ", item, analysis->glyphs[item].numGlyphs);
910         for (x = cnt; x < analysis->glyphs[item].numGlyphs + cnt; x ++)
911             TRACE("%04x", glyphs[x]);
912         TRACE("\n");
913
914         cnt += analysis->glyphs[item].numGlyphs; /* point to the end of the copied text */
915     }
916
917     hr = ScriptTextOut(analysis->hdc, (SCRIPT_CACHE *)&analysis->sc, iX, iY,
918                        uOptions, prc, &analysis->pItem->a, NULL, 0, glyphs, cnt,
919                        analysis->glyphs->piAdvance, NULL, analysis->glyphs->pGoffset);
920     TRACE("ScriptTextOut hr=%08x\n", hr);
921
922     /*
923      * Free the output buffer and script cache
924      */
925     heap_free(glyphs);
926     return hr;
927 }
928
929 /***********************************************************************
930  *      ScriptStringCPtoX (USP10.@)
931  *
932  */
933 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
934 {
935     int i, j;
936     int runningX = 0;
937     int runningCp = 0;
938     StringAnalysis* analysis = ssa;
939     BOOL itemTrailing;
940
941     TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
942
943     if (!ssa || !pX) return S_FALSE;
944
945     /* icp out of range */
946     if(icp < 0)
947     {
948         analysis->invalid = TRUE;
949         return E_INVALIDARG;
950     }
951
952     for(i=0; i<analysis->numItems; i++)
953     {
954         if (analysis->pItem[i].a.fRTL)
955             itemTrailing = !fTrailing;
956         else
957             itemTrailing = fTrailing;
958         for(j=0; j<analysis->glyphs[i].numGlyphs; j++)
959         {
960             if(runningCp == icp && itemTrailing == FALSE)
961             {
962                 *pX = runningX;
963                 return S_OK;
964             }
965             runningX += analysis->glyphs[i].piAdvance[j];
966             if(runningCp == icp && itemTrailing == TRUE)
967             {
968                 *pX = runningX;
969                 return S_OK;
970             }
971             runningCp++;
972         }
973     }
974
975     /* icp out of range */
976     analysis->invalid = TRUE;
977     return E_INVALIDARG;
978 }
979
980 /***********************************************************************
981  *      ScriptStringXtoCP (USP10.@)
982  *
983  */
984 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing) 
985 {
986     StringAnalysis* analysis = ssa;
987     int i;
988     int j;
989     int runningX = 0;
990     int runningCp = 0;
991     int width;
992
993     TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
994
995     if (!ssa || !piCh || !piTrailing) return S_FALSE;
996
997     /* out of range */
998     if(iX < 0)
999     {
1000         if (analysis->pItem[0].a.fRTL)
1001         {
1002             *piCh = 1;
1003             *piTrailing = FALSE;
1004         }
1005         else
1006         {
1007             *piCh = -1;
1008             *piTrailing = TRUE;
1009         }
1010         return S_OK;
1011     }
1012
1013     for(i=0; i<analysis->numItems; i++)
1014     {
1015         for(j=0; j<analysis->glyphs[i].numGlyphs; j++)
1016         {
1017             width = analysis->glyphs[i].piAdvance[j];
1018             if(iX < (runningX + width))
1019             {
1020                 *piCh = runningCp;
1021                 if((iX - runningX) > width/2)
1022                     *piTrailing = TRUE;
1023                 else
1024                     *piTrailing = FALSE;
1025
1026                 if (analysis->pItem[i].a.fRTL)
1027                     *piTrailing = !*piTrailing;
1028                 return S_OK;
1029             }
1030             runningX += width;
1031             runningCp++;
1032         }
1033     }
1034
1035     /* out of range */
1036     *piCh = analysis->pItem[analysis->numItems].iCharPos;
1037     *piTrailing = FALSE;
1038
1039     return S_OK;
1040 }
1041
1042
1043 /***********************************************************************
1044  *      ScriptStringFree (USP10.@)
1045  *
1046  * Free a string analysis.
1047  *
1048  * PARAMS
1049  *  pssa [I] string analysis.
1050  *
1051  * RETURNS
1052  *  Success: S_OK
1053  *  Failure: Non-zero HRESULT value.
1054  */
1055 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
1056 {
1057     StringAnalysis* analysis;
1058     BOOL invalid;
1059     int i;
1060
1061     TRACE("(%p)\n", pssa);
1062
1063     if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
1064
1065     invalid = analysis->invalid;
1066     ScriptFreeCache((SCRIPT_CACHE *)&analysis->sc);
1067
1068     for (i = 0; i < analysis->numItems; i++)
1069     {
1070         heap_free(analysis->glyphs[i].glyphs);
1071         heap_free(analysis->glyphs[i].pwLogClust);
1072         heap_free(analysis->glyphs[i].piAdvance);
1073         heap_free(analysis->glyphs[i].psva);
1074         heap_free(analysis->glyphs[i].pGoffset);
1075         heap_free(analysis->glyphs[i].abc);
1076     }
1077
1078     heap_free(analysis->glyphs);
1079     heap_free(analysis->pItem);
1080     heap_free(analysis->logattrs);
1081     heap_free(analysis->sz);
1082     heap_free(analysis->sc);
1083     heap_free(analysis);
1084
1085     if (invalid) return E_INVALIDARG;
1086     return S_OK;
1087 }
1088
1089 /***********************************************************************
1090  *      ScriptCPtoX (USP10.@)
1091  *
1092  */
1093 HRESULT WINAPI ScriptCPtoX(int iCP,
1094                            BOOL fTrailing,
1095                            int cChars,
1096                            int cGlyphs,
1097                            const WORD *pwLogClust,
1098                            const SCRIPT_VISATTR *psva,
1099                            const int *piAdvance,
1100                            const SCRIPT_ANALYSIS *psa,
1101                            int *piX)
1102 {
1103     int  item;
1104     int  iPosX;
1105     float  fMaxPosX = 0;
1106     TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
1107           iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
1108           psa, piX);
1109     for (item=0; item < cGlyphs; item++)            /* total piAdvance           */
1110         fMaxPosX += piAdvance[item];
1111     iPosX = (fMaxPosX/cGlyphs)*(iCP+fTrailing);
1112     if  (iPosX > fMaxPosX)
1113         iPosX = fMaxPosX;
1114     *piX = iPosX;                                    /* Return something in range */
1115
1116     TRACE("*piX=%d\n", *piX);
1117     return S_OK;
1118 }
1119
1120 /***********************************************************************
1121  *      ScriptXtoCP (USP10.@)
1122  *
1123  */
1124 HRESULT WINAPI ScriptXtoCP(int iX,
1125                            int cChars,
1126                            int cGlyphs,
1127                            const WORD *pwLogClust,
1128                            const SCRIPT_VISATTR *psva,
1129                            const int *piAdvance,
1130                            const SCRIPT_ANALYSIS *psa,
1131                            int *piCP,
1132                            int *piTrailing)
1133 {
1134     int item;
1135     int iPosX;
1136     float fMaxPosX = 1;
1137     float fAvePosX;
1138     TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
1139           iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
1140           psa, piCP, piTrailing);
1141     if  (iX < 0)                                    /* iX is before start of run */
1142     {
1143         *piCP = -1;
1144         *piTrailing = TRUE;
1145         return S_OK;
1146     }
1147
1148     for (item=0; item < cGlyphs; item++)            /* total piAdvance           */
1149         fMaxPosX += piAdvance[item];
1150
1151     if  (iX >= fMaxPosX)                            /* iX too large              */
1152     {
1153         *piCP = cChars;
1154         *piTrailing = FALSE;
1155         return S_OK;
1156     }
1157
1158     fAvePosX = fMaxPosX / cGlyphs;
1159     iPosX = fAvePosX;
1160     for (item = 1; item < cGlyphs  && iPosX < iX; item++)
1161         iPosX += fAvePosX;
1162     if  (iPosX - iX > fAvePosX/2)
1163         *piTrailing = 0;
1164     else
1165         *piTrailing = 1;                            /* yep we are over halfway */
1166
1167     *piCP = item -1;                                /* Return character position */
1168     TRACE("*piCP=%d iPposX=%d\n", *piCP, iPosX);
1169     return S_OK;
1170 }
1171
1172 /***********************************************************************
1173  *      ScriptBreak (USP10.@)
1174  *
1175  *  Retrieve line break information.
1176  *
1177  *  PARAMS
1178  *   chars [I] Array of characters.
1179  *   sa    [I] String analysis.
1180  *   la    [I] Array of logical attribute structures.
1181  *
1182  *  RETURNS
1183  *   Success: S_OK
1184  *   Failure: S_FALSE
1185  */
1186 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
1187 {
1188     int i;
1189
1190     TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
1191
1192     if (!la) return S_FALSE;
1193
1194     for (i = 0; i < count; i++)
1195     {
1196         memset(&la[i], 0, sizeof(SCRIPT_LOGATTR));
1197
1198         /* FIXME: set the other flags */
1199         la[i].fWhiteSpace = (chars[i] == ' ');
1200         la[i].fCharStop = 1;
1201
1202         if (i > 0 && la[i - 1].fWhiteSpace)
1203         {
1204             la[i].fSoftBreak = 1;
1205             la[i].fWordStop = 1;
1206         }
1207     }
1208     return S_OK;
1209 }
1210
1211 /***********************************************************************
1212  *      ScriptIsComplex (USP10.@)
1213  *
1214  *  Determine if a string is complex.
1215  *
1216  *  PARAMS
1217  *   chars [I] Array of characters to test.
1218  *   len   [I] Length in characters.
1219  *   flag  [I] Flag.
1220  *
1221  *  RETURNS
1222  *   Success: S_OK
1223  *   Failure: S_FALSE
1224  *
1225  */
1226 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
1227 {
1228     int i;
1229
1230     TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
1231
1232     for (i = 0; i < len; i++)
1233     {
1234         int script;
1235
1236         if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
1237             return S_OK;
1238
1239         script = get_char_script(chars[i]);
1240         if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
1241             (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
1242             return S_OK;
1243     }
1244     return S_FALSE;
1245 }
1246
1247 /***********************************************************************
1248  *      ScriptShape (USP10.@)
1249  *
1250  * Produce glyphs and visual attributes for a run.
1251  *
1252  * PARAMS
1253  *  hdc         [I]   Device context.
1254  *  psc         [I/O] Opaque pointer to a script cache.
1255  *  pwcChars    [I]   Array of characters specifying the run.
1256  *  cChars      [I]   Number of characters in pwcChars.
1257  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
1258  *  psa         [I/O] Script analysis.
1259  *  pwOutGlyphs [O]   Array of glyphs.
1260  *  pwLogClust  [O]   Array of logical cluster info.
1261  *  psva        [O]   Array of visual attributes.
1262  *  pcGlyphs    [O]   Number of glyphs returned.
1263  *
1264  * RETURNS
1265  *  Success: S_OK
1266  *  Failure: Non-zero HRESULT value.
1267  */
1268 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars, 
1269                            int cChars, int cMaxGlyphs,
1270                            SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
1271                            SCRIPT_VISATTR *psva, int *pcGlyphs)
1272 {
1273     HRESULT hr;
1274     unsigned int i;
1275     BOOL rtl;
1276
1277     TRACE("(%p, %p, %s, %d, %d, %p, %p, %p, %p, %p)\n", hdc, psc, debugstr_wn(pwcChars, cChars),
1278           cChars, cMaxGlyphs, psa, pwOutGlyphs, pwLogClust, psva, pcGlyphs);
1279
1280     if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
1281                    psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
1282
1283     if (!psva || !pcGlyphs) return E_INVALIDARG;
1284     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
1285     rtl = (!psa->fLogicalOrder && psa->fRTL);
1286
1287     *pcGlyphs = cChars;
1288     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1289     if (!pwLogClust) return E_FAIL;
1290
1291     /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
1292     for (i = 0; i < cChars; i++)
1293     {
1294         int idx = i;
1295         if (rtl) idx = cChars - 1 - i;
1296         /* FIXME: set to better values */
1297         psva[i].uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
1298         psva[i].fClusterStart  = 1;
1299         psva[i].fDiacritic     = 0;
1300         psva[i].fZeroWidth     = 0;
1301         psva[i].fReserved      = 0;
1302         psva[i].fShapeReserved = 0;
1303
1304         pwLogClust[i] = idx;
1305     }
1306
1307     if (!psa->fNoGlyphIndex)
1308     {
1309         WCHAR *rChars;
1310         if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
1311
1312         rChars = heap_alloc(sizeof(WCHAR) * cChars);
1313         if (!rChars) return E_OUTOFMEMORY;
1314         for (i = 0; i < cChars; i++)
1315         {
1316             int idx = i;
1317             WCHAR chInput;
1318             if (rtl) idx = cChars - 1 - i;
1319             if (psa->fRTL)
1320                 chInput = mirror_char(pwcChars[idx]);
1321             else
1322                 chInput = pwcChars[idx];
1323             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, chInput)))
1324             {
1325                 WORD glyph;
1326                 if (!hdc) return E_PENDING;
1327                 if (GetGlyphIndicesW(hdc, &chInput, 1, &glyph, 0) == GDI_ERROR) return S_FALSE;
1328                 pwOutGlyphs[i] = set_cache_glyph(psc, chInput, glyph);
1329             }
1330             rChars[i] = chInput;
1331         }
1332
1333         if (get_cache_pitch_family(psc) & TMPF_TRUETYPE)
1334         {
1335             SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
1336             SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
1337         }
1338         heap_free(rChars);
1339     }
1340     else
1341     {
1342         TRACE("no glyph translation\n");
1343         for (i = 0; i < cChars; i++)
1344         {
1345             int idx = i;
1346             /* No mirroring done here */
1347             if (rtl) idx = cChars - 1 - i;
1348             pwOutGlyphs[i] = pwcChars[idx];
1349         }
1350     }
1351
1352     return S_OK;
1353 }
1354
1355 /***********************************************************************
1356  *      ScriptPlace (USP10.@)
1357  *
1358  * Produce advance widths for a run.
1359  *
1360  * PARAMS
1361  *  hdc       [I]   Device context.
1362  *  psc       [I/O] Opaque pointer to a script cache.
1363  *  pwGlyphs  [I]   Array of glyphs.
1364  *  cGlyphs   [I]   Number of glyphs in pwGlyphs.
1365  *  psva      [I]   Array of visual attributes.
1366  *  psa       [I/O] String analysis.
1367  *  piAdvance [O]   Array of advance widths.
1368  *  pGoffset  [O]   Glyph offsets.
1369  *  pABC      [O]   Combined ABC width.
1370  *
1371  * RETURNS
1372  *  Success: S_OK
1373  *  Failure: Non-zero HRESULT value.
1374  */
1375 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs, 
1376                            int cGlyphs, const SCRIPT_VISATTR *psva,
1377                            SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
1378 {
1379     HRESULT hr;
1380     int i;
1381
1382     TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n",  hdc, psc, pwGlyphs, cGlyphs, psva, psa,
1383           piAdvance, pGoffset, pABC);
1384
1385     if (!psva) return E_INVALIDARG;
1386     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1387     if (!pGoffset) return E_FAIL;
1388
1389     if (pABC) memset(pABC, 0, sizeof(ABC));
1390     for (i = 0; i < cGlyphs; i++)
1391     {
1392         ABC abc;
1393         if (!get_cache_glyph_widths(psc, pwGlyphs[i], &abc))
1394         {
1395             if (!hdc) return E_PENDING;
1396             if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE) && !psa->fNoGlyphIndex)
1397             {
1398                 if (!GetCharABCWidthsI(hdc, 0, 1, (WORD *)&pwGlyphs[i], &abc)) return S_FALSE;
1399             }
1400             else
1401             {
1402                 INT width;
1403                 if (!GetCharWidth32W(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
1404                 abc.abcB = width;
1405                 abc.abcA = abc.abcC = 0;
1406             }
1407             set_cache_glyph_widths(psc, pwGlyphs[i], &abc);
1408         }
1409         if (pABC)
1410         {
1411             pABC->abcA += abc.abcA;
1412             pABC->abcB += abc.abcB;
1413             pABC->abcC += abc.abcC;
1414         }
1415         /* FIXME: set to more reasonable values */
1416         pGoffset[i].du = pGoffset[i].dv = 0;
1417         if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
1418     }
1419
1420     if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
1421     return S_OK;
1422 }
1423
1424 /***********************************************************************
1425  *      ScriptGetCMap (USP10.@)
1426  *
1427  * Retrieve glyph indices.
1428  *
1429  * PARAMS
1430  *  hdc         [I]   Device context.
1431  *  psc         [I/O] Opaque pointer to a script cache.
1432  *  pwcInChars  [I]   Array of Unicode characters.
1433  *  cChars      [I]   Number of characters in pwcInChars.
1434  *  dwFlags     [I]   Flags.
1435  *  pwOutGlyphs [O]   Buffer to receive the array of glyph indices.
1436  *
1437  * RETURNS
1438  *  Success: S_OK
1439  *  Failure: Non-zero HRESULT value.
1440  */
1441 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
1442                              int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
1443 {
1444     HRESULT hr;
1445     int i;
1446
1447     TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
1448           cChars, dwFlags, pwOutGlyphs);
1449
1450     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1451
1452     hr = S_OK;
1453
1454     if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
1455     {
1456         for (i = 0; i < cChars; i++)
1457         {
1458             WCHAR inChar;
1459             if (dwFlags == SGCM_RTL)
1460                 inChar = mirror_char(pwcInChars[i]);
1461             else
1462                 inChar = pwcInChars[i];
1463             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
1464             {
1465                 WORD glyph;
1466                 if (!hdc) return E_PENDING;
1467                 if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
1468                 if (glyph == 0xffff)
1469                 {
1470                     hr = S_FALSE;
1471                     glyph = 0x0;
1472                 }
1473                 pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
1474             }
1475         }
1476     }
1477     else
1478     {
1479         TRACE("no glyph translation\n");
1480         for (i = 0; i < cChars; i++)
1481         {
1482             WCHAR inChar;
1483             if (dwFlags == SGCM_RTL)
1484                 inChar = mirror_char(pwcInChars[i]);
1485             else
1486                 inChar = pwcInChars[i];
1487             pwOutGlyphs[i] = inChar;
1488         }
1489     }
1490     return hr;
1491 }
1492
1493 /***********************************************************************
1494  *      ScriptTextOut (USP10.@)
1495  *
1496  */
1497 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions, 
1498                              const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved, 
1499                              int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
1500                              const int *piJustify, const GOFFSET *pGoffset)
1501 {
1502     HRESULT hr = S_OK;
1503
1504     TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
1505          hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
1506          piAdvance, piJustify, pGoffset);
1507
1508     if (!hdc || !psc) return E_INVALIDARG;
1509     if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
1510
1511     fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
1512     fuOptions |= ETO_IGNORELANGUAGE;
1513     if  (!psa->fNoGlyphIndex)                                     /* Have Glyphs?                      */
1514         fuOptions |= ETO_GLYPH_INDEX;                             /* Say don't do translation to glyph */
1515
1516     if (psa->fRTL && psa->fLogicalOrder)
1517     {
1518         int i;
1519         WORD *rtlGlyphs;
1520
1521         rtlGlyphs = heap_alloc(cGlyphs * sizeof(WORD));
1522         if (!rtlGlyphs)
1523             return E_OUTOFMEMORY;
1524
1525         for (i = 0; i < cGlyphs; i++)
1526             rtlGlyphs[i] = pwGlyphs[cGlyphs-1-i];
1527
1528         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, rtlGlyphs, cGlyphs, NULL))
1529             hr = S_FALSE;
1530         heap_free(rtlGlyphs);
1531     }
1532     else
1533         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
1534             hr = S_FALSE;
1535
1536     return hr;
1537 }
1538
1539 /***********************************************************************
1540  *      ScriptCacheGetHeight (USP10.@)
1541  *
1542  * Retrieve the height of the font in the cache.
1543  *
1544  * PARAMS
1545  *  hdc    [I]    Device context.
1546  *  psc    [I/O]  Opaque pointer to a script cache.
1547  *  height [O]    Receives font height.
1548  *
1549  * RETURNS
1550  *  Success: S_OK
1551  *  Failure: Non-zero HRESULT value.
1552  */
1553 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
1554 {
1555     HRESULT hr;
1556
1557     TRACE("(%p, %p, %p)\n", hdc, psc, height);
1558
1559     if (!height) return E_INVALIDARG;
1560     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1561
1562     *height = get_cache_height(psc);
1563     return S_OK;
1564 }
1565
1566 /***********************************************************************
1567  *      ScriptGetGlyphABCWidth (USP10.@)
1568  *
1569  * Retrieve the width of a glyph.
1570  *
1571  * PARAMS
1572  *  hdc    [I]    Device context.
1573  *  psc    [I/O]  Opaque pointer to a script cache.
1574  *  glyph  [I]    Glyph to retrieve the width for.
1575  *  abc    [O]    ABC widths of the glyph.
1576  *
1577  * RETURNS
1578  *  Success: S_OK
1579  *  Failure: Non-zero HRESULT value.
1580  */
1581 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
1582 {
1583     HRESULT hr;
1584
1585     TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
1586
1587     if (!abc) return E_INVALIDARG;
1588     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1589
1590     if (!get_cache_glyph_widths(psc, glyph, abc))
1591     {
1592         if (!hdc) return E_PENDING;
1593         if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
1594         {
1595             if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
1596         }
1597         else
1598         {
1599             INT width;
1600             if (!GetCharWidth32W(hdc, glyph, glyph, &width)) return S_FALSE;
1601             abc->abcB = width;
1602             abc->abcA = abc->abcC = 0;
1603         }
1604         set_cache_glyph_widths(psc, glyph, abc);
1605     }
1606     return S_OK;
1607 }
1608
1609 /***********************************************************************
1610  *      ScriptLayout (USP10.@)
1611  *
1612  * Map embedding levels to visual and/or logical order.
1613  *
1614  * PARAMS
1615  *  runs     [I] Size of level array.
1616  *  level    [I] Array of embedding levels.
1617  *  vistolog [O] Map of embedding levels from visual to logical order.
1618  *  logtovis [O] Map of embedding levels from logical to visual order.
1619  *
1620  * RETURNS
1621  *  Success: S_OK
1622  *  Failure: Non-zero HRESULT value.
1623  *
1624  * BUGS
1625  *  This stub works correctly for any sequence of a single
1626  *  embedding level but not for sequences of different
1627  *  embedding levels, i.e. mixtures of RTL and LTR scripts.
1628  */
1629 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
1630 {
1631     int* indexs;
1632     int ich;
1633
1634     TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
1635
1636     if (!level || (!vistolog && !logtovis))
1637         return E_INVALIDARG;
1638
1639     indexs = heap_alloc(sizeof(int) * runs);
1640     if (!indexs)
1641         return E_OUTOFMEMORY;
1642
1643
1644     if (vistolog)
1645     {
1646         for( ich = 0; ich < runs; ich++)
1647             indexs[ich] = ich;
1648
1649         ich = 0;
1650         while (ich < runs)
1651             ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
1652         for (ich = 0; ich < runs; ich++)
1653             vistolog[ich] = indexs[ich];
1654     }
1655
1656
1657     if (logtovis)
1658     {
1659         for( ich = 0; ich < runs; ich++)
1660             indexs[ich] = ich;
1661
1662         ich = 0;
1663         while (ich < runs)
1664             ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
1665         for (ich = 0; ich < runs; ich++)
1666             logtovis[ich] = indexs[ich];
1667     }
1668     heap_free(indexs);
1669
1670     return S_OK;
1671 }
1672
1673 /***********************************************************************
1674  *      ScriptStringGetLogicalWidths (USP10.@)
1675  *
1676  * Returns logical widths from a string analysis.
1677  *
1678  * PARAMS
1679  *  ssa  [I] string analysis.
1680  *  piDx [O] logical widths returned.
1681  *
1682  * RETURNS
1683  *  Success: S_OK
1684  *  Failure: a non-zero HRESULT.
1685  */
1686 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
1687 {
1688     int i, j, next = 0;
1689     StringAnalysis *analysis = ssa;
1690
1691     TRACE("%p, %p\n", ssa, piDx);
1692
1693     if (!analysis) return S_FALSE;
1694
1695     for (i = 0; i < analysis->numItems; i++)
1696     {
1697         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
1698         {
1699             piDx[next] = analysis->glyphs[i].piAdvance[j];
1700             next++;
1701         }
1702     }
1703     return S_OK;
1704 }
1705
1706 /***********************************************************************
1707  *      ScriptStringValidate (USP10.@)
1708  *
1709  * Validate a string analysis.
1710  *
1711  * PARAMS
1712  *  ssa [I] string analysis.
1713  *
1714  * RETURNS
1715  *  Success: S_OK
1716  *  Failure: S_FALSE if invalid sequences are found
1717  *           or a non-zero HRESULT if it fails.
1718  */
1719 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
1720 {
1721     StringAnalysis *analysis = ssa;
1722
1723     TRACE("(%p)\n", ssa);
1724
1725     if (!analysis) return E_INVALIDARG;
1726     return (analysis->invalid) ? S_FALSE : S_OK;
1727 }
1728
1729 /***********************************************************************
1730  *      ScriptString_pSize (USP10.@)
1731  *
1732  * Retrieve width and height of an analysed string.
1733  *
1734  * PARAMS
1735  *  ssa [I] string analysis.
1736  *
1737  * RETURNS
1738  *  Success: Pointer to a SIZE structure.
1739  *  Failure: NULL
1740  */
1741 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
1742 {
1743     int i, j;
1744     StringAnalysis *analysis = ssa;
1745
1746     TRACE("(%p)\n", ssa);
1747
1748     if (!analysis) return NULL;
1749
1750     if (!analysis->sz)
1751     {
1752         if (!(analysis->sz = heap_alloc(sizeof(SIZE)))) return NULL;
1753         analysis->sz->cy = analysis->sc->tm.tmHeight;
1754
1755         analysis->sz->cx = 0;
1756         for (i = 0; i < analysis->numItems; i++)
1757             for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
1758                 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
1759     }
1760     return analysis->sz;
1761 }
1762
1763 /***********************************************************************
1764  *      ScriptString_pLogAttr (USP10.@)
1765  *
1766  * Retrieve logical attributes of an analysed string.
1767  *
1768  * PARAMS
1769  *  ssa [I] string analysis.
1770  *
1771  * RETURNS
1772  *  Success: Pointer to an array of SCRIPT_LOGATTR structures.
1773  *  Failure: NULL
1774  */
1775 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
1776 {
1777     StringAnalysis *analysis = ssa;
1778
1779     TRACE("(%p)\n", ssa);
1780
1781     if (!analysis) return NULL;
1782     return analysis->logattrs;
1783 }
1784
1785 /***********************************************************************
1786  *      ScriptString_pcOutChars (USP10.@)
1787  *
1788  * Retrieve the length of a string after clipping.
1789  *
1790  * PARAMS
1791  *  ssa [I] String analysis.
1792  *
1793  * RETURNS
1794  *  Success: Pointer to the length.
1795  *  Failure: NULL
1796  */
1797 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
1798 {
1799     StringAnalysis *analysis = ssa;
1800
1801     TRACE("(%p)\n", ssa);
1802
1803     if (!analysis) return NULL;
1804     return &analysis->clip_len;
1805 }
1806
1807 /***********************************************************************
1808  *      ScriptStringGetOrder (USP10.@)
1809  *
1810  * Retrieve a glyph order map.
1811  *
1812  * PARAMS
1813  *  ssa   [I]   String analysis.
1814  *  order [I/O] Array of glyph positions.
1815  *
1816  * RETURNS
1817  *  Success: S_OK
1818  *  Failure: a non-zero HRESULT.
1819  */
1820 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
1821 {
1822     int i, j;
1823     unsigned int k;
1824     StringAnalysis *analysis = ssa;
1825
1826     TRACE("(%p)\n", ssa);
1827
1828     if (!analysis) return S_FALSE;
1829
1830     /* FIXME: handle RTL scripts */
1831     for (i = 0, k = 0; i < analysis->numItems; i++)
1832         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
1833             order[k] = k;
1834
1835     return S_OK;
1836 }
1837
1838 /***********************************************************************
1839  *      ScriptGetLogicalWidths (USP10.@)
1840  *
1841  * Convert advance widths to logical widths.
1842  *
1843  * PARAMS
1844  *  sa          [I] Script analysis.
1845  *  nbchars     [I] Number of characters.
1846  *  nbglyphs    [I] Number of glyphs.
1847  *  glyph_width [I] Array of glyph widths.
1848  *  log_clust   [I] Array of logical clusters.
1849  *  sva         [I] Visual attributes.
1850  *  widths      [O] Array of logical widths.
1851  *
1852  * RETURNS
1853  *  Success: S_OK
1854  *  Failure: a non-zero HRESULT.
1855  */
1856 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
1857                                       const int *glyph_width, const WORD *log_clust,
1858                                       const SCRIPT_VISATTR *sva, int *widths)
1859 {
1860     int i;
1861
1862     TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
1863           sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
1864
1865     /* FIXME */
1866     for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
1867     return S_OK;
1868 }
1869
1870 /***********************************************************************
1871  *      ScriptApplyLogicalWidth (USP10.@)
1872  *
1873  * Generate glyph advance widths.
1874  *
1875  * PARAMS
1876  *  dx          [I]   Array of logical advance widths.
1877  *  num_chars   [I]   Number of characters.
1878  *  num_glyphs  [I]   Number of glyphs.
1879  *  log_clust   [I]   Array of logical clusters.
1880  *  sva         [I]   Visual attributes.
1881  *  advance     [I]   Array of glyph advance widths.
1882  *  sa          [I]   Script analysis.
1883  *  abc         [I/O] Summed ABC widths.
1884  *  justify     [O]   Array of glyph advance widths.
1885  *
1886  * RETURNS
1887  *  Success: S_OK
1888  *  Failure: a non-zero HRESULT.
1889  */
1890 HRESULT WINAPI ScriptApplyLogicalWidth(const int *dx, int num_chars, int num_glyphs,
1891                                        const WORD *log_clust, const SCRIPT_VISATTR *sva,
1892                                        const int *advance, const SCRIPT_ANALYSIS *sa,
1893                                        ABC *abc, int *justify)
1894 {
1895     int i;
1896
1897     FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
1898           dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
1899
1900     for (i = 0; i < num_chars; i++) justify[i] = advance[i];
1901     return S_OK;
1902 }
1903
1904 HRESULT WINAPI ScriptJustify(const SCRIPT_VISATTR *sva, const int *advance,
1905                              int num_glyphs, int dx, int min_kashida, int *justify)
1906 {
1907     int i;
1908
1909     FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
1910
1911     for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
1912     return S_OK;
1913 }