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