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