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