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