git.oblomov.eu Git - wine/blob - dlls/usp10/usp10.c

   1 /*
   2  * Implementation of Uniscribe Script Processor (usp10.dll)
   3  *
   4  * Copyright 2005 Steven Edwards for CodeWeavers
   5  * Copyright 2006 Hans Leidekker
   6  * Copyright 2010 CodeWeavers, Aric Stewart
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * Notes:
  23  * Uniscribe allows for processing of complex scripts such as joining
  24  * and filtering characters and bi-directional text with custom line breaks.
  25  */
  26
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winuser.h"
  34 #include "winnls.h"
  35 #include "winreg.h"
  36 #include "usp10.h"
  37
  38 #include "usp10_internal.h"
  39
  40 #include "wine/debug.h"
  41 #include "wine/unicode.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  44
  45 typedef struct _scriptRange
  46 {
  47     WORD script;
  48     DWORD rangeFirst;
  49     DWORD rangeLast;
  50     WORD numericScript;
  51     WORD punctScript;
  52 } scriptRange;
  53
  54 static const scriptRange scriptRanges[] = {
  55     /* Basic Latin: U+0000–U+007A */
  56     { Script_Latin,      0x00,   0x07a ,  Script_Numeric, Script_Punctuation},
  57     /* Latin-1 Supplement: U+0080–U+00FF */
  58     /* Latin Extended-A: U+0100–U+017F */
  59     /* Latin Extended-B: U+0180–U+024F */
  60     /* IPA Extensions: U+0250–U+02AF */
  61     /* Spacing Modifier Letters:U+02B0–U+02FF */
  62     { Script_Latin,      0x80,   0x2ff ,  Script_Numeric2, Script_Punctuation},
  63     /* Combining Diacritical Marks : U+0300–U+036F */
  64     { Script_Diacritical,0x300,  0x36f,  0, 0},
  65     /* Greek: U+0370–U+03FF */
  66     { Script_Greek,      0x370,  0x3ff,  0, 0},
  67     /* Cyrillic: U+0400–U+04FF */
  68     /* Cyrillic Supplement: U+0500–U+052F */
  69     { Script_Cyrillic,   0x400,  0x52f,  0, 0},
  70     /* Armenian: U+0530–U+058F */
  71     { Script_Armenian,   0x530,  0x58f,  0, 0},
  72     /* Hebrew: U+0590–U+05FF */
  73     { Script_Hebrew,     0x590,  0x5ff,  0, 0},
  74     /* Arabic: U+0600–U+06FF */
  75     { Script_Arabic,     0x600,  0x6ef,  Script_Arabic_Numeric, 0},
  76     /* Defined by Windows */
  77     { Script_Persian,    0x6f0,  0x6f9,  0, 0},
  78     /* Continue Arabic: U+0600–U+06FF */
  79     { Script_Arabic,     0x6fa,  0x6ff,  0, 0},
  80     /* Syriac: U+0700–U+074F*/
  81     { Script_Syriac,     0x700,  0x74f,  0, 0},
  82     /* Arabic Supplement: U+0750–U+077F */
  83     { Script_Arabic,     0x750,  0x77f,  0, 0},
  84     /* Thaana: U+0780–U+07BF */
  85     { Script_Thaana,     0x780,  0x7bf,  0, 0},
  86     /* N’Ko: U+07C0–U+07FF */
  87     { Script_NKo,        0x7c0,  0x7ff,  0, 0},
  88     /* Devanagari: U+0900–U+097F */
  89     { Script_Devanagari, 0x900,  0x97f,  Script_Devanagari_Numeric, 0},
  90     /* Bengali: U+0980–U+09FF */
  91     { Script_Bengali,    0x980,  0x9ff,  Script_Bengali_Numeric, 0},
  92     /* Gurmukhi: U+0A00–U+0A7F*/
  93     { Script_Gurmukhi,   0xa00,  0xa7f,  Script_Gurmukhi_Numeric, 0},
  94     /* Gujarati: U+0A80–U+0AFF*/
  95     { Script_Gujarati,   0xa80,  0xaff,  Script_Gujarati_Numeric, 0},
  96     /* Oriya: U+0B00–U+0B7F */
  97     { Script_Oriya,      0xb00,  0xb7f,  Script_Oriya_Numeric, 0},
  98     /* Tamil: U+0B80–U+0BFF */
  99     { Script_Tamil,      0xb80,  0xbff,  Script_Tamil_Numeric, 0},
 100     /* Telugu: U+0C00–U+0C7F */
 101     { Script_Telugu,     0xc00,  0xc7f,  Script_Telugu_Numeric, 0},
 102     /* Kannada: U+0C80–U+0CFF */
 103     { Script_Kannada,    0xc80,  0xcff,  Script_Kannada_Numeric, 0},
 104     /* Malayalam: U+0D00–U+0D7F */
 105     { Script_Malayalam,  0xd00,  0xd7f,  Script_Malayalam_Numeric, 0},
 106     /* Sinhala: U+0D80–U+0DFF */
 107     { Script_Sinhala,   0xd80,  0xdff,  0, 0},
 108     /* Thai: U+0E00–U+0E7F */
 109     { Script_Thai,      0xe00,  0xe7f,  Script_Thai_Numeric, 0},
 110     /* Lao: U+0E80–U+0EFF */
 111     { Script_Lao,       0xe80,  0xeff,  Script_Lao_Numeric, 0},
 112     /* Tibetan: U+0F00–U+0FFF */
 113     { Script_Tibetan,   0xf00,  0xfff,  0, 0},
 114     /* Myanmar: U+1000–U+109F */
 115     { Script_Myanmar,    0x1000,  0x109f, Script_Myanmar_Numeric, 0},
 116     /* Georgian: U+10A0–U+10FF */
 117     { Script_Georgian,   0x10a0,  0x10ff,  0, 0},
 118     /* Hangul Jamo: U+1100–U+11FF */
 119     { Script_Hangul,     0x1100,  0x11ff,  0, 0},
 120     /* Ethiopic: U+1200–U+137F */
 121     /* Ethiopic Extensions: U+1380–U+139F */
 122     { Script_Ethiopic,   0x1200,  0x139f,  0, 0},
 123     /* Cherokee: U+13A0–U+13FF */
 124     { Script_Cherokee,   0x13a0,  0x13ff,  0, 0},
 125     /* Canadian Aboriginal Syllabics: U+1400–U+167F */
 126     { Script_Canadian,   0x1400,  0x167f,  0, 0},
 127     /* Ogham: U+1680–U+169F */
 128     { Script_Ogham,      0x1680,  0x169f,  0, 0},
 129     /* Runic: U+16A0–U+16F0 */
 130     { Script_Runic,      0x16a0,  0x16f0,  0, 0},
 131     /* Khmer: U+1780–U+17FF */
 132     { Script_Khmer,      0x1780,  0x17ff,  Script_Khmer_Numeric, 0},
 133     /* Mongolian: U+1800–U+18AF */
 134     { Script_Mongolian,  0x1800,  0x18af,  Script_Mongolian_Numeric, 0},
 135     /* Canadian Aboriginal Syllabics Extended: U+18B0–U+18FF */
 136     { Script_Canadian,   0x18b0,  0x18ff,  0, 0},
 137     /* Tai Le: U+1950–U+197F */
 138     { Script_Tai_Le,     0x1950,  0x197f,  0, 0},
 139     /* New Tai Lue: U+1980–U+19DF */
 140     { Script_New_Tai_Lue,0x1980,  0x19df,  Script_New_Tai_Lue_Numeric, 0},
 141     /* Khmer Symbols: U+19E0–U+19FF */
 142     { Script_Khmer,      0x19e0,  0x19ff,  Script_Khmer_Numeric, 0},
 143     /* Vedic Extensions: U+1CD0-U+1CFF */
 144     { Script_Devanagari, 0x1cd0, 0x1cff, Script_Devanagari_Numeric, 0},
 145     /* Phonetic Extensions: U+1D00–U+1DBF */
 146     { Script_Latin,      0x1d00, 0x1dbf, 0, 0},
 147     /* Combining Diacritical Marks Supplement: U+1DC0–U+1DFF */
 148     { Script_Diacritical,0x1dc0, 0x1dff, 0, 0},
 149     /* Latin Extended Additional: U+1E00–U+1EFF */
 150     { Script_Latin,      0x1e00, 0x1eff, 0, 0},
 151     /* Greek Extended: U+1F00–U+1FFF */
 152     { Script_Greek,      0x1f00, 0x1fff, 0, 0},
 153     /* General Punctuation: U+2000 –U+206f */
 154     { Script_Latin,      0x2000, 0x206f, 0, 0},
 155     /* Superscripts and Subscripts : U+2070 –U+209f */
 156     /* Currency Symbols : U+20a0 –U+20cf */
 157     { Script_Numeric2,   0x2070, 0x2070, 0, 0},
 158     { Script_Latin,      0x2071, 0x2073, 0, 0},
 159     { Script_Numeric2,   0x2074, 0x2079, 0, 0},
 160     { Script_Latin,      0x207a, 0x207f, 0, 0},
 161     { Script_Numeric2,   0x2080, 0x2089, 0, 0},
 162     { Script_Latin,      0x208a, 0x20cf, 0, 0},
 163     /* Letterlike Symbols : U+2100 –U+214f */
 164     /* Number Forms : U+2150 –U+218f */
 165     /* Arrows : U+2190 –U+21ff */
 166     /* Mathematical Operators : U+2200 –U+22ff */
 167     /* Miscellaneous Technical : U+2300 –U+23ff */
 168     /* Control Pictures : U+2400 –U+243f */
 169     /* Optical Character Recognition : U+2440 –U+245f */
 170     /* Enclosed Alphanumerics : U+2460 –U+24ff */
 171     /* Box Drawing : U+2500 –U+25ff */
 172     /* Block Elements : U+2580 –U+259f */
 173     /* Geometric Shapes : U+25a0 –U+25ff */
 174     /* Miscellaneous Symbols : U+2600 –U+26ff */
 175     /* Dingbats : U+2700 –U+27bf */
 176     /* Miscellaneous Mathematical Symbols-A : U+27c0 –U+27ef */
 177     /* Supplemental Arrows-A : U+27f0 –U+27ff */
 178     { Script_Latin,      0x2100, 0x27ff, 0, 0},
 179     /* Braille Patterns: U+2800–U+28FF */
 180     { Script_Braille,    0x2800, 0x28ff, 0, 0},
 181     /* Supplemental Arrows-B : U+2900 –U+297f */
 182     /* Miscellaneous Mathematical Symbols-B : U+2980 –U+29ff */
 183     /* Supplemental Mathematical Operators : U+2a00 –U+2aff */
 184     /* Miscellaneous Symbols and Arrows : U+2b00 –U+2bff */
 185     { Script_Latin,      0x2900, 0x2bff, 0, 0},
 186     /* Latin Extended-C: U+2C60–U+2C7F */
 187     { Script_Latin,      0x2c60, 0x2c7f, 0, 0},
 188     /* Georgian: U+2D00–U+2D2F */
 189     { Script_Georgian,   0x2d00,  0x2d2f,  0, 0},
 190     /* Tifinagh: U+2D30–U+2D7F */
 191     { Script_Tifinagh,   0x2d30,  0x2d7f,  0, 0},
 192     /* Ethiopic Extensions: U+2D80–U+2DDF */
 193     { Script_Ethiopic,   0x2d80,  0x2ddf,  0, 0},
 194     /* Cyrillic Extended-A: U+2DE0–U+2DFF */
 195     { Script_Cyrillic,   0x2de0, 0x2dff,  0, 0},
 196     /* CJK Radicals Supplement: U+2E80–U+2EFF */
 197     /* Kangxi Radicals: U+2F00–U+2FDF */
 198     { Script_CJK_Han,    0x2e80, 0x2fdf,  0, 0},
 199     /* Ideographic Description Characters: U+2FF0–U+2FFF */
 200     { Script_Ideograph  ,0x2ff0, 0x2fff,  0, 0},
 201     /* CJK Symbols and Punctuation: U+3000–U+303F */
 202     { Script_Ideograph  ,0x3000, 0x3004,  0, 0},
 203     { Script_CJK_Han    ,0x3005, 0x3005,  0, 0},
 204     { Script_Ideograph  ,0x3006, 0x3006,  0, 0},
 205     { Script_CJK_Han    ,0x3007, 0x3007,  0, 0},
 206     { Script_Ideograph  ,0x3008, 0x3020,  0, 0},
 207     { Script_CJK_Han    ,0x3021, 0x3029,  0, 0},
 208     { Script_Ideograph  ,0x302a, 0x3030,  0, 0},
 209     /* Kana Marks: */
 210     { Script_Kana       ,0x3031, 0x3035,  0, 0},
 211     { Script_Ideograph  ,0x3036, 0x3037,  0, 0},
 212     { Script_CJK_Han    ,0x3038, 0x303b,  0, 0},
 213     { Script_Ideograph  ,0x303c, 0x303f,  0, 0},
 214     /* Hiragana: U+3040–U+309F */
 215     /* Katakana: U+30A0–U+30FF */
 216     { Script_Kana       ,0x3040, 0x30ff,  0, 0},
 217     /* Bopomofo: U+3100–U+312F */
 218     { Script_Bopomofo   ,0x3100, 0x312f,  0, 0},
 219     /* Hangul Compatibility Jamo: U+3130–U+318F */
 220     { Script_Hangul     ,0x3130, 0x318f,  0, 0},
 221     /* Kanbun: U+3190–U+319F */
 222     { Script_Ideograph  ,0x3190, 0x319f,  0, 0},
 223     /* Bopomofo Extended: U+31A0–U+31BF */
 224     { Script_Bopomofo   ,0x31a0, 0x31bf,  0, 0},
 225     /* CJK Strokes: U+31C0–U+31EF */
 226     { Script_Ideograph  ,0x31c0, 0x31ef,  0, 0},
 227     /* Katakana Phonetic Extensions: U+31F0–U+31FF */
 228     { Script_Kana       ,0x31f0, 0x31ff,  0, 0},
 229     /* Enclosed CJK Letters and Months: U+3200–U+32FF */
 230     { Script_Hangul     ,0x3200, 0x321f,  0, 0},
 231     { Script_Ideograph  ,0x3220, 0x325f,  0, 0},
 232     { Script_Hangul     ,0x3260, 0x327f,  0, 0},
 233     { Script_Ideograph  ,0x3280, 0x32ef,  0, 0},
 234     { Script_Kana       ,0x32d0, 0x31ff,  0, 0},
 235     /* CJK Compatibility: U+3300–U+33FF*/
 236     { Script_Kana       ,0x3300, 0x3357,  0, 0},
 237     { Script_Ideograph  ,0x3358, 0x33ff,  0, 0},
 238     /* CJK Unified Ideographs Extension A: U+3400–U+4DBF */
 239     { Script_CJK_Han    ,0x3400, 0x4dbf,  0, 0},
 240     /* CJK Unified Ideographs: U+4E00–U+9FFF */
 241     { Script_CJK_Han    ,0x4e00, 0x9fff,  0, 0},
 242     /* Yi: U+A000–U+A4CF */
 243     { Script_Yi         ,0xa000, 0xa4cf,  0, 0},
 244     /* Vai: U+A500–U+A63F */
 245     { Script_Vai        ,0xa500, 0xa63f,  Script_Vai_Numeric, 0},
 246     /* Cyrillic Extended-B: U+A640–U+A69F */
 247     { Script_Cyrillic,   0xa640, 0xa69f,  0, 0},
 248     /* Modifier Tone Letters: U+A700–U+A71F */
 249     /* Latin Extended-D: U+A720–U+A7FF */
 250     { Script_Latin,      0xa700, 0xa7ff, 0, 0},
 251     /* Phags-pa: U+A840–U+A87F */
 252     { Script_Phags_pa,   0xa840, 0xa87f, 0, 0},
 253     /* Devanagari Extended: U+A8E0-U+A8FF */
 254     { Script_Devanagari, 0xa8e0, 0xa8ff, Script_Devanagari_Numeric, 0},
 255     /* Myanmar Extended-A: U+AA60–U+AA7F */
 256     { Script_Myanmar,    0xaa60,  0xaa7f, Script_Myanmar_Numeric, 0},
 257     /* Hangul Jamo Extended-A: U+A960–U+A97F */
 258     { Script_Hangul,     0xa960, 0xa97f,  0, 0},
 259     /* Hangul Syllables: U+AC00–U+D7A3 */
 260     { Script_Hangul,     0xac00, 0xd7a3,  0, 0},
 261     /* Hangul Jamo Extended-B: U+D7B0–U+D7FF */
 262     { Script_Hangul,     0xd7b0, 0xd7ff,  0, 0},
 263     /* Surrogates Area: U+D800–U+DFFF */
 264     { Script_Surrogates, 0xd800, 0xdbfe,  0, 0},
 265     { Script_Private,    0xdbff, 0xdc00,  0, 0},
 266     { Script_Surrogates, 0xdc01, 0xdfff,  0, 0},
 267     /* Private Use Area: U+E000–U+F8FF */
 268     { Script_Private,    0xe000, 0xf8ff,  0, 0},
 269     /* CJK Compatibility Ideographs: U+F900–U+FAFF */
 270     { Script_CJK_Han    ,0xf900, 0xfaff,  0, 0},
 271     /* Latin Ligatures: U+FB00–U+FB06 */
 272     { Script_Latin,      0xfb00, 0xfb06, 0, 0},
 273     /* Armenian ligatures U+FB13..U+FB17 */
 274     { Script_Armenian,   0xfb13, 0xfb17,  0, 0},
 275     /* Alphabetic Presentation Forms: U+FB1D–U+FB4F */
 276     { Script_Hebrew,     0xfb1d, 0xfb4f, 0, 0},
 277     /* Arabic Presentation Forms-A: U+FB50–U+FDFF*/
 278     { Script_Arabic,     0xfb50, 0xfdff, 0, 0},
 279     /* Vertical Forms: U+FE10–U+FE1F */
 280     /* Combining Half Marks: U+FE20–U+FE2F */
 281     /* CJK Compatibility Forms: U+FE30–U+FE4F */
 282     /* Small Form Variants: U+FE50–U+FE6F */
 283     { Script_Ideograph  ,0xfe10, 0xfe6f,  0, 0},
 284     /* Arabic Presentation Forms-B: U+FE70–U+FEFF*/
 285     { Script_Arabic,     0xfe70, 0xfeff, 0, 0},
 286     /* Halfwidth and Fullwidth Forms: U+FF00–FFEF */
 287     { Script_Ideograph  ,0xff00, 0xff64,  Script_Numeric2, 0},
 288     { Script_Kana       ,0xff65, 0xff9f,  0, 0},
 289     { Script_Hangul     ,0xffa0, 0xffdf,  0, 0},
 290     { Script_Ideograph  ,0xffe0, 0xffef,  0, 0},
 291     /* Plane - 1 */
 292     /* Deseret: U+10400–U+1044F */
 293     { Script_Deseret,     0x10400, 0x1044F,  0, 0},
 294     /* Osmanya: U+10480–U+104AF */
 295     { Script_Osmanya,    0x10480, 0x104AF,  Script_Osmanya_Numeric, 0},
 296     /* Mathematical Alphanumeric Symbols: U+1D400–U+1D7FF */
 297     { Script_MathAlpha,  0x1D400, 0x1D7FF,  0, 0},
 298     /* END */
 299     { SCRIPT_UNDEFINED,  0, 0, 0}
 300 };
 301
 302 /* the must be in order so that the index matches the Script value */
 303 const scriptData scriptInformation[] = {
 304     {{SCRIPT_UNDEFINED, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 305      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 306      0x00000000,
 307      {0}},
 308     {{Script_Latin, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 309      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 310      MS_MAKE_TAG('l','a','t','n'),
 311      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 312     {{Script_CR, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 313      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 314      0x00000000,
 315      {0}},
 316     {{Script_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 317      {LANG_ENGLISH, 1, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 318      0x00000000,
 319      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 320     {{Script_Control, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 321      {LANG_ENGLISH, 0, 1, 0, 0, ANSI_CHARSET, 1, 0, 0, 0, 0, 0, 1, 0, 0},
 322      0x00000000,
 323      {0}},
 324     {{Script_Punctuation, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 325      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 326      0x00000000,
 327      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 328     {{Script_Arabic, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 329      {LANG_ARABIC, 0, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 330      MS_MAKE_TAG('a','r','a','b'),
 331      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 332     {{Script_Arabic_Numeric, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 333      {LANG_ARABIC, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 334      MS_MAKE_TAG('a','r','a','b'),
 335      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 336     {{Script_Hebrew, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 337      {LANG_HEBREW, 0, 1, 0, 1, HEBREW_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 338      MS_MAKE_TAG('h','e','b','r'),
 339      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 340     {{Script_Syriac, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 341      {LANG_SYRIAC, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 1, 0},
 342      MS_MAKE_TAG('s','y','r','c'),
 343      {'E','s','t','r','a','n','g','e','l','o',' ','E','d','e','s','s','a',0}},
 344     {{Script_Persian, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 345      {LANG_PERSIAN, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 346      MS_MAKE_TAG('s','y','r','c'),
 347      {'E','s','t','r','a','n','g','e','l','o',' ','E','d','e','s','s','a',0}},
 348     {{Script_Thaana, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 349      {LANG_DIVEHI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 350      MS_MAKE_TAG('t','h','a','a'),
 351      {'M','V',' ','B','o','l','i',0}},
 352     {{Script_Greek, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 353      {LANG_GREEK, 0, 0, 0, 0, GREEK_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 354      MS_MAKE_TAG('g','r','e','k'),
 355      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 356     {{Script_Cyrillic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 357      {LANG_RUSSIAN, 0, 0, 0, 0, RUSSIAN_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 358      MS_MAKE_TAG('c','y','r','l'),
 359      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 360     {{Script_Armenian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 361      {LANG_ARMENIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 362      MS_MAKE_TAG('a','r','m','n'),
 363      {'S','y','l','f','a','e','n',0}},
 364     {{Script_Georgian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 365      {LANG_GEORGIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 366      MS_MAKE_TAG('g','e','o','r'),
 367      {'S','y','l','f','a','e','n',0}},
 368     {{Script_Sinhala, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 369      {LANG_SINHALESE, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 370      MS_MAKE_TAG('s','i','n','h'),
 371      {'I','s','k','o','o','l','a',' ','P','o','t','a',0}},
 372     {{Script_Tibetan, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 373      {LANG_TIBETAN, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0},
 374      MS_MAKE_TAG('t','i','b','t'),
 375      {'M','i','c','r','o','s','o','f','t',' ','H','i','m','a','l','a','y','a',0}},
 376     {{Script_Tibetan_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 377      {LANG_TIBETAN, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 378      MS_MAKE_TAG('t','i','b','t'),
 379      {'M','i','c','r','o','s','o','f','t',' ','H','i','m','a','l','a','y','a',0}},
 380     {{Script_Phags_pa, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 381      {LANG_MONGOLIAN, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 382      MS_MAKE_TAG('p','h','a','g'),
 383      {'M','i','c','r','o','s','o','f','t',' ','P','h','a','g','s','P','a',0}},
 384     {{Script_Thai, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 385      {LANG_THAI, 0, 1, 1, 1, THAI_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 1},
 386      MS_MAKE_TAG('t','h','a','i'),
 387      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 388     {{Script_Thai_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 389      {LANG_THAI, 1, 1, 0, 0, THAI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 390      MS_MAKE_TAG('t','h','a','i'),
 391      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 392     {{Script_Lao, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 393      {LANG_LAO, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0},
 394      MS_MAKE_TAG('l','a','o',' '),
 395      {'D','o','k','C','h','a','m','p','a',0}},
 396     {{Script_Lao_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 397      {LANG_LAO, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 398      MS_MAKE_TAG('l','a','o',' '),
 399      {'D','o','k','C','h','a','m','p','a',0}},
 400     {{Script_Devanagari, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 401      {LANG_HINDI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 402      MS_MAKE_TAG('d','e','v','a'),
 403      {'M','a','n','g','a','l',0}},
 404     {{Script_Devanagari_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 405      {LANG_HINDI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 406      MS_MAKE_TAG('d','e','v','a'),
 407      {'M','a','n','g','a','l',0}},
 408     {{Script_Bengali, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 409      {LANG_BENGALI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 410      MS_MAKE_TAG('b','e','n','g'),
 411      {'V','r','i','n','d','a',0}},
 412     {{Script_Bengali_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 413      {LANG_BENGALI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 414      MS_MAKE_TAG('b','e','n','g'),
 415      {'V','r','i','n','d','a',0}},
 416     {{Script_Bengali_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 417      {LANG_BENGALI, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 418      MS_MAKE_TAG('b','e','n','g'),
 419      {'V','r','i','n','d','a',0}},
 420     {{Script_Gurmukhi, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 421      {LANG_PUNJABI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 422      MS_MAKE_TAG('g','u','r','u'),
 423      {'R','a','a','v','i',0}},
 424     {{Script_Gurmukhi_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 425      {LANG_PUNJABI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 426      MS_MAKE_TAG('g','u','r','u'),
 427      {'R','a','a','v','i',0}},
 428     {{Script_Gujarati, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 429      {LANG_GUJARATI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 430      MS_MAKE_TAG('g','u','j','r'),
 431      {'S','h','r','u','t','i',0}},
 432     {{Script_Gujarati_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 433      {LANG_GUJARATI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 434      MS_MAKE_TAG('g','u','j','r'),
 435      {'S','h','r','u','t','i',0}},
 436     {{Script_Gujarati_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 437      {LANG_GUJARATI, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 438      MS_MAKE_TAG('g','u','j','r'),
 439      {'S','h','r','u','t','i',0}},
 440     {{Script_Oriya, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 441      {LANG_ORIYA, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 442      MS_MAKE_TAG('o','r','y','a'),
 443      {'K','a','l','i','n','g','a',0}},
 444     {{Script_Oriya_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 445      {LANG_ORIYA, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 446      MS_MAKE_TAG('o','r','y','a'),
 447      {'K','a','l','i','n','g','a',0}},
 448     {{Script_Tamil, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 449      {LANG_TAMIL, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 450      MS_MAKE_TAG('t','a','m','l'),
 451      {'L','a','t','h','a',0}},
 452     {{Script_Tamil_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 453      {LANG_TAMIL, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 454      MS_MAKE_TAG('t','a','m','l'),
 455      {'L','a','t','h','a',0}},
 456     {{Script_Telugu, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 457      {LANG_TELUGU, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 458      MS_MAKE_TAG('t','e','l','u'),
 459      {'G','a','u','t','a','m','i',0}},
 460     {{Script_Telugu_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 461      {LANG_TELUGU, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 462      MS_MAKE_TAG('t','e','l','u'),
 463      {'G','a','u','t','a','m','i',0}},
 464     {{Script_Kannada, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 465      {LANG_KANNADA, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 466      MS_MAKE_TAG('k','n','d','a'),
 467      {'T','u','n','g','a',0}},
 468     {{Script_Kannada_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 469      {LANG_KANNADA, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 470      MS_MAKE_TAG('k','n','d','a'),
 471      {'T','u','n','g','a',0}},
 472     {{Script_Malayalam, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 473      {LANG_MALAYALAM, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 474      MS_MAKE_TAG('m','l','y','m'),
 475      {'K','a','r','t','i','k','a',0}},
 476     {{Script_Malayalam_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 477      {LANG_MALAYALAM, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 478      MS_MAKE_TAG('m','l','y','m'),
 479      {'K','a','r','t','i','k','a',0}},
 480     {{Script_Diacritical, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 481      {LANG_ENGLISH, 0, 1, 0, 1, ANSI_CHARSET, 0, 0, 0, 0, 0, 1, 1, 0, 0},
 482      0x00000000,
 483      {0}},
 484     {{Script_Punctuation2, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 485      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 486      MS_MAKE_TAG('l','a','t','n'),
 487      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 488     {{Script_Numeric2, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 489      {LANG_ENGLISH, 1, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 490      0x00000000,
 491      {0}},
 492     {{Script_Myanmar, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 493      {0x55, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 494      MS_MAKE_TAG('m','y','m','r'),
 495      {'M','y','a','n','m','a','r',' ','T','e','x','t',0}},
 496     {{Script_Myanmar_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 497      {0x55, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 498      MS_MAKE_TAG('m','y','m','r'),
 499      {0}},
 500     {{Script_Tai_Le, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 501      {0, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 502      MS_MAKE_TAG('t','a','l','e'),
 503      {'M','i','c','r','o','s','o','f','t',' ','T','a','i',' ','L','e'}},
 504     {{Script_New_Tai_Lue, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 505      {0, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 506      MS_MAKE_TAG('t','a','l','u'),
 507      {'M','i','c','r','o','s','o','f','t',' ','N','e','w',' ','T','a','i',' ','L','u','e'}},
 508     {{Script_New_Tai_Lue_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 509      {0, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 510      MS_MAKE_TAG('t','a','l','u'),
 511      {'M','i','c','r','o','s','o','f','t',' ','N','e','w',' ','T','a','i',' ','L','u','e'}},
 512     {{Script_Khmer, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 513      {0x53, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 514      MS_MAKE_TAG('k','h','m','r'),
 515      {'D','a','u','n','P','e','n','h'}},
 516     {{Script_Khmer, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 517      {0x53, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 518      MS_MAKE_TAG('k','h','m','r'),
 519      {'D','a','u','n','P','e','n','h'}},
 520     {{Script_CJK_Han, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 521      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 522      MS_MAKE_TAG('h','a','n','i'),
 523      {0}},
 524     {{Script_Ideograph, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 525      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 526      MS_MAKE_TAG('h','a','n','i'),
 527      {0}},
 528     {{Script_Bopomofo, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 529      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 530      MS_MAKE_TAG('b','o','p','o'),
 531      {0}},
 532     {{Script_Kana, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 533      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 534      MS_MAKE_TAG('k','a','n','a'),
 535      {0}},
 536     {{Script_Hangul, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 537      {LANG_KOREAN, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 538      MS_MAKE_TAG('h','a','n','g'),
 539      {0}},
 540     {{Script_Yi, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 541      {LANG_ENGLISH, 0, 0, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 542      MS_MAKE_TAG('y','i',' ',' '),
 543      {'M','i','c','r','o','s','o','f','t',' ','Y','i',' ','B','a','i','t','i'}},
 544     {{Script_Ethiopic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 545      {0x5e, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 546      MS_MAKE_TAG('e','t','h','i'),
 547      {'N','y','a','l','a'}},
 548     {{Script_Ethiopic_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 549      {0x5e, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 550      MS_MAKE_TAG('e','t','h','i'),
 551      {'N','y','a','l','a'}},
 552     {{Script_Mongolian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 553      {LANG_MONGOLIAN, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 554      MS_MAKE_TAG('m','o','n','g'),
 555      {'M','o','n','g','o','l','i','a','n',' ','B','a','i','t','i'}},
 556     {{Script_Mongolian_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 557      {LANG_MONGOLIAN, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 558      MS_MAKE_TAG('m','o','n','g'),
 559      {'M','o','n','g','o','l','i','a','n',' ','B','a','i','t','i'}},
 560     {{Script_Tifinagh, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 561      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 562      MS_MAKE_TAG('t','f','n','g'),
 563      {'E','b','r','i','m','a'}},
 564     {{Script_NKo, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 565      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 566      MS_MAKE_TAG('n','k','o',' '),
 567      {'E','b','r','i','m','a'}},
 568     {{Script_Vai, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 569      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 570      MS_MAKE_TAG('v','a','i',' '),
 571      {'E','b','r','i','m','a'}},
 572     {{Script_Vai_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 573      {0, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 574      MS_MAKE_TAG('v','a','i',' '),
 575      {'E','b','r','i','m','a'}},
 576     {{Script_Cherokee, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 577      {0x5c, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 578      MS_MAKE_TAG('c','h','e','r'),
 579      {'P','l','a','n','t','a','g','e','n','e','t',' ','C','h','e','r','o','k','e','e'}},
 580     {{Script_Canadian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 581      {0x5d, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 582      MS_MAKE_TAG('c','a','n','s'),
 583      {'E','u','p','h','e','m','i','a'}},
 584     {{Script_Ogham, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 585      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 586      MS_MAKE_TAG('o','g','a','m'),
 587      {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
 588     {{Script_Runic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 589      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 590      MS_MAKE_TAG('r','u','n','r'),
 591      {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
 592     {{Script_Braille, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 593      {LANG_ENGLISH, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 594      MS_MAKE_TAG('b','r','a','i'),
 595      {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
 596     {{Script_Surrogates, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 597      {LANG_ENGLISH, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 598      0x00000000,
 599      {0}},
 600     {{Script_Private, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 601      {0, 0, 0, 0, 0, DEFAULT_CHARSET, 0, 1, 0, 0, 0, 0, 1, 0, 0},
 602      0x00000000,
 603      {0}},
 604     {{Script_Deseret, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 605      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 606      MS_MAKE_TAG('d','s','r','t'),
 607      {'S','e','g','o','e',' ','U','I',' ','S','y','m','b','o','l'}},
 608     {{Script_Osmanya, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 609      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 610      MS_MAKE_TAG('o','s','m','a'),
 611      {'E','b','r','i','m','a'}},
 612     {{Script_Osmanya_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 613      {0, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 614      MS_MAKE_TAG('o','s','m','a'),
 615      {'E','b','r','i','m','a'}},
 616     {{Script_MathAlpha, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 617      {0, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 618      MS_MAKE_TAG('m','a','t','h'),
 619      {'C','a','m','b','r','i','a',' ','M','a','t','h'}},
 620     {{Script_Hebrew_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 621      {LANG_HEBREW, 0, 1, 0, 0, HEBREW_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 622      MS_MAKE_TAG('h','e','b','r'),
 623      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 624     {{Script_Vietnamese_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 625      {LANG_VIETNAMESE, 0, 0, 0, 0, VIETNAMESE_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 626      MS_MAKE_TAG('l','a','t','n'),
 627      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 628     {{Script_Thai_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 629      {LANG_THAI, 0, 1, 0, 0, THAI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 630      MS_MAKE_TAG('t','h','a','i'),
 631      {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0}},
 632 };
 633
 634 static const SCRIPT_PROPERTIES *script_props[] =
 635 {
 636     &scriptInformation[0].props, &scriptInformation[1].props,
 637     &scriptInformation[2].props, &scriptInformation[3].props,
 638     &scriptInformation[4].props, &scriptInformation[5].props,
 639     &scriptInformation[6].props, &scriptInformation[7].props,
 640     &scriptInformation[8].props, &scriptInformation[9].props,
 641     &scriptInformation[10].props, &scriptInformation[11].props,
 642     &scriptInformation[12].props, &scriptInformation[13].props,
 643     &scriptInformation[14].props, &scriptInformation[15].props,
 644     &scriptInformation[16].props, &scriptInformation[17].props,
 645     &scriptInformation[18].props, &scriptInformation[19].props,
 646     &scriptInformation[20].props, &scriptInformation[21].props,
 647     &scriptInformation[22].props, &scriptInformation[23].props,
 648     &scriptInformation[24].props, &scriptInformation[25].props,
 649     &scriptInformation[26].props, &scriptInformation[27].props,
 650     &scriptInformation[28].props, &scriptInformation[29].props,
 651     &scriptInformation[30].props, &scriptInformation[31].props,
 652     &scriptInformation[32].props, &scriptInformation[33].props,
 653     &scriptInformation[34].props, &scriptInformation[35].props,
 654     &scriptInformation[36].props, &scriptInformation[37].props,
 655     &scriptInformation[38].props, &scriptInformation[39].props,
 656     &scriptInformation[40].props, &scriptInformation[41].props,
 657     &scriptInformation[42].props, &scriptInformation[43].props,
 658     &scriptInformation[44].props, &scriptInformation[45].props,
 659     &scriptInformation[46].props, &scriptInformation[47].props,
 660     &scriptInformation[48].props, &scriptInformation[49].props,
 661     &scriptInformation[50].props, &scriptInformation[51].props,
 662     &scriptInformation[52].props, &scriptInformation[53].props,
 663     &scriptInformation[54].props, &scriptInformation[55].props,
 664     &scriptInformation[56].props, &scriptInformation[57].props,
 665     &scriptInformation[58].props, &scriptInformation[59].props,
 666     &scriptInformation[60].props, &scriptInformation[61].props,
 667     &scriptInformation[62].props, &scriptInformation[63].props,
 668     &scriptInformation[64].props, &scriptInformation[65].props,
 669     &scriptInformation[66].props, &scriptInformation[67].props,
 670     &scriptInformation[68].props, &scriptInformation[69].props,
 671     &scriptInformation[70].props, &scriptInformation[71].props,
 672     &scriptInformation[72].props, &scriptInformation[73].props,
 673     &scriptInformation[74].props, &scriptInformation[75].props,
 674     &scriptInformation[76].props, &scriptInformation[77].props,
 675     &scriptInformation[78].props, &scriptInformation[79].props,
 676     &scriptInformation[80].props, &scriptInformation[81].props
 677 };
 678
 679 typedef struct {
 680     ScriptCache *sc;
 681     int numGlyphs;
 682     WORD* glyphs;
 683     WORD* pwLogClust;
 684     int* piAdvance;
 685     SCRIPT_VISATTR* psva;
 686     GOFFSET* pGoffset;
 687     ABC* abc;
 688     int iMaxPosX;
 689     HFONT fallbackFont;
 690 } StringGlyphs;
 691
 692 typedef struct {
 693     HDC hdc;
 694     DWORD dwFlags;
 695     BOOL invalid;
 696     int clip_len;
 697     int cItems;
 698     int cMaxGlyphs;
 699     SCRIPT_ITEM* pItem;
 700     int numItems;
 701     StringGlyphs* glyphs;
 702     SCRIPT_LOGATTR* logattrs;
 703     SIZE* sz;
 704     int* logical2visual;
 705 } StringAnalysis;
 706
 707 typedef struct {
 708     BOOL ascending;
 709     WORD target;
 710 } FindGlyph_struct;
 711
 712 static inline void *heap_alloc(SIZE_T size)
 713 {
 714     return HeapAlloc(GetProcessHeap(), 0, size);
 715 }
 716
 717 static inline void *heap_alloc_zero(SIZE_T size)
 718 {
 719     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 720 }
 721
 722 static inline void *heap_realloc_zero(LPVOID mem, SIZE_T size)
 723 {
 724     return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
 725 }
 726
 727 static inline BOOL heap_free(LPVOID mem)
 728 {
 729     return HeapFree(GetProcessHeap(), 0, mem);
 730 }
 731
 732 /* TODO Fix font properties on Arabic locale */
 733 static inline BOOL set_cache_font_properties(const HDC hdc, ScriptCache *sc)
 734 {
 735     if (!sc->sfnt)
 736     {
 737         sc->sfp.wgBlank = sc->tm.tmBreakChar;
 738         sc->sfp.wgDefault = sc->tm.tmDefaultChar;
 739         sc->sfp.wgInvalid = sc->sfp.wgBlank;
 740         sc->sfp.wgKashida = 0xFFFF;
 741         sc->sfp.iKashidaWidth = 0;
 742     }
 743     else
 744     {
 745         static const WCHAR chars[4] = {0x0020, 0x200B, 0xF71B, 0x0640};
 746         /* U+0020: numeric space
 747            U+200B: zero width space
 748            U+F71B: unknow char found by black box testing
 749            U+0640: kashida */
 750         WORD gi[4];
 751
 752         if (GetGlyphIndicesW(hdc, chars, 4, gi, GGI_MARK_NONEXISTING_GLYPHS) != GDI_ERROR)
 753         {
 754             if(gi[0] != 0xFFFF) /* 0xFFFF: index of default non exist char */
 755                 sc->sfp.wgBlank = gi[0];
 756             else
 757                 sc->sfp.wgBlank = 0;
 758
 759             sc->sfp.wgDefault = 0;
 760
 761             if (gi[2] != 0xFFFF)
 762                 sc->sfp.wgInvalid = gi[2];
 763             else if (gi[1] != 0xFFFF)
 764                 sc->sfp.wgInvalid = gi[1];
 765             else if (gi[0] != 0xFFFF)
 766                 sc->sfp.wgInvalid = gi[0];
 767             else
 768                 sc->sfp.wgInvalid = 0;
 769
 770             sc->sfp.wgKashida = gi[3];
 771
 772             sc->sfp.iKashidaWidth = 0; /* TODO */
 773         }
 774         else
 775             return FALSE;
 776     }
 777     return TRUE;
 778 }
 779
 780 static inline void get_cache_font_properties(SCRIPT_FONTPROPERTIES *sfp, ScriptCache *sc)
 781 {
 782     sfp->wgBlank = sc->sfp.wgBlank;
 783     sfp->wgDefault = sc->sfp.wgDefault;
 784     sfp->wgInvalid = sc->sfp.wgInvalid;
 785     sfp->wgKashida = sc->sfp.wgKashida;
 786     sfp->iKashidaWidth = sc->sfp.iKashidaWidth;
 787 }
 788
 789 static inline LONG get_cache_height(SCRIPT_CACHE *psc)
 790 {
 791     return ((ScriptCache *)*psc)->tm.tmHeight;
 792 }
 793
 794 static inline BYTE get_cache_pitch_family(SCRIPT_CACHE *psc)
 795 {
 796     return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
 797 }
 798
 799 static inline WORD get_cache_glyph(SCRIPT_CACHE *psc, DWORD c)
 800 {
 801     CacheGlyphPage *page = ((ScriptCache *)*psc)->page[c / 0x10000];
 802     WORD *block;
 803
 804     if (!page) return 0;
 805     block = page->glyphs[(c % 0x10000) >> GLYPH_BLOCK_SHIFT];
 806     if (!block) return 0;
 807     return block[(c % 0x10000) & GLYPH_BLOCK_MASK];
 808 }
 809
 810 static inline WORD set_cache_glyph(SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
 811 {
 812     CacheGlyphPage **page = &((ScriptCache *)*psc)->page[c / 0x10000];
 813     WORD **block;
 814     if (!*page && !(*page = heap_alloc_zero(sizeof(CacheGlyphPage)))) return 0;
 815
 816     block = &(*page)->glyphs[(c % 0x10000) >> GLYPH_BLOCK_SHIFT];
 817     if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
 818     return ((*block)[(c % 0x10000) & GLYPH_BLOCK_MASK] = glyph);
 819 }
 820
 821 static inline BOOL get_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
 822 {
 823     static const ABC nil;
 824     ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 825
 826     if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
 827     memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
 828     return TRUE;
 829 }
 830
 831 static inline BOOL set_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
 832 {
 833     ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 834
 835     if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
 836     memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
 837     return TRUE;
 838 }
 839
 840 static HRESULT init_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
 841 {
 842     ScriptCache *sc;
 843     int size;
 844
 845     if (!psc) return E_INVALIDARG;
 846     if (*psc) return S_OK;
 847     if (!hdc) return E_PENDING;
 848
 849     if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
 850     if (!GetTextMetricsW(hdc, &sc->tm))
 851     {
 852         heap_free(sc);
 853         return E_INVALIDARG;
 854     }
 855     size = GetOutlineTextMetricsW(hdc, 0, NULL);
 856     if (size)
 857     {
 858         sc->otm = heap_alloc(size);
 859         sc->otm->otmSize = size;
 860         GetOutlineTextMetricsW(hdc, size, sc->otm);
 861     }
 862     if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(LOGFONTW), &sc->lf))
 863     {
 864         heap_free(sc);
 865         return E_INVALIDARG;
 866     }
 867     sc->sfnt = (GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, NULL, 0)!=GDI_ERROR);
 868     if (!set_cache_font_properties(hdc, sc))
 869     {
 870         heap_free(sc);
 871         return E_INVALIDARG;
 872     }
 873     *psc = sc;
 874     TRACE("<- %p\n", sc);
 875     return S_OK;
 876 }
 877
 878 static WCHAR mirror_char( WCHAR ch )
 879 {
 880     extern const WCHAR wine_mirror_map[];
 881     return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
 882 }
 883
 884 static inline DWORD decode_surrogate_pair(LPCWSTR str, INT index, INT end)
 885 {
 886     if (index < end-1 && IS_SURROGATE_PAIR(str[index],str[index+1]))
 887     {
 888         DWORD ch = 0x10000 + ((str[index] - 0xd800) << 10) + (str[index+1] - 0xdc00);
 889         TRACE("Surrogate Pair %x %x => %x\n",str[index], str[index+1], ch);
 890         return ch;
 891     }
 892     return 0;
 893 }
 894
 895 static WORD get_char_script( LPCWSTR str, INT index, INT end, INT *consumed)
 896 {
 897     static const WCHAR latin_punc[] = {'#','$','&','\'',',',';','<','>','?','@','\\','^','_','`','{','|','}','~', 0x00a0, 0};
 898     WORD type = 0;
 899     DWORD ch;
 900     int i;
 901
 902     *consumed = 1;
 903
 904     if (str[index] == 0xc || str[index] == 0x20 || str[index] == 0x202f)
 905         return Script_CR;
 906
 907     /* These punctuation are separated out as Latin punctuation */
 908     if (strchrW(latin_punc,str[index]))
 909         return Script_Punctuation2;
 910
 911     /* These chars are itemized as Punctuation by Windows */
 912     if (str[index] == 0x2212 || str[index] == 0x2044)
 913         return Script_Punctuation;
 914
 915     /* Currency Symboles by Unicode point */
 916     switch (str[index])
 917     {
 918         case 0x09f2:
 919         case 0x09f3: return Script_Bengali_Currency;
 920         case 0x0af1: return Script_Gujarati_Currency;
 921         case 0x0e3f: return Script_Thai_Currency;
 922         case 0x20aa: return Script_Hebrew_Currency;
 923         case 0x20ab: return Script_Vietnamese_Currency;
 924         case 0xfb29: return Script_Hebrew_Currency;
 925     }
 926
 927     GetStringTypeW(CT_CTYPE1, &str[index], 1, &type);
 928
 929     if (type == 0)
 930         return SCRIPT_UNDEFINED;
 931
 932     if (type & C1_CNTRL)
 933         return Script_Control;
 934
 935     ch = decode_surrogate_pair(str, index, end);
 936     if (ch)
 937         *consumed = 2;
 938     else
 939         ch = str[index];
 940
 941     i = 0;
 942     do
 943     {
 944         if (ch < scriptRanges[i].rangeFirst || scriptRanges[i].script == SCRIPT_UNDEFINED)
 945             break;
 946
 947         if (ch >= scriptRanges[i].rangeFirst && ch <= scriptRanges[i].rangeLast)
 948         {
 949             if (scriptRanges[i].numericScript && type & C1_DIGIT)
 950                 return scriptRanges[i].numericScript;
 951             if (scriptRanges[i].punctScript && type & C1_PUNCT)
 952                 return scriptRanges[i].punctScript;
 953             return scriptRanges[i].script;
 954         }
 955         i++;
 956     } while (1);
 957
 958     return SCRIPT_UNDEFINED;
 959 }
 960
 961 static int compare_FindGlyph(const void *a, const void* b)
 962 {
 963     const FindGlyph_struct *find = (FindGlyph_struct*)a;
 964     const WORD *idx= (WORD*)b;
 965     int rc = 0;
 966
 967     if ( find->target > *idx)
 968         rc = 1;
 969     else if (find->target < *idx)
 970         rc = -1;
 971
 972     if (!find->ascending)
 973         rc *= -1;
 974     return rc;
 975 }
 976
 977 int USP10_FindGlyphInLogClust(const WORD* pwLogClust, int cChars, WORD target)
 978 {
 979     FindGlyph_struct fgs;
 980     WORD *ptr;
 981     INT k;
 982
 983     if (pwLogClust[0] < pwLogClust[cChars-1])
 984         fgs.ascending = TRUE;
 985     else
 986         fgs.ascending = FALSE;
 987
 988     fgs.target = target;
 989     ptr = bsearch(&fgs, pwLogClust, cChars, sizeof(WORD), compare_FindGlyph);
 990
 991     if (!ptr)
 992         return -1;
 993
 994     for (k = (ptr - pwLogClust)-1; k >= 0 && pwLogClust[k] == target; k--)
 995     ;
 996     k++;
 997
 998     return k;
 999 }
1000
1001 /***********************************************************************
1002  *      DllMain
1003  *
1004  */
1005 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
1006 {
1007     switch(fdwReason)
1008     {
1009     case DLL_PROCESS_ATTACH:
1010         DisableThreadLibraryCalls(hInstDLL);
1011         break;
1012     case DLL_PROCESS_DETACH:
1013         break;
1014     }
1015     return TRUE;
1016 }
1017
1018 /***********************************************************************
1019  *      ScriptFreeCache (USP10.@)
1020  *
1021  * Free a script cache.
1022  *
1023  * PARAMS
1024  *   psc [I/O] Script cache.
1025  *
1026  * RETURNS
1027  *  Success: S_OK
1028  *  Failure: Non-zero HRESULT value.
1029  */
1030 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
1031 {
1032     TRACE("%p\n", psc);
1033
1034     if (psc && *psc)
1035     {
1036         unsigned int i;
1037         for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
1038         {
1039             heap_free(((ScriptCache *)*psc)->widths[i]);
1040         }
1041         for (i = 0; i < 0x10; i++)
1042         {
1043             int j;
1044             if (((ScriptCache *)*psc)->page[i])
1045                 for (j = 0; j < GLYPH_MAX / GLYPH_BLOCK_SIZE; j++)
1046                     heap_free(((ScriptCache *)*psc)->page[i]->glyphs[j]);
1047             heap_free(((ScriptCache *)*psc)->page[i]);
1048         }
1049         heap_free(((ScriptCache *)*psc)->GSUB_Table);
1050         heap_free(((ScriptCache *)*psc)->GDEF_Table);
1051         heap_free(((ScriptCache *)*psc)->CMAP_Table);
1052         heap_free(((ScriptCache *)*psc)->GPOS_Table);
1053         for (i = 0; i < ((ScriptCache *)*psc)->script_count; i++)
1054         {
1055             int j;
1056             for (j = 0; j < ((ScriptCache *)*psc)->scripts[i].language_count; j++)
1057             {
1058                 int k;
1059                 for (k = 0; k < ((ScriptCache *)*psc)->scripts[i].languages[j].feature_count; k++)
1060                     heap_free(((ScriptCache *)*psc)->scripts[i].languages[j].features[k].lookups);
1061                 heap_free(((ScriptCache *)*psc)->scripts[i].languages[j].features);
1062             }
1063             heap_free(((ScriptCache *)*psc)->scripts[i].languages);
1064         }
1065         heap_free(((ScriptCache *)*psc)->scripts);
1066         heap_free(((ScriptCache *)*psc)->otm);
1067         heap_free(*psc);
1068         *psc = NULL;
1069     }
1070     return S_OK;
1071 }
1072
1073 /***********************************************************************
1074  *      ScriptGetProperties (USP10.@)
1075  *
1076  * Retrieve a list of script properties.
1077  *
1078  * PARAMS
1079  *  props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
1080  *  num   [I] Pointer to the number of scripts.
1081  *
1082  * RETURNS
1083  *  Success: S_OK
1084  *  Failure: Non-zero HRESULT value.
1085  *
1086  * NOTES
1087  *  Behaviour matches WinXP.
1088  */
1089 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
1090 {
1091     TRACE("(%p,%p)\n", props, num);
1092
1093     if (!props && !num) return E_INVALIDARG;
1094
1095     if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
1096     if (props) *props = script_props;
1097
1098     return S_OK;
1099 }
1100
1101 /***********************************************************************
1102  *      ScriptGetFontProperties (USP10.@)
1103  *
1104  * Get information on special glyphs.
1105  *
1106  * PARAMS
1107  *  hdc [I]   Device context.
1108  *  psc [I/O] Opaque pointer to a script cache.
1109  *  sfp [O]   Font properties structure.
1110  */
1111 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
1112 {
1113     HRESULT hr;
1114
1115     TRACE("%p,%p,%p\n", hdc, psc, sfp);
1116
1117     if (!sfp) return E_INVALIDARG;
1118     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1119
1120     if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
1121         return E_INVALIDARG;
1122
1123     get_cache_font_properties(sfp, *psc);
1124
1125     return S_OK;
1126 }
1127
1128 /***********************************************************************
1129  *      ScriptRecordDigitSubstitution (USP10.@)
1130  *
1131  *  Record digit substitution settings for a given locale.
1132  *
1133  *  PARAMS
1134  *   locale [I] Locale identifier.
1135  *   sds    [I] Structure to record substitution settings.
1136  *
1137  *  RETURNS
1138  *   Success: S_OK
1139  *   Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
1140  *
1141  *  SEE ALSO
1142  *   http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
1143  */
1144 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
1145 {
1146     DWORD plgid, sub;
1147
1148     TRACE("0x%x, %p\n", locale, sds);
1149
1150     /* This implementation appears to be correct for all languages, but it's
1151      * not clear if sds->DigitSubstitute is ever set to anything except
1152      * CONTEXT or NONE in reality */
1153
1154     if (!sds) return E_POINTER;
1155
1156     locale = ConvertDefaultLocale(locale);
1157
1158     if (!IsValidLocale(locale, LCID_INSTALLED))
1159         return E_INVALIDARG;
1160
1161     plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
1162     sds->TraditionalDigitLanguage = plgid;
1163
1164     if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
1165         sds->NationalDigitLanguage = plgid;
1166     else
1167         sds->NationalDigitLanguage = LANG_ENGLISH;
1168
1169     if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
1170                         (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
1171
1172     switch (sub)
1173     {
1174     case 0:
1175         if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
1176             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
1177         else
1178             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
1179         break;
1180     case 1:
1181         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
1182         break;
1183     case 2:
1184         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
1185         break;
1186     default:
1187         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
1188         break;
1189     }
1190
1191     sds->dwReserved = 0;
1192     return S_OK;
1193 }
1194
1195 /***********************************************************************
1196  *      ScriptApplyDigitSubstitution (USP10.@)
1197  *
1198  *  Apply digit substitution settings.
1199  *
1200  *  PARAMS
1201  *   sds [I] Structure with recorded substitution settings.
1202  *   sc  [I] Script control structure.
1203  *   ss  [I] Script state structure.
1204  *
1205  *  RETURNS
1206  *   Success: S_OK
1207  *   Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
1208  */
1209 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds,
1210                                             SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
1211 {
1212     SCRIPT_DIGITSUBSTITUTE psds;
1213
1214     TRACE("%p, %p, %p\n", sds, sc, ss);
1215
1216     if (!sc || !ss) return E_POINTER;
1217     if (!sds)
1218     {
1219         sds = &psds;
1220         if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
1221             return E_INVALIDARG;
1222     }
1223
1224     sc->uDefaultLanguage = LANG_ENGLISH;
1225     sc->fContextDigits = 0;
1226     ss->fDigitSubstitute = 0;
1227
1228     switch (sds->DigitSubstitute) {
1229         case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
1230         case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
1231         case SCRIPT_DIGITSUBSTITUTE_NONE:
1232         case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
1233             return S_OK;
1234         default:
1235             return E_INVALIDARG;
1236     }
1237 }
1238
1239 static inline BOOL is_indic(WORD script)
1240 {
1241     return (script >= Script_Devanagari && script <= Script_Malayalam_Numeric);
1242 }
1243
1244 static inline WORD base_indic(WORD script)
1245 {
1246     switch (script)
1247     {
1248         case Script_Devanagari:
1249         case Script_Devanagari_Numeric: return Script_Devanagari;
1250         case Script_Bengali:
1251         case Script_Bengali_Numeric:
1252         case Script_Bengali_Currency: return Script_Bengali;
1253         case Script_Gurmukhi:
1254         case Script_Gurmukhi_Numeric: return Script_Gurmukhi;
1255         case Script_Gujarati:
1256         case Script_Gujarati_Numeric:
1257         case Script_Gujarati_Currency: return Script_Gujarati;
1258         case Script_Oriya:
1259         case Script_Oriya_Numeric: return Script_Oriya;
1260         case Script_Tamil:
1261         case Script_Tamil_Numeric: return Script_Tamil;
1262         case Script_Telugu:
1263         case Script_Telugu_Numeric: return Script_Telugu;
1264         case Script_Kannada:
1265         case Script_Kannada_Numeric: return Script_Kannada;
1266         case Script_Malayalam:
1267         case Script_Malayalam_Numeric: return Script_Malayalam;
1268         default:
1269             return -1;
1270     };
1271 }
1272
1273 /***********************************************************************
1274  *      ScriptItemizeOpenType (USP10.@)
1275  *
1276  * Split a Unicode string into shapeable parts.
1277  *
1278  * PARAMS
1279  *  pwcInChars  [I] String to split.
1280  *  cInChars    [I] Number of characters in pwcInChars.
1281  *  cMaxItems   [I] Maximum number of items to return.
1282  *  psControl   [I] Pointer to a SCRIPT_CONTROL structure.
1283  *  psState     [I] Pointer to a SCRIPT_STATE structure.
1284  *  pItems      [O] Buffer to receive SCRIPT_ITEM structures.
1285  *  pScriptTags [O] Buffer to receive OPENTYPE_TAGs.
1286  *  pcItems     [O] Number of script items returned.
1287  *
1288  * RETURNS
1289  *  Success: S_OK
1290  *  Failure: Non-zero HRESULT value.
1291  */
1292 HRESULT WINAPI ScriptItemizeOpenType(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
1293                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
1294                              SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
1295 {
1296
1297 #define Numeric_space 0x0020
1298 #define ZWNJ 0x200C
1299 #define ZWJ  0x200D
1300
1301     int   cnt = 0, index = 0, str = 0;
1302     int   New_Script = -1;
1303     int   i;
1304     WORD  *levels = NULL;
1305     WORD  *strength = NULL;
1306     WORD  *scripts = NULL;
1307     WORD  baselevel = 0;
1308     BOOL  new_run;
1309     WORD  last_indic = -1;
1310     WORD layoutRTL = 0;
1311     BOOL forceLevels = FALSE;
1312     INT consumed = 0;
1313
1314     TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems,
1315           psControl, psState, pItems, pcItems);
1316
1317     if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
1318         return E_INVALIDARG;
1319
1320     scripts = heap_alloc(cInChars * sizeof(WORD));
1321     if (!scripts)
1322         return E_OUTOFMEMORY;
1323
1324     for (i = 0; i < cInChars; i++)
1325     {
1326         if (consumed <= 0)
1327         {
1328             scripts[i] = get_char_script(pwcInChars,i,cInChars,&consumed);
1329             consumed --;
1330         }
1331         else
1332         {
1333             scripts[i] = scripts[i-1];
1334             consumed --;
1335         }
1336         /* Devanagari danda (U+0964) and double danda (U+0965) are used for
1337            all Indic scripts */
1338         if ((pwcInChars[i] == 0x964 || pwcInChars[i] ==0x965) && last_indic > 0)
1339             scripts[i] = last_indic;
1340         else if (is_indic(scripts[i]))
1341             last_indic = base_indic(scripts[i]);
1342
1343         /* Some unicode points (Zero Width Space U+200B -
1344            Right-to-Left Mark U+200F) will force us into bidi mode */
1345         if (!forceLevels && pwcInChars[i] >= 0x200B && pwcInChars[i] <= 0x200F)
1346             forceLevels = TRUE;
1347
1348         /* Diacritical marks merge with other scripts */
1349         if (scripts[i] == Script_Diacritical && i > 0)
1350                 scripts[i] = scripts[i-1];
1351     }
1352
1353     for (i = 0; i < cInChars; i++)
1354     {
1355         /* Joiners get merged preferencially right */
1356         if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ))
1357         {
1358             int j;
1359             if (i+1 == cInChars)
1360                 scripts[i] = scripts[i-1];
1361             else
1362             {
1363                 for (j = i+1; j < cInChars; j++)
1364                 {
1365                     if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ && pwcInChars[j] != Numeric_space)
1366                     {
1367                         scripts[i] = scripts[j];
1368                         break;
1369                     }
1370                 }
1371             }
1372         }
1373     }
1374
1375     if (psState && psControl)
1376     {
1377         levels = heap_alloc_zero(cInChars * sizeof(WORD));
1378         if (!levels)
1379         {
1380             heap_free(scripts);
1381             return E_OUTOFMEMORY;
1382         }
1383
1384         BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels);
1385         baselevel = levels[0];
1386         for (i = 0; i < cInChars; i++)
1387             if (levels[i]!=levels[0])
1388                 break;
1389         if (i >= cInChars && !odd(baselevel) && !odd(psState->uBidiLevel) && !forceLevels)
1390         {
1391             heap_free(levels);
1392             levels = NULL;
1393         }
1394         else
1395         {
1396             BOOL inNumber = FALSE;
1397             static WCHAR math_punc[] = {'#','$','%','+',',','-','.','/',':',0x2212, 0x2044, 0x00a0,0};
1398
1399             strength = heap_alloc_zero(cInChars * sizeof(WORD));
1400             if (!strength)
1401             {
1402                 heap_free(scripts);
1403                 heap_free(levels);
1404                 return E_OUTOFMEMORY;
1405             }
1406             BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
1407
1408             /* We currently mis-level leading Diacriticals */
1409             if (scripts[0] == Script_Diacritical)
1410                 for (i = 0; i < cInChars && scripts[0] == Script_Diacritical; i++)
1411                 {
1412                     levels[i] = odd(levels[i])?levels[i]+1:levels[i];
1413                     strength[i] = BIDI_STRONG;
1414                 }
1415
1416             for (i = 0; i < cInChars; i++)
1417             {
1418                 /* Script_Numeric and select puncuation at level 0 get bumped to level 2 */
1419                 if ((levels[i] == 0 || (odd(psState->uBidiLevel) && levels[i] == psState->uBidiLevel+1)) && inNumber && strchrW(math_punc,pwcInChars[i]))
1420                 {
1421                     scripts[i] = Script_Numeric;
1422                     levels[i] = 2;
1423                 }
1424                 else if ((levels[i] == 0 || (odd(psState->uBidiLevel) && levels[i] == psState->uBidiLevel+1)) && scripts[i] == Script_Numeric)
1425                 {
1426                     levels[i] = 2;
1427                     inNumber = TRUE;
1428                 }
1429                 else
1430                     inNumber = FALSE;
1431
1432                 /* Joiners get merged preferencially right */
1433                 if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ))
1434                 {
1435                     int j;
1436                     if (i+1 == cInChars && levels[i-1] == levels[i])
1437                         strength[i] = strength[i-1];
1438                     else
1439                         for (j = i+1; j < cInChars && levels[i] == levels[j]; j++)
1440                             if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ && pwcInChars[j] != Numeric_space)
1441                             {
1442                                 strength[i] = strength[j];
1443                                 break;
1444                             }
1445                 }
1446             }
1447             if (psControl->fMergeNeutralItems)
1448             {
1449                 /* Merge the neutrals */
1450                 for (i = 0; i < cInChars; i++)
1451                 {
1452                     if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
1453                     {
1454                         int j;
1455                         for (j = i; j > 0; j--)
1456                         {
1457                             if (levels[i] != levels[j])
1458                                 break;
1459                             if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
1460                             {
1461                                 scripts[i] = scripts[j];
1462                                 strength[i] = strength[j];
1463                                 break;
1464                             }
1465                         }
1466                     }
1467                     /* Try going the other way */
1468                     if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
1469                     {
1470                         int j;
1471                         for (j = i; j < cInChars; j++)
1472                         {
1473                             if (levels[i] != levels[j])
1474                                 break;
1475                             if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
1476                             {
1477                                 scripts[i] = scripts[j];
1478                                 strength[i] = strength[j];
1479                                 break;
1480                             }
1481                         }
1482                     }
1483                 }
1484             }
1485         }
1486     }
1487
1488     while ((!levels || (levels && levels[cnt+1] == levels[0])) && (pwcInChars[cnt] == Numeric_space) && cnt < cInChars)
1489         cnt++;
1490
1491     if (cnt == cInChars) /* All Spaces */
1492     {
1493         cnt = 0;
1494         New_Script = scripts[cnt];
1495     }
1496
1497     pItems[index].iCharPos = 0;
1498     pItems[index].a = scriptInformation[scripts[cnt]].a;
1499     pScriptTags[index] = scriptInformation[scripts[cnt]].scriptTag;
1500
1501     if (strength && strength[cnt] == BIDI_STRONG)
1502         str = strength[cnt];
1503     else if (strength)
1504         str = strength[0];
1505
1506     cnt = 0;
1507
1508     if (levels)
1509     {
1510         if (strength[cnt] == BIDI_STRONG)
1511             layoutRTL = (odd(levels[cnt]))?1:0;
1512         else
1513             layoutRTL = (psState->uBidiLevel || odd(levels[cnt]))?1:0;
1514         pItems[index].a.fRTL = odd(levels[cnt]);
1515         pItems[index].a.fLayoutRTL = layoutRTL;
1516         pItems[index].a.s.uBidiLevel = levels[cnt];
1517     }
1518     else if (!pItems[index].a.s.uBidiLevel)
1519     {
1520         layoutRTL = (odd(baselevel))?1:0;
1521         pItems[index].a.s.uBidiLevel = baselevel;
1522         pItems[index].a.fLayoutRTL = odd(baselevel);
1523         pItems[index].a.fRTL = odd(baselevel);
1524     }
1525
1526     TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
1527           levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
1528           pItems[index].iCharPos);
1529
1530     for (cnt=1; cnt < cInChars; cnt++)
1531     {
1532         if(pwcInChars[cnt] != Numeric_space)
1533             New_Script = scripts[cnt];
1534         else if (levels)
1535         {
1536             int j = 1;
1537             while (cnt + j < cInChars - 1 && pwcInChars[cnt+j] == Numeric_space && levels[cnt] == levels[cnt+j])
1538                 j++;
1539             if (cnt + j < cInChars && levels[cnt] == levels[cnt+j])
1540                 New_Script = scripts[cnt+j];
1541             else
1542                 New_Script = scripts[cnt];
1543         }
1544
1545         new_run = FALSE;
1546         /* merge space strengths*/
1547         if (strength && strength[cnt] == BIDI_STRONG && str != BIDI_STRONG && New_Script == pItems[index].a.eScript)
1548             str = BIDI_STRONG;
1549
1550         if (strength && strength[cnt] == BIDI_NEUTRAL && str == BIDI_STRONG && pwcInChars[cnt] != Numeric_space && New_Script == pItems[index].a.eScript)
1551             str = BIDI_NEUTRAL;
1552
1553         /* changes in level */
1554         if (levels && (levels[cnt] != pItems[index].a.s.uBidiLevel))
1555         {
1556             TRACE("Level break(%i/%i)\n",pItems[index].a.s.uBidiLevel,levels[cnt]);
1557             new_run = TRUE;
1558         }
1559         /* changes in strength */
1560         else if (strength && pwcInChars[cnt] != Numeric_space && str != strength[cnt])
1561         {
1562             TRACE("Strength break (%i/%i)\n",str,strength[cnt]);
1563             new_run = TRUE;
1564         }
1565         /* changes in script */
1566         else if (((pwcInChars[cnt] != Numeric_space) && (New_Script != -1) && (New_Script != pItems[index].a.eScript)) || (New_Script == Script_Control))
1567         {
1568             TRACE("Script break(%i/%i)\n",pItems[index].a.eScript,New_Script);
1569             new_run = TRUE;
1570         }
1571
1572         if (!new_run && strength && str == BIDI_STRONG)
1573         {
1574             layoutRTL = odd(levels[cnt])?1:0;
1575             pItems[index].a.fLayoutRTL = layoutRTL;
1576         }
1577
1578         if (new_run)
1579         {
1580             TRACE("New_Level = %i, New_Strength = %i, New_Script=%d, eScript=%d\n", levels?levels[cnt]:-1, strength?strength[cnt]:str, New_Script, pItems[index].a.eScript);
1581
1582             index++;
1583             if  (index+1 > cMaxItems)
1584                 return E_OUTOFMEMORY;
1585
1586             if (strength)
1587                 str = strength[cnt];
1588
1589             pItems[index].iCharPos = cnt;
1590             memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
1591
1592             pItems[index].a = scriptInformation[New_Script].a;
1593             pScriptTags[index] = scriptInformation[New_Script].scriptTag;
1594             if (levels)
1595             {
1596                 if (levels[cnt] == 0)
1597                     layoutRTL = 0;
1598                 else
1599                     layoutRTL = (layoutRTL || odd(levels[cnt]))?1:0;
1600                 pItems[index].a.fRTL = odd(levels[cnt]);
1601                 pItems[index].a.fLayoutRTL = layoutRTL;
1602                 pItems[index].a.s.uBidiLevel = levels[cnt];
1603             }
1604             else if (!pItems[index].a.s.uBidiLevel)
1605             {
1606                 pItems[index].a.s.uBidiLevel = baselevel;
1607                 pItems[index].a.fLayoutRTL = layoutRTL;
1608                 pItems[index].a.fRTL = odd(baselevel);
1609             }
1610
1611             TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
1612         }
1613     }
1614
1615     /* While not strictly necessary according to the spec, make sure the n+1
1616      * item is set up to prevent random behaviour if the caller erroneously
1617      * checks the n+1 structure                                              */
1618     index++;
1619     memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
1620
1621     TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
1622
1623     /*  Set one SCRIPT_STATE item being returned  */
1624     if  (index + 1 > cMaxItems) return E_OUTOFMEMORY;
1625     if (pcItems) *pcItems = index;
1626
1627     /*  Set SCRIPT_ITEM                                     */
1628     pItems[index].iCharPos = cnt;         /* the last item contains the ptr to the lastchar */
1629     heap_free(levels);
1630     heap_free(strength);
1631     heap_free(scripts);
1632     return S_OK;
1633 }
1634
1635 /***********************************************************************
1636  *      ScriptItemize (USP10.@)
1637  *
1638  * Split a Unicode string into shapeable parts.
1639  *
1640  * PARAMS
1641  *  pwcInChars [I] String to split.
1642  *  cInChars   [I] Number of characters in pwcInChars.
1643  *  cMaxItems  [I] Maximum number of items to return.
1644  *  psControl  [I] Pointer to a SCRIPT_CONTROL structure.
1645  *  psState    [I] Pointer to a SCRIPT_STATE structure.
1646  *  pItems     [O] Buffer to receive SCRIPT_ITEM structures.
1647  *  pcItems    [O] Number of script items returned.
1648  *
1649  * RETURNS
1650  *  Success: S_OK
1651  *  Failure: Non-zero HRESULT value.
1652  */
1653 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
1654                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
1655                              SCRIPT_ITEM *pItems, int *pcItems)
1656 {
1657     OPENTYPE_TAG *discarded_tags;
1658     HRESULT res;
1659
1660     discarded_tags = heap_alloc(cMaxItems * sizeof(OPENTYPE_TAG));
1661     if (!discarded_tags)
1662         return E_OUTOFMEMORY;
1663     res = ScriptItemizeOpenType(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, discarded_tags, pcItems);
1664     heap_free(discarded_tags);
1665     return res;
1666 }
1667
1668 static inline int getGivenTabWidth(ScriptCache *psc, SCRIPT_TABDEF *pTabdef, int charPos, int current_x)
1669 {
1670     int defWidth;
1671     int cTabStops=0;
1672     INT *lpTabPos = NULL;
1673     INT nTabOrg = 0;
1674     INT x = 0;
1675
1676     if (pTabdef)
1677         lpTabPos = pTabdef->pTabStops;
1678
1679     if (pTabdef && pTabdef->iTabOrigin)
1680     {
1681         if (pTabdef->iScale)
1682             nTabOrg = (pTabdef->iTabOrigin * pTabdef->iScale)/4;
1683         else
1684             nTabOrg = pTabdef->iTabOrigin * psc->tm.tmAveCharWidth;
1685     }
1686
1687     if (pTabdef)
1688         cTabStops = pTabdef->cTabStops;
1689
1690     if (cTabStops == 1)
1691     {
1692         if (pTabdef->iScale)
1693             defWidth = ((pTabdef->pTabStops[0])*pTabdef->iScale) / 4;
1694         else
1695             defWidth = (pTabdef->pTabStops[0])*psc->tm.tmAveCharWidth;
1696         cTabStops = 0;
1697     }
1698     else
1699         defWidth = 8 * psc->tm.tmAveCharWidth;
1700
1701     for (; cTabStops>0 ; lpTabPos++, cTabStops--)
1702     {
1703         int position = *lpTabPos;
1704         if (position < 0)
1705             position = -1 * position;
1706         if (pTabdef->iScale)
1707             position = (position * pTabdef->iScale) / 4;
1708         else
1709             position = position * psc->tm.tmAveCharWidth;
1710
1711         if( nTabOrg + position > current_x)
1712         {
1713             if( *lpTabPos >= 0)
1714             {
1715                 /* a left aligned tab */
1716                 x = (nTabOrg + *lpTabPos) - current_x;
1717                 break;
1718             }
1719             else
1720             {
1721                 FIXME("Negative tabstop\n");
1722                 break;
1723             }
1724         }
1725     }
1726     if ((!cTabStops) && (defWidth > 0))
1727         x =((((current_x - nTabOrg) / defWidth)+1) * defWidth) - current_x;
1728     else if ((!cTabStops) && (defWidth < 0))
1729         FIXME("TODO: Negative defWidth\n");
1730
1731     return x;
1732 }
1733
1734 /***********************************************************************
1735  * Helper function for ScriptStringAnalyse
1736  */
1737 static BOOL requires_fallback(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
1738                               const WCHAR *pwcInChars, int cChars )
1739 {
1740     /* FIXME: When to properly fallback is still a bit of a mystery */
1741     WORD *glyphs;
1742
1743     if (psa->fNoGlyphIndex)
1744         return FALSE;
1745
1746     if (init_script_cache(hdc, psc) != S_OK)
1747         return FALSE;
1748
1749     if (SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa) != S_OK)
1750         return TRUE;
1751
1752     glyphs = heap_alloc(sizeof(WORD) * cChars);
1753     if (!glyphs)
1754         return FALSE;
1755     if (ScriptGetCMap(hdc, psc, pwcInChars, cChars, 0, glyphs) != S_OK)
1756     {
1757         heap_free(glyphs);
1758         return TRUE;
1759     }
1760     heap_free(glyphs);
1761
1762     return FALSE;
1763 }
1764
1765 static void find_fallback_font(DWORD scriptid, LPWSTR FaceName)
1766 {
1767     HKEY hkey;
1768
1769     if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Uniscribe\\Fallback", &hkey))
1770     {
1771         static const WCHAR szFmt[] = {'%','x',0};
1772         WCHAR value[10];
1773         DWORD count = LF_FACESIZE * sizeof(WCHAR);
1774         DWORD type;
1775
1776         sprintfW(value, szFmt, scriptInformation[scriptid].scriptTag);
1777         if (RegQueryValueExW(hkey, value, 0, &type, (LPBYTE)FaceName, &count))
1778             lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
1779         RegCloseKey(hkey);
1780     }
1781     else
1782         lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
1783 }
1784
1785 /***********************************************************************
1786  *      ScriptStringAnalyse (USP10.@)
1787  *
1788  */
1789 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
1790                                    int cGlyphs, int iCharset, DWORD dwFlags,
1791                                    int iReqWidth, SCRIPT_CONTROL *psControl,
1792                                    SCRIPT_STATE *psState, const int *piDx,
1793                                    SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
1794                                    SCRIPT_STRING_ANALYSIS *pssa)
1795 {
1796     HRESULT hr = E_OUTOFMEMORY;
1797     StringAnalysis *analysis = NULL;
1798     SCRIPT_CONTROL sControl;
1799     SCRIPT_STATE sState;
1800     int i, num_items = 255;
1801     BYTE   *BidiLevel;
1802     WCHAR *iString = NULL;
1803
1804     TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
1805           hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
1806           psControl, psState, piDx, pTabdef, pbInClass, pssa);
1807
1808     if (iCharset != -1)
1809     {
1810         FIXME("Only Unicode strings are supported\n");
1811         return E_INVALIDARG;
1812     }
1813     if (cString < 1 || !pString) return E_INVALIDARG;
1814     if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
1815
1816     if (!(analysis = heap_alloc_zero(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
1817     if (!(analysis->pItem = heap_alloc_zero(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
1818
1819     /* FIXME: handle clipping */
1820     analysis->clip_len = cString;
1821     analysis->hdc = hdc;
1822     analysis->dwFlags = dwFlags;
1823
1824     if (psState)
1825         sState = *psState;
1826     else
1827         memset(&sState, 0, sizeof(SCRIPT_STATE));
1828
1829     if (psControl)
1830         sControl = *psControl;
1831     else
1832         memset(&sControl, 0, sizeof(SCRIPT_CONTROL));
1833
1834     if (dwFlags & SSA_PASSWORD)
1835     {
1836         iString = heap_alloc(sizeof(WCHAR)*cString);
1837         if (!iString)
1838         {
1839             hr = E_OUTOFMEMORY;
1840             goto error;
1841         }
1842         for (i = 0; i < cString; i++)
1843             iString[i] = *((const WCHAR *)pString);
1844         pString = iString;
1845     }
1846
1847     hr = ScriptItemize(pString, cString, num_items, &sControl, &sState, analysis->pItem,
1848                        &analysis->numItems);
1849
1850     if FAILED(hr)
1851     {
1852         if (hr == E_OUTOFMEMORY)
1853             hr = E_INVALIDARG;
1854         goto error;
1855     }
1856
1857     /* set back to out of memory for default goto error behaviour */
1858     hr = E_OUTOFMEMORY;
1859
1860     if (dwFlags & SSA_BREAK)
1861     {
1862         if ((analysis->logattrs = heap_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
1863         {
1864             for (i = 0; i < analysis->numItems; i++)
1865                 ScriptBreak(&((LPWSTR)pString)[analysis->pItem[i].iCharPos], analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos, &analysis->pItem[i].a, &analysis->logattrs[analysis->pItem[i].iCharPos]);
1866         }
1867         else
1868             goto error;
1869     }
1870
1871     if (!(analysis->logical2visual = heap_alloc_zero(sizeof(int) * analysis->numItems)))
1872         goto error;
1873     if (!(BidiLevel = heap_alloc_zero(analysis->numItems)))
1874         goto error;
1875
1876     if (dwFlags & SSA_GLYPHS)
1877     {
1878         int tab_x = 0;
1879         if (!(analysis->glyphs = heap_alloc_zero(sizeof(StringGlyphs) * analysis->numItems)))
1880         {
1881             heap_free(BidiLevel);
1882             goto error;
1883         }
1884
1885         for (i = 0; i < analysis->numItems; i++)
1886         {
1887             SCRIPT_CACHE *sc = (SCRIPT_CACHE*)&analysis->glyphs[i].sc;
1888             int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1889             int numGlyphs = 1.5 * cChar + 16;
1890             WORD *glyphs = heap_alloc_zero(sizeof(WORD) * numGlyphs);
1891             WORD *pwLogClust = heap_alloc_zero(sizeof(WORD) * cChar);
1892             int *piAdvance = heap_alloc_zero(sizeof(int) * numGlyphs);
1893             SCRIPT_VISATTR *psva = heap_alloc_zero(sizeof(SCRIPT_VISATTR) * numGlyphs);
1894             GOFFSET *pGoffset = heap_alloc_zero(sizeof(GOFFSET) * numGlyphs);
1895             ABC *abc = heap_alloc_zero(sizeof(ABC));
1896             int numGlyphsReturned;
1897             HFONT originalFont = 0x0;
1898
1899             /* FIXME: non unicode strings */
1900             const WCHAR* pStr = (const WCHAR*)pString;
1901             analysis->glyphs[i].fallbackFont = NULL;
1902
1903             if (!glyphs || !pwLogClust || !piAdvance || !psva || !pGoffset || !abc)
1904             {
1905                 heap_free (BidiLevel);
1906                 heap_free (glyphs);
1907                 heap_free (pwLogClust);
1908                 heap_free (piAdvance);
1909                 heap_free (psva);
1910                 heap_free (pGoffset);
1911                 heap_free (abc);
1912                 hr = E_OUTOFMEMORY;
1913                 goto error;
1914             }
1915
1916             if ((dwFlags & SSA_FALLBACK) && requires_fallback(hdc, sc, &analysis->pItem[i].a, &pStr[analysis->pItem[i].iCharPos], cChar))
1917             {
1918                 LOGFONTW lf;
1919                 GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), & lf);
1920                 lf.lfCharSet = scriptInformation[analysis->pItem[i].a.eScript].props.bCharSet;
1921                 lf.lfFaceName[0] = 0;
1922                 find_fallback_font(analysis->pItem[i].a.eScript, lf.lfFaceName);
1923                 if (lf.lfFaceName[0])
1924                 {
1925                     analysis->glyphs[i].fallbackFont = CreateFontIndirectW(&lf);
1926                     if (analysis->glyphs[i].fallbackFont)
1927                     {
1928                         ScriptFreeCache(sc);
1929                         originalFont = SelectObject(hdc, analysis->glyphs[i].fallbackFont);
1930                     }
1931                 }
1932             }
1933
1934             /* FIXME: When we properly shape Hangul remove this check */
1935             if ((dwFlags & SSA_LINK) && !analysis->glyphs[i].fallbackFont && analysis->pItem[i].a.eScript == Script_Hangul)
1936                 analysis->pItem[i].a.fNoGlyphIndex = TRUE;
1937
1938             if ((dwFlags & SSA_LINK) && !analysis->glyphs[i].fallbackFont && !scriptInformation[analysis->pItem[i].a.eScript].props.fComplex)
1939                 analysis->pItem[i].a.fNoGlyphIndex = TRUE;
1940
1941             hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
1942                              cChar, numGlyphs, &analysis->pItem[i].a,
1943                              glyphs, pwLogClust, psva, &numGlyphsReturned);
1944             hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
1945                              piAdvance, pGoffset, abc);
1946             if (originalFont)
1947                 SelectObject(hdc,originalFont);
1948
1949             if (dwFlags & SSA_TAB)
1950             {
1951                 int tabi = 0;
1952                 for (tabi = 0; tabi < cChar; tabi++)
1953                 {
1954                     if (pStr[analysis->pItem[i].iCharPos+tabi] == 0x0009)
1955                         piAdvance[tabi] = getGivenTabWidth(analysis->glyphs[i].sc, pTabdef, analysis->pItem[i].iCharPos+tabi, tab_x);
1956                     tab_x+=piAdvance[tabi];
1957                 }
1958             }
1959
1960             analysis->glyphs[i].numGlyphs = numGlyphsReturned;
1961             analysis->glyphs[i].glyphs = glyphs;
1962             analysis->glyphs[i].pwLogClust = pwLogClust;
1963             analysis->glyphs[i].piAdvance = piAdvance;
1964             analysis->glyphs[i].psva = psva;
1965             analysis->glyphs[i].pGoffset = pGoffset;
1966             analysis->glyphs[i].abc = abc;
1967             analysis->glyphs[i].iMaxPosX= -1;
1968
1969             BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1970         }
1971     }
1972     else
1973     {
1974         for (i = 0; i < analysis->numItems; i++)
1975             BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1976     }
1977
1978     ScriptLayout(analysis->numItems, BidiLevel, NULL, analysis->logical2visual);
1979     heap_free(BidiLevel);
1980
1981     *pssa = analysis;
1982     heap_free(iString);
1983     return S_OK;
1984
1985 error:
1986     heap_free(iString);
1987     heap_free(analysis->glyphs);
1988     heap_free(analysis->logattrs);
1989     heap_free(analysis->pItem);
1990     heap_free(analysis->logical2visual);
1991     heap_free(analysis);
1992     return hr;
1993 }
1994
1995 static inline BOOL does_glyph_start_cluster(const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cChars, int glyph, int direction)
1996 {
1997     if (pva[glyph].fClusterStart)
1998         return TRUE;
1999     if (USP10_FindGlyphInLogClust(pwLogClust, cChars, glyph) >= 0)
2000         return TRUE;
2001
2002     return FALSE;
2003 }
2004
2005
2006 static HRESULT SS_ItemOut( SCRIPT_STRING_ANALYSIS ssa,
2007                            int iX,
2008                            int iY,
2009                            int iItem,
2010                            int cStart,
2011                            int cEnd,
2012                            UINT uOptions,
2013                            const RECT *prc,
2014                            BOOL fSelected,
2015                            BOOL fDisabled)
2016 {
2017     StringAnalysis *analysis;
2018     int off_x = 0;
2019     HRESULT hr;
2020     COLORREF BkColor = 0x0;
2021     COLORREF TextColor = 0x0;
2022     INT BkMode = 0;
2023     INT runStart, runEnd;
2024     INT iGlyph, cGlyphs;
2025     HFONT oldFont = 0x0;
2026     RECT  crc;
2027     int i;
2028
2029     TRACE("(%p,%d,%d,%d,%d,%d, 0x%1x, %d, %d)\n",
2030          ssa, iX, iY, iItem, cStart, cEnd, uOptions, fSelected, fDisabled);
2031
2032     if (!(analysis = ssa)) return E_INVALIDARG;
2033
2034     if ((cStart >= 0 && analysis->pItem[iItem+1].iCharPos <= cStart) ||
2035          (cEnd >= 0 && analysis->pItem[iItem].iCharPos >= cEnd))
2036             return S_OK;
2037
2038     CopyRect(&crc,prc);
2039     if (fSelected)
2040     {
2041         BkMode = GetBkMode(analysis->hdc);
2042         SetBkMode( analysis->hdc, OPAQUE);
2043         BkColor = GetBkColor(analysis->hdc);
2044         SetBkColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHT));
2045         if (!fDisabled)
2046         {
2047             TextColor = GetTextColor(analysis->hdc);
2048             SetTextColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2049         }
2050     }
2051     if (analysis->glyphs[iItem].fallbackFont)
2052         oldFont = SelectObject(analysis->hdc, analysis->glyphs[iItem].fallbackFont);
2053
2054     if (cStart >= 0 && analysis->pItem[iItem+1].iCharPos > cStart && analysis->pItem[iItem].iCharPos <= cStart)
2055         runStart = cStart - analysis->pItem[iItem].iCharPos;
2056     else
2057         runStart =  0;
2058     if (cEnd >= 0 && analysis->pItem[iItem+1].iCharPos > cEnd && analysis->pItem[iItem].iCharPos <= cEnd)
2059         runEnd = (cEnd-1) - analysis->pItem[iItem].iCharPos;
2060     else
2061         runEnd = (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos) - 1;
2062
2063     if (analysis->pItem[iItem].a.fRTL)
2064     {
2065         if (cEnd >= 0 && cEnd < analysis->pItem[iItem+1].iCharPos)
2066             ScriptStringCPtoX(ssa, cEnd, FALSE, &off_x);
2067         else
2068             ScriptStringCPtoX(ssa, analysis->pItem[iItem+1].iCharPos-1, TRUE, &off_x);
2069         crc.left = iX + off_x;
2070     }
2071     else
2072     {
2073         if (cStart >=0 && runStart)
2074             ScriptStringCPtoX(ssa, cStart, FALSE, &off_x);
2075         else
2076             ScriptStringCPtoX(ssa, analysis->pItem[iItem].iCharPos, FALSE, &off_x);
2077         crc.left = iX + off_x;
2078     }
2079
2080     if (analysis->pItem[iItem].a.fRTL)
2081         iGlyph = analysis->glyphs[iItem].pwLogClust[runEnd];
2082     else
2083         iGlyph = analysis->glyphs[iItem].pwLogClust[runStart];
2084
2085     if (analysis->pItem[iItem].a.fRTL)
2086         cGlyphs = analysis->glyphs[iItem].pwLogClust[runStart] - iGlyph;
2087     else
2088         cGlyphs = analysis->glyphs[iItem].pwLogClust[runEnd] - iGlyph;
2089
2090     cGlyphs++;
2091
2092     /* adjust for cluster glyphs when starting */
2093     if (analysis->pItem[iItem].a.fRTL)
2094         i = analysis->pItem[iItem+1].iCharPos - 1;
2095     else
2096         i = analysis->pItem[iItem].iCharPos;
2097
2098     for (; i >=analysis->pItem[iItem].iCharPos && i < analysis->pItem[iItem+1].iCharPos; (analysis->pItem[iItem].a.fRTL)?i--:i++)
2099     {
2100         if (analysis->glyphs[iItem].pwLogClust[i - analysis->pItem[iItem].iCharPos] == iGlyph)
2101         {
2102             if (analysis->pItem[iItem].a.fRTL)
2103                 ScriptStringCPtoX(ssa, i, TRUE, &off_x);
2104             else
2105                 ScriptStringCPtoX(ssa, i, FALSE, &off_x);
2106             break;
2107         }
2108     }
2109
2110     if (cEnd < 0 || scriptInformation[analysis->pItem[iItem].a.eScript].props.fNeedsCaretInfo)
2111     {
2112         INT direction;
2113         INT clust_glyph;
2114
2115         clust_glyph = iGlyph + cGlyphs;
2116         if (analysis->pItem[iItem].a.fRTL)
2117             direction = -1;
2118         else
2119             direction = 1;
2120
2121         while(clust_glyph < analysis->glyphs[iItem].numGlyphs &&
2122               !does_glyph_start_cluster(analysis->glyphs[iItem].psva, analysis->glyphs[iItem].pwLogClust, (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos), clust_glyph, direction))
2123         {
2124             cGlyphs++;
2125             clust_glyph++;
2126         }
2127     }
2128
2129     hr = ScriptTextOut(analysis->hdc,
2130                        (SCRIPT_CACHE *)&analysis->glyphs[iItem].sc, iX + off_x,
2131                        iY, uOptions, &crc, &analysis->pItem[iItem].a, NULL, 0,
2132                        &analysis->glyphs[iItem].glyphs[iGlyph], cGlyphs,
2133                        &analysis->glyphs[iItem].piAdvance[iGlyph], NULL,
2134                        &analysis->glyphs[iItem].pGoffset[iGlyph]);
2135
2136     TRACE("ScriptTextOut hr=%08x\n", hr);
2137
2138     if (fSelected)
2139     {
2140         SetBkColor(analysis->hdc, BkColor);
2141         SetBkMode( analysis->hdc, BkMode);
2142         if (!fDisabled)
2143             SetTextColor(analysis->hdc, TextColor);
2144     }
2145     if (analysis->glyphs[iItem].fallbackFont)
2146         SelectObject(analysis->hdc, oldFont);
2147
2148     return hr;
2149 }
2150
2151 /***********************************************************************
2152  *      ScriptStringOut (USP10.@)
2153  *
2154  * This function takes the output of ScriptStringAnalyse and joins the segments
2155  * of glyphs and passes the resulting string to ScriptTextOut.  ScriptStringOut
2156  * only processes glyphs.
2157  *
2158  * Parameters:
2159  *  ssa       [I] buffer to hold the analysed string components
2160  *  iX        [I] X axis displacement for output
2161  *  iY        [I] Y axis displacement for output
2162  *  uOptions  [I] flags controlling output processing
2163  *  prc       [I] rectangle coordinates
2164  *  iMinSel   [I] starting pos for substringing output string
2165  *  iMaxSel   [I] ending pos for substringing output string
2166  *  fDisabled [I] controls text highlighting
2167  *
2168  *  RETURNS
2169  *   Success: S_OK
2170  *   Failure: is the value returned by ScriptTextOut
2171  */
2172 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
2173                                int iX,
2174                                int iY,
2175                                UINT uOptions,
2176                                const RECT *prc,
2177                                int iMinSel,
2178                                int iMaxSel,
2179                                BOOL fDisabled)
2180 {
2181     StringAnalysis *analysis;
2182     int   item;
2183     HRESULT hr;
2184
2185     TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
2186          ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
2187
2188     if (!(analysis = ssa)) return E_INVALIDARG;
2189     if (!(analysis->dwFlags & SSA_GLYPHS)) return E_INVALIDARG;
2190
2191     for (item = 0; item < analysis->numItems; item++)
2192     {
2193         hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], -1, -1, uOptions, prc, FALSE, fDisabled);
2194         if (FAILED(hr))
2195             return hr;
2196     }
2197
2198     if (iMinSel < iMaxSel && (iMinSel > 0 || iMaxSel > 0))
2199     {
2200         if (iMaxSel > 0 &&  iMinSel < 0)
2201             iMinSel = 0;
2202         for (item = 0; item < analysis->numItems; item++)
2203         {
2204             hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], iMinSel, iMaxSel, uOptions, prc, TRUE, fDisabled);
2205             if (FAILED(hr))
2206                 return hr;
2207         }
2208     }
2209
2210     return S_OK;
2211 }
2212
2213 /***********************************************************************
2214  *      ScriptStringCPtoX (USP10.@)
2215  *
2216  */
2217 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
2218 {
2219     int item;
2220     int runningX = 0;
2221     StringAnalysis* analysis = ssa;
2222
2223     TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
2224
2225     if (!ssa || !pX) return S_FALSE;
2226     if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
2227
2228     /* icp out of range */
2229     if(icp < 0)
2230     {
2231         analysis->invalid = TRUE;
2232         return E_INVALIDARG;
2233     }
2234
2235     for(item=0; item<analysis->numItems; item++)
2236     {
2237         int CP, i;
2238         int offset;
2239
2240         i = analysis->logical2visual[item];
2241         CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
2242         /* initialize max extents for uninitialized runs */
2243         if (analysis->glyphs[i].iMaxPosX == -1)
2244         {
2245             if (analysis->pItem[i].a.fRTL)
2246                 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2247                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2248                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2249             else
2250                 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2251                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2252                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2253         }
2254
2255         if (icp >= analysis->pItem[i+1].iCharPos || icp < analysis->pItem[i].iCharPos)
2256         {
2257             runningX += analysis->glyphs[i].iMaxPosX;
2258             continue;
2259         }
2260
2261         icp -= analysis->pItem[i].iCharPos;
2262         ScriptCPtoX(icp, fTrailing, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2263                     analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2264                     &analysis->pItem[i].a, &offset);
2265         runningX += offset;
2266
2267         *pX = runningX;
2268         return S_OK;
2269     }
2270
2271     /* icp out of range */
2272     analysis->invalid = TRUE;
2273     return E_INVALIDARG;
2274 }
2275
2276 /***********************************************************************
2277  *      ScriptStringXtoCP (USP10.@)
2278  *
2279  */
2280 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing)
2281 {
2282     StringAnalysis* analysis = ssa;
2283     int item;
2284
2285     TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
2286
2287     if (!ssa || !piCh || !piTrailing) return S_FALSE;
2288     if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
2289
2290     /* out of range */
2291     if(iX < 0)
2292     {
2293         if (analysis->pItem[0].a.fRTL)
2294         {
2295             *piCh = 1;
2296             *piTrailing = FALSE;
2297         }
2298         else
2299         {
2300             *piCh = -1;
2301             *piTrailing = TRUE;
2302         }
2303         return S_OK;
2304     }
2305
2306     for(item=0; item<analysis->numItems; item++)
2307     {
2308         int i;
2309         int CP;
2310
2311         for (i = 0; i < analysis->numItems && analysis->logical2visual[i] != item; i++)
2312         /* nothing */;
2313
2314         CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
2315         /* initialize max extents for uninitialized runs */
2316         if (analysis->glyphs[i].iMaxPosX == -1)
2317         {
2318             if (analysis->pItem[i].a.fRTL)
2319                 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2320                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2321                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2322             else
2323                 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2324                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2325                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
2326         }
2327
2328         if (iX > analysis->glyphs[i].iMaxPosX)
2329         {
2330             iX -= analysis->glyphs[i].iMaxPosX;
2331             continue;
2332         }
2333
2334         ScriptXtoCP(iX, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
2335                     analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
2336                     &analysis->pItem[i].a, piCh, piTrailing);
2337         *piCh += analysis->pItem[i].iCharPos;
2338
2339         return S_OK;
2340     }
2341
2342     /* out of range */
2343     *piCh = analysis->pItem[analysis->numItems].iCharPos;
2344     *piTrailing = FALSE;
2345
2346     return S_OK;
2347 }
2348
2349
2350 /***********************************************************************
2351  *      ScriptStringFree (USP10.@)
2352  *
2353  * Free a string analysis.
2354  *
2355  * PARAMS
2356  *  pssa [I] string analysis.
2357  *
2358  * RETURNS
2359  *  Success: S_OK
2360  *  Failure: Non-zero HRESULT value.
2361  */
2362 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
2363 {
2364     StringAnalysis* analysis;
2365     BOOL invalid;
2366     int i;
2367
2368     TRACE("(%p)\n", pssa);
2369
2370     if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
2371
2372     invalid = analysis->invalid;
2373
2374     if (analysis->glyphs)
2375     {
2376         for (i = 0; i < analysis->numItems; i++)
2377         {
2378             heap_free(analysis->glyphs[i].glyphs);
2379             heap_free(analysis->glyphs[i].pwLogClust);
2380             heap_free(analysis->glyphs[i].piAdvance);
2381             heap_free(analysis->glyphs[i].psva);
2382             heap_free(analysis->glyphs[i].pGoffset);
2383             heap_free(analysis->glyphs[i].abc);
2384             if (analysis->glyphs[i].fallbackFont)
2385                 DeleteObject(analysis->glyphs[i].fallbackFont);
2386             ScriptFreeCache((SCRIPT_CACHE *)&analysis->glyphs[i].sc);
2387             heap_free(analysis->glyphs[i].sc);
2388         }
2389         heap_free(analysis->glyphs);
2390     }
2391
2392     heap_free(analysis->pItem);
2393     heap_free(analysis->logattrs);
2394     heap_free(analysis->sz);
2395     heap_free(analysis->logical2visual);
2396     heap_free(analysis);
2397
2398     if (invalid) return E_INVALIDARG;
2399     return S_OK;
2400 }
2401
2402 static inline int get_cluster_size(const WORD *pwLogClust, int cChars, int item,
2403                                    int direction, int* iCluster, int *check_out)
2404 {
2405     int clust_size = 1;
2406     int check;
2407     WORD clust = pwLogClust[item];
2408
2409     for (check = item+direction; check < cChars && check >= 0; check+=direction)
2410     {
2411         if (pwLogClust[check] == clust)
2412         {
2413             clust_size ++;
2414             if (iCluster && *iCluster == -1)
2415                 *iCluster = item;
2416         }
2417         else break;
2418     }
2419
2420     if (check_out)
2421         *check_out = check;
2422
2423     return clust_size;
2424 }
2425
2426 static inline int get_glyph_cluster_advance(const int* piAdvance, const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cGlyphs, int cChars, int glyph, int direction)
2427 {
2428     int advance;
2429     int log_clust_max;
2430
2431     advance = piAdvance[glyph];
2432
2433     if (pwLogClust[0] > pwLogClust[cChars-1])
2434         log_clust_max = pwLogClust[0];
2435     else
2436         log_clust_max = pwLogClust[cChars-1];
2437
2438     if (glyph > log_clust_max)
2439         return advance;
2440
2441     for (glyph+=direction; glyph < cGlyphs && glyph >= 0; glyph +=direction)
2442     {
2443
2444         if (does_glyph_start_cluster(pva, pwLogClust, cChars, glyph, direction))
2445             break;
2446         if (glyph > log_clust_max)
2447             break;
2448         advance += piAdvance[glyph];
2449     }
2450
2451     return advance;
2452 }
2453
2454 /***********************************************************************
2455  *      ScriptCPtoX (USP10.@)
2456  *
2457  */
2458 HRESULT WINAPI ScriptCPtoX(int iCP,
2459                            BOOL fTrailing,
2460                            int cChars,
2461                            int cGlyphs,
2462                            const WORD *pwLogClust,
2463                            const SCRIPT_VISATTR *psva,
2464                            const int *piAdvance,
2465                            const SCRIPT_ANALYSIS *psa,
2466                            int *piX)
2467 {
2468     int item;
2469     float iPosX;
2470     int iSpecial = -1;
2471     int iCluster = -1;
2472     int clust_size = 1;
2473     float special_size = 0.0;
2474     int iMaxPos = 0;
2475     int advance = 0;
2476     BOOL rtl = FALSE;
2477
2478     TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
2479           iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
2480           psa, piX);
2481
2482     if (psa->fRTL && ! psa->fLogicalOrder)
2483         rtl = TRUE;
2484
2485     if (fTrailing)
2486         iCP++;
2487
2488     if (rtl)
2489     {
2490         int max_clust = pwLogClust[0];
2491
2492         for (item=0; item < cGlyphs; item++)
2493             if (pwLogClust[item] > max_clust)
2494             {
2495                 ERR("We do not handle non reversed clusters properly\n");
2496                 break;
2497             }
2498
2499         iMaxPos = 0;
2500         for (item = max_clust; item >=0; item --)
2501             iMaxPos += piAdvance[item];
2502     }
2503
2504     iPosX = 0.0;
2505     for (item=0; item < iCP && item < cChars; item++)
2506     {
2507         if (iSpecial == -1 && (iCluster == -1 || (iCluster != -1 && iCluster+clust_size <= item)))
2508         {
2509             int check;
2510             int clust = pwLogClust[item];
2511
2512             iCluster = -1;
2513             clust_size = get_cluster_size(pwLogClust, cChars, item, 1, &iCluster,
2514                                           &check);
2515
2516             advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, 1);
2517
2518             if (check >= cChars && !iMaxPos)
2519             {
2520                 for (check = clust; check < cChars; check++)
2521                     special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, check, 1);
2522                 iSpecial = item;
2523                 special_size /= (cChars - item);
2524                 iPosX += special_size;
2525             }
2526             else
2527             {
2528                 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2529                 {
2530                     clust_size --;
2531                     if (clust_size == 0)
2532                         iPosX += advance;
2533                 }
2534                 else
2535                     iPosX += advance / (float)clust_size;
2536             }
2537         }
2538         else if (iSpecial != -1)
2539             iPosX += special_size;
2540         else /* (iCluster != -1) */
2541         {
2542             int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], 1);
2543             if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2544             {
2545                 clust_size --;
2546                 if (clust_size == 0)
2547                     iPosX += adv;
2548             }
2549             else
2550                 iPosX += adv / (float)clust_size;
2551         }
2552     }
2553
2554     if (iMaxPos > 0)
2555     {
2556         iPosX = iMaxPos - iPosX;
2557         if (iPosX < 0)
2558             iPosX = 0;
2559     }
2560
2561     *piX = iPosX;
2562     TRACE("*piX=%d\n", *piX);
2563     return S_OK;
2564 }
2565
2566 /***********************************************************************
2567  *      ScriptXtoCP (USP10.@)
2568  *
2569  */
2570 HRESULT WINAPI ScriptXtoCP(int iX,
2571                            int cChars,
2572                            int cGlyphs,
2573                            const WORD *pwLogClust,
2574                            const SCRIPT_VISATTR *psva,
2575                            const int *piAdvance,
2576                            const SCRIPT_ANALYSIS *psa,
2577                            int *piCP,
2578                            int *piTrailing)
2579 {
2580     int item;
2581     float iPosX;
2582     float iLastPosX;
2583     int iSpecial = -1;
2584     int iCluster = -1;
2585     int clust_size = 1;
2586     int cjump = 0;
2587     int advance;
2588     float special_size = 0.0;
2589     int direction = 1;
2590
2591     TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
2592           iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
2593           psa, piCP, piTrailing);
2594
2595     if (psa->fRTL && ! psa->fLogicalOrder)
2596         direction = -1;
2597
2598     if (direction<0)
2599     {
2600         int max_clust = pwLogClust[0];
2601
2602         if (iX < 0)
2603         {
2604             *piCP = cChars;
2605             *piTrailing = 0;
2606             return S_OK;
2607         }
2608
2609         for (item=0; item < cChars; item++)
2610             if (pwLogClust[item] > max_clust)
2611             {
2612                 ERR("We do not handle non reversed clusters properly\n");
2613                 break;
2614             }
2615     }
2616
2617     if (iX < 0)
2618     {
2619         *piCP = -1;
2620         *piTrailing = 1;
2621         return S_OK;
2622     }
2623
2624     iPosX = iLastPosX = 0;
2625     if (direction > 0)
2626         item = 0;
2627     else
2628         item = cChars - 1;
2629     for (; iPosX <= iX && item < cChars && item >= 0; item+=direction)
2630     {
2631         iLastPosX = iPosX;
2632         if (iSpecial == -1 &&
2633              (iCluster == -1 ||
2634               (iCluster != -1 &&
2635                  ((direction > 0 && iCluster+clust_size <= item) ||
2636                   (direction < 0 && iCluster-clust_size >= item))
2637               )
2638              )
2639             )
2640         {
2641             int check;
2642             int clust = pwLogClust[item];
2643
2644             iCluster = -1;
2645             cjump = 0;
2646             clust_size = get_cluster_size(pwLogClust, cChars, item, direction,
2647                                           &iCluster, &check);
2648             advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, direction);
2649
2650             if (check >= cChars && direction > 0)
2651             {
2652                 for (check = clust; check < cChars; check++)
2653                     special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, check, direction);
2654                 iSpecial = item;
2655                 special_size /= (cChars - item);
2656                 iPosX += special_size;
2657             }
2658             else
2659             {
2660                 if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2661                 {
2662                     if (!cjump)
2663                         iPosX += advance;
2664                     cjump++;
2665                 }
2666                 else
2667                     iPosX += advance / (float)clust_size;
2668             }
2669         }
2670         else if (iSpecial != -1)
2671             iPosX += special_size;
2672         else /* (iCluster != -1) */
2673         {
2674             int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], direction);
2675             if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
2676             {
2677                 if (!cjump)
2678                     iPosX += adv;
2679                 cjump++;
2680             }
2681             else
2682                 iPosX += adv / (float)clust_size;
2683         }
2684     }
2685
2686     if (direction > 0)
2687     {
2688         if (iPosX > iX)
2689             item--;
2690         if (item < cChars && ((iPosX - iLastPosX) / 2.0) + iX >= iPosX)
2691         {
2692             if (scriptInformation[psa->eScript].props.fNeedsCaretInfo && clust_size > 1)
2693                 item+=(clust_size-1);
2694             *piTrailing = 1;
2695         }
2696         else
2697             *piTrailing = 0;
2698     }
2699     else
2700     {
2701         if (iX == iLastPosX)
2702             item++;
2703         if (iX >= iLastPosX && iX <= iPosX)
2704             item++;
2705
2706         if (iLastPosX == iX)
2707             *piTrailing = 0;
2708         else if (item < 0 || ((iLastPosX - iPosX) / 2.0) + iX <= iLastPosX)
2709         {
2710             if (scriptInformation[psa->eScript].props.fNeedsCaretInfo && clust_size > 1)
2711                 item-=(clust_size-1);
2712             *piTrailing = 1;
2713         }
2714         else
2715             *piTrailing = 0;
2716     }
2717
2718     *piCP = item;
2719
2720     TRACE("*piCP=%d\n", *piCP);
2721     TRACE("*piTrailing=%d\n", *piTrailing);
2722     return S_OK;
2723 }
2724
2725 /***********************************************************************
2726  *      ScriptBreak (USP10.@)
2727  *
2728  *  Retrieve line break information.
2729  *
2730  *  PARAMS
2731  *   chars [I] Array of characters.
2732  *   sa    [I] String analysis.
2733  *   la    [I] Array of logical attribute structures.
2734  *
2735  *  RETURNS
2736  *   Success: S_OK
2737  *   Failure: S_FALSE
2738  */
2739 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
2740 {
2741     TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
2742
2743     if (count < 0 || !la) return E_INVALIDARG;
2744     if (count == 0) return E_FAIL;
2745
2746     BREAK_line(chars, count, sa, la);
2747
2748     return S_OK;
2749 }
2750
2751 /***********************************************************************
2752  *      ScriptIsComplex (USP10.@)
2753  *
2754  *  Determine if a string is complex.
2755  *
2756  *  PARAMS
2757  *   chars [I] Array of characters to test.
2758  *   len   [I] Length in characters.
2759  *   flag  [I] Flag.
2760  *
2761  *  RETURNS
2762  *   Success: S_OK
2763  *   Failure: S_FALSE
2764  *
2765  */
2766 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
2767 {
2768     int i;
2769     INT consumed = 0;
2770
2771     TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
2772
2773     for (i = 0; i < len; i+=consumed)
2774     {
2775         int script;
2776         if (i >= len)
2777             break;
2778
2779         if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
2780             return S_OK;
2781
2782         script = get_char_script(chars,i,len, &consumed);
2783         if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
2784             (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
2785             return S_OK;
2786     }
2787     return S_FALSE;
2788 }
2789
2790 /***********************************************************************
2791  *      ScriptShapeOpenType (USP10.@)
2792  *
2793  * Produce glyphs and visual attributes for a run.
2794  *
2795  * PARAMS
2796  *  hdc         [I]   Device context.
2797  *  psc         [I/O] Opaque pointer to a script cache.
2798  *  psa         [I/O] Script analysis.
2799  *  tagScript   [I]   The OpenType tag for the Script
2800  *  tagLangSys  [I]   The OpenType tag for the Language
2801  *  rcRangeChars[I]   Array of Character counts in each range
2802  *  rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
2803  *  cRanges     [I]   Count of ranges
2804  *  pwcChars    [I]   Array of characters specifying the run.
2805  *  cChars      [I]   Number of characters in pwcChars.
2806  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
2807  *  pwLogClust  [O]   Array of logical cluster info.
2808  *  pCharProps  [O]   Array of character property values
2809  *  pwOutGlyphs [O]   Array of glyphs.
2810  *  pOutGlyphProps [O]  Array of attributes for the retrieved glyphs
2811  *  pcGlyphs    [O]   Number of glyphs returned.
2812  *
2813  * RETURNS
2814  *  Success: S_OK
2815  *  Failure: Non-zero HRESULT value.
2816  */
2817 HRESULT WINAPI ScriptShapeOpenType( HDC hdc, SCRIPT_CACHE *psc,
2818                                     SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript,
2819                                     OPENTYPE_TAG tagLangSys, int *rcRangeChars,
2820                                     TEXTRANGE_PROPERTIES **rpRangeProperties,
2821                                     int cRanges, const WCHAR *pwcChars, int cChars,
2822                                     int cMaxGlyphs, WORD *pwLogClust,
2823                                     SCRIPT_CHARPROP *pCharProps, WORD *pwOutGlyphs,
2824                                     SCRIPT_GLYPHPROP *pOutGlyphProps, int *pcGlyphs)
2825 {
2826     HRESULT hr;
2827     unsigned int i,g;
2828     BOOL rtl;
2829     int cluster;
2830
2831     TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %d, %d, %p, %p, %p, %p, %p )\n",
2832      hdc, psc, psa,
2833      debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
2834      rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
2835      cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
2836
2837     if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
2838                    psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
2839
2840     if (!pOutGlyphProps || !pcGlyphs || !pCharProps) return E_INVALIDARG;
2841     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
2842
2843     if (cRanges)
2844         FIXME("Ranges not supported yet\n");
2845
2846     rtl = (psa && !psa->fLogicalOrder && psa->fRTL);
2847
2848     *pcGlyphs = cChars;
2849     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2850     if (!pwLogClust) return E_FAIL;
2851
2852     ((ScriptCache *)*psc)->userScript = tagScript;
2853     ((ScriptCache *)*psc)->userLang = tagLangSys;
2854
2855     /* set fNoGlyphIndex non truetype/opentype fonts */
2856     if (psa && !psa->fNoGlyphIndex && !((ScriptCache *)*psc)->sfnt)
2857         psa->fNoGlyphIndex = TRUE;
2858
2859     /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
2860     for (i = 0; i < cChars; i++)
2861     {
2862         int idx = i;
2863         if (rtl) idx = cChars - 1 - i;
2864         /* FIXME: set to better values */
2865         pOutGlyphProps[i].sva.uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
2866         pOutGlyphProps[i].sva.fClusterStart  = 1;
2867         pOutGlyphProps[i].sva.fDiacritic     = 0;
2868         pOutGlyphProps[i].sva.fZeroWidth     = 0;
2869         pOutGlyphProps[i].sva.fReserved      = 0;
2870         pOutGlyphProps[i].sva.fShapeReserved = 0;
2871
2872         /* FIXME: have the shaping engine set this */
2873         pCharProps[i].fCanGlyphAlone = 0;
2874
2875         pwLogClust[i] = idx;
2876     }
2877
2878     if (psa && !psa->fNoGlyphIndex)
2879     {
2880         WCHAR *rChars;
2881         if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
2882
2883         rChars = heap_alloc(sizeof(WCHAR) * cChars);
2884         if (!rChars) return E_OUTOFMEMORY;
2885         for (i = 0, g = 0, cluster = 0; i < cChars; i++)
2886         {
2887             int idx = i;
2888             DWORD chInput;
2889
2890             if (rtl) idx = cChars - 1 - i;
2891             if (!cluster)
2892             {
2893                 chInput = decode_surrogate_pair(pwcChars, idx, cChars);
2894                 if (!chInput)
2895                 {
2896                     if (psa->fRTL)
2897                         chInput = mirror_char(pwcChars[idx]);
2898                     else
2899                         chInput = pwcChars[idx];
2900                     /* special case for tabs */
2901                     if (chInput == 0x0009)
2902                         chInput = 0x0020;
2903                     rChars[i] = chInput;
2904                 }
2905                 else
2906                 {
2907                     rChars[i] = pwcChars[idx];
2908                     rChars[i+1] = pwcChars[(rtl)?idx-1:idx+1];
2909                     cluster = 1;
2910                 }
2911                 if (!(pwOutGlyphs[g] = get_cache_glyph(psc, chInput)))
2912                 {
2913                     WORD glyph;
2914                     if (!hdc)
2915                     {
2916                         heap_free(rChars);
2917                         return E_PENDING;
2918                     }
2919                     if (OpenType_CMAP_GetGlyphIndex(hdc, (ScriptCache *)*psc, chInput, &glyph, 0) == GDI_ERROR)
2920                     {
2921                         heap_free(rChars);
2922                         return S_FALSE;
2923                     }
2924                     pwOutGlyphs[g] = set_cache_glyph(psc, chInput, glyph);
2925                 }
2926                 g++;
2927             }
2928             else
2929             {
2930                 int k;
2931                 cluster--;
2932                 pwLogClust[idx] = (rtl)?pwLogClust[idx+1]:pwLogClust[idx-1];
2933                 for (k = (rtl)?idx-1:idx+1; k >= 0 && k < cChars; (rtl)?k--:k++)
2934                     pwLogClust[k]--;
2935             }
2936         }
2937         *pcGlyphs = g;
2938
2939         SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
2940         SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
2941         SHAPE_CharGlyphProp(hdc, (ScriptCache *)*psc, psa, pwcChars, cChars, pwOutGlyphs, *pcGlyphs, pwLogClust, pCharProps, pOutGlyphProps);
2942         heap_free(rChars);
2943     }
2944     else
2945     {
2946         TRACE("no glyph translation\n");
2947         for (i = 0; i < cChars; i++)
2948         {
2949             int idx = i;
2950             /* No mirroring done here */
2951             if (rtl) idx = cChars - 1 - i;
2952             pwOutGlyphs[i] = pwcChars[idx];
2953         }
2954     }
2955
2956     return S_OK;
2957 }
2958
2959
2960 /***********************************************************************
2961  *      ScriptShape (USP10.@)
2962  *
2963  * Produce glyphs and visual attributes for a run.
2964  *
2965  * PARAMS
2966  *  hdc         [I]   Device context.
2967  *  psc         [I/O] Opaque pointer to a script cache.
2968  *  pwcChars    [I]   Array of characters specifying the run.
2969  *  cChars      [I]   Number of characters in pwcChars.
2970  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
2971  *  psa         [I/O] Script analysis.
2972  *  pwOutGlyphs [O]   Array of glyphs.
2973  *  pwLogClust  [O]   Array of logical cluster info.
2974  *  psva        [O]   Array of visual attributes.
2975  *  pcGlyphs    [O]   Number of glyphs returned.
2976  *
2977  * RETURNS
2978  *  Success: S_OK
2979  *  Failure: Non-zero HRESULT value.
2980  */
2981 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars,
2982                            int cChars, int cMaxGlyphs,
2983                            SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
2984                            SCRIPT_VISATTR *psva, int *pcGlyphs)
2985 {
2986     HRESULT hr;
2987     int i;
2988     SCRIPT_CHARPROP *charProps;
2989     SCRIPT_GLYPHPROP *glyphProps;
2990
2991     if (!psva || !pcGlyphs) return E_INVALIDARG;
2992     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
2993
2994     charProps = heap_alloc_zero(sizeof(SCRIPT_CHARPROP)*cChars);
2995     if (!charProps) return E_OUTOFMEMORY;
2996     glyphProps = heap_alloc_zero(sizeof(SCRIPT_GLYPHPROP)*cMaxGlyphs);
2997     if (!glyphProps)
2998     {
2999         heap_free(charProps);
3000         return E_OUTOFMEMORY;
3001     }
3002
3003     hr = ScriptShapeOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, pwcChars, cChars, cMaxGlyphs, pwLogClust, charProps, pwOutGlyphs, glyphProps, pcGlyphs);
3004
3005     if (SUCCEEDED(hr))
3006     {
3007         for (i = 0; i < *pcGlyphs; i++)
3008             psva[i] = glyphProps[i].sva;
3009     }
3010
3011     heap_free(charProps);
3012     heap_free(glyphProps);
3013
3014     return hr;
3015 }
3016
3017 /***********************************************************************
3018  *      ScriptPlaceOpenType (USP10.@)
3019  *
3020  * Produce advance widths for a run.
3021  *
3022  * PARAMS
3023  *  hdc       [I]   Device context.
3024  *  psc       [I/O] Opaque pointer to a script cache.
3025  *  psa       [I/O] String analysis.
3026  *  tagScript   [I]   The OpenType tag for the Script
3027  *  tagLangSys  [I]   The OpenType tag for the Language
3028  *  rcRangeChars[I]   Array of Character counts in each range
3029  *  rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
3030  *  cRanges     [I]   Count of ranges
3031  *  pwcChars    [I]   Array of characters specifying the run.
3032  *  pwLogClust  [I]   Array of logical cluster info
3033  *  pCharProps  [I]   Array of character property values
3034  *  cChars      [I]   Number of characters in pwcChars.
3035  *  pwGlyphs  [I]   Array of glyphs.
3036  *  pGlyphProps [I]  Array of attributes for the retrieved glyphs
3037  *  cGlyphs [I] Count of Glyphs
3038  *  piAdvance [O]   Array of advance widths.
3039  *  pGoffset  [O]   Glyph offsets.
3040  *  pABC      [O]   Combined ABC width.
3041  *
3042  * RETURNS
3043  *  Success: S_OK
3044  *  Failure: Non-zero HRESULT value.
3045  */
3046
3047 HRESULT WINAPI ScriptPlaceOpenType( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
3048                                     OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys,
3049                                     int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties,
3050                                     int cRanges, const WCHAR *pwcChars, WORD *pwLogClust,
3051                                     SCRIPT_CHARPROP *pCharProps, int cChars,
3052                                     const WORD *pwGlyphs, const SCRIPT_GLYPHPROP *pGlyphProps,
3053                                     int cGlyphs, int *piAdvance,
3054                                     GOFFSET *pGoffset, ABC *pABC
3055 )
3056 {
3057     HRESULT hr;
3058     int i;
3059
3060     TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %p, %p, %d, %p, %p, %d, %p %p %p)\n",
3061      hdc, psc, psa,
3062      debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
3063      rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
3064      pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance,
3065      pGoffset, pABC);
3066
3067     if (!pGlyphProps) return E_INVALIDARG;
3068     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3069     if (!pGoffset) return E_FAIL;
3070
3071     if (cRanges)
3072         FIXME("Ranges not supported yet\n");
3073
3074     ((ScriptCache *)*psc)->userScript = tagScript;
3075     ((ScriptCache *)*psc)->userLang = tagLangSys;
3076
3077     if (pABC) memset(pABC, 0, sizeof(ABC));
3078     for (i = 0; i < cGlyphs; i++)
3079     {
3080         ABC abc;
3081         if (!get_cache_glyph_widths(psc, pwGlyphs[i], &abc))
3082         {
3083             if (!hdc) return E_PENDING;
3084             if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE) && !psa->fNoGlyphIndex)
3085             {
3086                 if (!GetCharABCWidthsI(hdc, 0, 1, (WORD *)&pwGlyphs[i], &abc)) return S_FALSE;
3087             }
3088             else
3089             {
3090                 INT width;
3091                 if (!GetCharWidth32W(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
3092                 abc.abcB = width;
3093                 abc.abcA = abc.abcC = 0;
3094             }
3095             set_cache_glyph_widths(psc, pwGlyphs[i], &abc);
3096         }
3097         if (pABC)
3098         {
3099             pABC->abcA += abc.abcA;
3100             pABC->abcB += abc.abcB;
3101             pABC->abcC += abc.abcC;
3102         }
3103         /* FIXME: set to more reasonable values */
3104         pGoffset[i].du = pGoffset[i].dv = 0;
3105         if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
3106     }
3107
3108     SHAPE_ApplyOpenTypePositions(hdc, (ScriptCache *)*psc, psa, pwGlyphs, cGlyphs, piAdvance, pGoffset);
3109
3110     if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
3111     return S_OK;
3112 }
3113
3114 /***********************************************************************
3115  *      ScriptPlace (USP10.@)
3116  *
3117  * Produce advance widths for a run.
3118  *
3119  * PARAMS
3120  *  hdc       [I]   Device context.
3121  *  psc       [I/O] Opaque pointer to a script cache.
3122  *  pwGlyphs  [I]   Array of glyphs.
3123  *  cGlyphs   [I]   Number of glyphs in pwGlyphs.
3124  *  psva      [I]   Array of visual attributes.
3125  *  psa       [I/O] String analysis.
3126  *  piAdvance [O]   Array of advance widths.
3127  *  pGoffset  [O]   Glyph offsets.
3128  *  pABC      [O]   Combined ABC width.
3129  *
3130  * RETURNS
3131  *  Success: S_OK
3132  *  Failure: Non-zero HRESULT value.
3133  */
3134 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs,
3135                            int cGlyphs, const SCRIPT_VISATTR *psva,
3136                            SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
3137 {
3138     HRESULT hr;
3139     SCRIPT_GLYPHPROP *glyphProps;
3140     int i;
3141
3142     TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n",  hdc, psc, pwGlyphs, cGlyphs, psva, psa,
3143           piAdvance, pGoffset, pABC);
3144
3145     if (!psva) return E_INVALIDARG;
3146     if (!pGoffset) return E_FAIL;
3147
3148     glyphProps = heap_alloc(sizeof(SCRIPT_GLYPHPROP)*cGlyphs);
3149     if (!glyphProps) return E_OUTOFMEMORY;
3150
3151     for (i = 0; i < cGlyphs; i++)
3152         glyphProps[i].sva = psva[i];
3153
3154     hr = ScriptPlaceOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, NULL, NULL, NULL, 0, pwGlyphs, glyphProps, cGlyphs, piAdvance, pGoffset, pABC);
3155
3156     heap_free(glyphProps);
3157
3158     return hr;
3159 }
3160
3161 /***********************************************************************
3162  *      ScriptGetCMap (USP10.@)
3163  *
3164  * Retrieve glyph indices.
3165  *
3166  * PARAMS
3167  *  hdc         [I]   Device context.
3168  *  psc         [I/O] Opaque pointer to a script cache.
3169  *  pwcInChars  [I]   Array of Unicode characters.
3170  *  cChars      [I]   Number of characters in pwcInChars.
3171  *  dwFlags     [I]   Flags.
3172  *  pwOutGlyphs [O]   Buffer to receive the array of glyph indices.
3173  *
3174  * RETURNS
3175  *  Success: S_OK
3176  *  Failure: Non-zero HRESULT value.
3177  */
3178 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
3179                              int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
3180 {
3181     HRESULT hr;
3182     int i;
3183
3184     TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
3185           cChars, dwFlags, pwOutGlyphs);
3186
3187     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3188
3189     hr = S_OK;
3190
3191     if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
3192     {
3193         for (i = 0; i < cChars; i++)
3194         {
3195             WCHAR inChar;
3196             if (dwFlags == SGCM_RTL)
3197                 inChar = mirror_char(pwcInChars[i]);
3198             else
3199                 inChar = pwcInChars[i];
3200             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
3201             {
3202                 WORD glyph;
3203                 if (!hdc) return E_PENDING;
3204                 if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
3205                 if (glyph == 0xffff)
3206                 {
3207                     hr = S_FALSE;
3208                     glyph = 0x0;
3209                 }
3210                 pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
3211             }
3212         }
3213     }
3214     else
3215     {
3216         TRACE("no glyph translation\n");
3217         for (i = 0; i < cChars; i++)
3218         {
3219             WCHAR inChar;
3220             if (dwFlags == SGCM_RTL)
3221                 inChar = mirror_char(pwcInChars[i]);
3222             else
3223                 inChar = pwcInChars[i];
3224             pwOutGlyphs[i] = inChar;
3225         }
3226     }
3227     return hr;
3228 }
3229
3230 /***********************************************************************
3231  *      ScriptTextOut (USP10.@)
3232  *
3233  */
3234 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
3235                              const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
3236                              int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
3237                              const int *piJustify, const GOFFSET *pGoffset)
3238 {
3239     HRESULT hr = S_OK;
3240     INT i;
3241     INT *lpDx;
3242
3243     TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
3244          hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
3245          piAdvance, piJustify, pGoffset);
3246
3247     if (!hdc || !psc) return E_INVALIDARG;
3248     if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
3249
3250     fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
3251     fuOptions |= ETO_IGNORELANGUAGE;
3252     if  (!psa->fNoGlyphIndex)                                     /* Have Glyphs?                      */
3253         fuOptions |= ETO_GLYPH_INDEX;                             /* Say don't do translation to glyph */
3254
3255     lpDx = heap_alloc(cGlyphs * sizeof(INT) * 2);
3256
3257     if (pGoffset)
3258     {
3259         for (i = 0; i < cGlyphs; i++)
3260             if (!(fuOptions&ETO_PDY) && pGoffset[i].dv)
3261                 fuOptions |= ETO_PDY;
3262     }
3263     for (i = 0; i < cGlyphs; i++)
3264     {
3265         int idx = i;
3266         if (fuOptions&ETO_PDY)
3267         {
3268             idx *=2;
3269             lpDx[idx+1] = 0;
3270         }
3271         lpDx[idx] = piAdvance[i];
3272     }
3273     if (pGoffset)
3274     {
3275         for (i = 1; i < cGlyphs; i++)
3276         {
3277             int idx = i;
3278             int prev_idx = i-1;
3279             if (fuOptions&ETO_PDY)
3280             {
3281                 idx*=2;
3282                 prev_idx = idx-2;
3283             }
3284             lpDx[prev_idx] += pGoffset[i].du;
3285             lpDx[idx] -= pGoffset[i].du;
3286             if (fuOptions&ETO_PDY)
3287             {
3288                 lpDx[prev_idx+1] += pGoffset[i].dv;
3289                 lpDx[idx+1] -= pGoffset[i].dv;
3290             }
3291         }
3292     }
3293
3294     if (psa->fRTL && psa->fLogicalOrder)
3295     {
3296         int i;
3297         WORD *rtlGlyphs;
3298
3299         rtlGlyphs = heap_alloc(cGlyphs * sizeof(WORD));
3300         if (!rtlGlyphs)
3301         {
3302             heap_free(lpDx);
3303             return E_OUTOFMEMORY;
3304         }
3305
3306         for (i = 0; i < cGlyphs; i++)
3307             rtlGlyphs[i] = pwGlyphs[cGlyphs-1-i];
3308
3309         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, rtlGlyphs, cGlyphs, lpDx))
3310             hr = S_FALSE;
3311         heap_free(rtlGlyphs);
3312     }
3313     else
3314         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, pwGlyphs, cGlyphs, lpDx))
3315             hr = S_FALSE;
3316
3317     heap_free(lpDx);
3318
3319     return hr;
3320 }
3321
3322 /***********************************************************************
3323  *      ScriptCacheGetHeight (USP10.@)
3324  *
3325  * Retrieve the height of the font in the cache.
3326  *
3327  * PARAMS
3328  *  hdc    [I]    Device context.
3329  *  psc    [I/O]  Opaque pointer to a script cache.
3330  *  height [O]    Receives font height.
3331  *
3332  * RETURNS
3333  *  Success: S_OK
3334  *  Failure: Non-zero HRESULT value.
3335  */
3336 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
3337 {
3338     HRESULT hr;
3339
3340     TRACE("(%p, %p, %p)\n", hdc, psc, height);
3341
3342     if (!height) return E_INVALIDARG;
3343     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3344
3345     *height = get_cache_height(psc);
3346     return S_OK;
3347 }
3348
3349 /***********************************************************************
3350  *      ScriptGetGlyphABCWidth (USP10.@)
3351  *
3352  * Retrieve the width of a glyph.
3353  *
3354  * PARAMS
3355  *  hdc    [I]    Device context.
3356  *  psc    [I/O]  Opaque pointer to a script cache.
3357  *  glyph  [I]    Glyph to retrieve the width for.
3358  *  abc    [O]    ABC widths of the glyph.
3359  *
3360  * RETURNS
3361  *  Success: S_OK
3362  *  Failure: Non-zero HRESULT value.
3363  */
3364 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
3365 {
3366     HRESULT hr;
3367
3368     TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
3369
3370     if (!abc) return E_INVALIDARG;
3371     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3372
3373     if (!get_cache_glyph_widths(psc, glyph, abc))
3374     {
3375         if (!hdc) return E_PENDING;
3376         if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
3377         {
3378             if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
3379         }
3380         else
3381         {
3382             INT width;
3383             if (!GetCharWidth32W(hdc, glyph, glyph, &width)) return S_FALSE;
3384             abc->abcB = width;
3385             abc->abcA = abc->abcC = 0;
3386         }
3387         set_cache_glyph_widths(psc, glyph, abc);
3388     }
3389     return S_OK;
3390 }
3391
3392 /***********************************************************************
3393  *      ScriptLayout (USP10.@)
3394  *
3395  * Map embedding levels to visual and/or logical order.
3396  *
3397  * PARAMS
3398  *  runs     [I] Size of level array.
3399  *  level    [I] Array of embedding levels.
3400  *  vistolog [O] Map of embedding levels from visual to logical order.
3401  *  logtovis [O] Map of embedding levels from logical to visual order.
3402  *
3403  * RETURNS
3404  *  Success: S_OK
3405  *  Failure: Non-zero HRESULT value.
3406  *
3407  * BUGS
3408  *  This stub works correctly for any sequence of a single
3409  *  embedding level but not for sequences of different
3410  *  embedding levels, i.e. mixtures of RTL and LTR scripts.
3411  */
3412 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
3413 {
3414     int* indexs;
3415     int ich;
3416
3417     TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
3418
3419     if (!level || (!vistolog && !logtovis))
3420         return E_INVALIDARG;
3421
3422     indexs = heap_alloc(sizeof(int) * runs);
3423     if (!indexs)
3424         return E_OUTOFMEMORY;
3425
3426
3427     if (vistolog)
3428     {
3429         for( ich = 0; ich < runs; ich++)
3430             indexs[ich] = ich;
3431
3432         ich = 0;
3433         while (ich < runs)
3434             ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
3435         for (ich = 0; ich < runs; ich++)
3436             vistolog[ich] = indexs[ich];
3437     }
3438
3439
3440     if (logtovis)
3441     {
3442         for( ich = 0; ich < runs; ich++)
3443             indexs[ich] = ich;
3444
3445         ich = 0;
3446         while (ich < runs)
3447             ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
3448         for (ich = 0; ich < runs; ich++)
3449             logtovis[ich] = indexs[ich];
3450     }
3451     heap_free(indexs);
3452
3453     return S_OK;
3454 }
3455
3456 /***********************************************************************
3457  *      ScriptStringGetLogicalWidths (USP10.@)
3458  *
3459  * Returns logical widths from a string analysis.
3460  *
3461  * PARAMS
3462  *  ssa  [I] string analysis.
3463  *  piDx [O] logical widths returned.
3464  *
3465  * RETURNS
3466  *  Success: S_OK
3467  *  Failure: a non-zero HRESULT.
3468  */
3469 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
3470 {
3471     int i, j, next = 0;
3472     StringAnalysis *analysis = ssa;
3473
3474     TRACE("%p, %p\n", ssa, piDx);
3475
3476     if (!analysis) return S_FALSE;
3477     if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
3478
3479     for (i = 0; i < analysis->numItems; i++)
3480     {
3481         int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
3482         int direction = 1;
3483
3484         if (analysis->pItem[i].a.fRTL && ! analysis->pItem[i].a.fLogicalOrder)
3485             direction = -1;
3486
3487         for (j = 0; j < cChar; j++)
3488         {
3489             int k;
3490             int glyph = analysis->glyphs[i].pwLogClust[j];
3491             int clust_size = get_cluster_size(analysis->glyphs[i].pwLogClust,
3492                                               cChar, j, direction, NULL, NULL);
3493             int advance = get_glyph_cluster_advance(analysis->glyphs[i].piAdvance, analysis->glyphs[i].psva, analysis->glyphs[i].pwLogClust, analysis->glyphs[i].numGlyphs, cChar, glyph, direction);
3494
3495             for (k = 0; k < clust_size; k++)
3496             {
3497                 piDx[next] = advance / clust_size;
3498                 next++;
3499                 if (k) j++;
3500             }
3501         }
3502     }
3503     return S_OK;
3504 }
3505
3506 /***********************************************************************
3507  *      ScriptStringValidate (USP10.@)
3508  *
3509  * Validate a string analysis.
3510  *
3511  * PARAMS
3512  *  ssa [I] string analysis.
3513  *
3514  * RETURNS
3515  *  Success: S_OK
3516  *  Failure: S_FALSE if invalid sequences are found
3517  *           or a non-zero HRESULT if it fails.
3518  */
3519 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
3520 {
3521     StringAnalysis *analysis = ssa;
3522
3523     TRACE("(%p)\n", ssa);
3524
3525     if (!analysis) return E_INVALIDARG;
3526     return (analysis->invalid) ? S_FALSE : S_OK;
3527 }
3528
3529 /***********************************************************************
3530  *      ScriptString_pSize (USP10.@)
3531  *
3532  * Retrieve width and height of an analysed string.
3533  *
3534  * PARAMS
3535  *  ssa [I] string analysis.
3536  *
3537  * RETURNS
3538  *  Success: Pointer to a SIZE structure.
3539  *  Failure: NULL
3540  */
3541 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
3542 {
3543     int i, j;
3544     StringAnalysis *analysis = ssa;
3545
3546     TRACE("(%p)\n", ssa);
3547
3548     if (!analysis) return NULL;
3549     if (!(analysis->dwFlags & SSA_GLYPHS)) return NULL;
3550
3551     if (!analysis->sz)
3552     {
3553         if (!(analysis->sz = heap_alloc(sizeof(SIZE)))) return NULL;
3554         analysis->sz->cy = analysis->glyphs[0].sc->tm.tmHeight;
3555
3556         analysis->sz->cx = 0;
3557         for (i = 0; i < analysis->numItems; i++)
3558         {
3559             if (analysis->glyphs[i].sc->tm.tmHeight > analysis->sz->cy)
3560                 analysis->sz->cy = analysis->glyphs[i].sc->tm.tmHeight;
3561             for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
3562                 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
3563         }
3564     }
3565     return analysis->sz;
3566 }
3567
3568 /***********************************************************************
3569  *      ScriptString_pLogAttr (USP10.@)
3570  *
3571  * Retrieve logical attributes of an analysed string.
3572  *
3573  * PARAMS
3574  *  ssa [I] string analysis.
3575  *
3576  * RETURNS
3577  *  Success: Pointer to an array of SCRIPT_LOGATTR structures.
3578  *  Failure: NULL
3579  */
3580 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
3581 {
3582     StringAnalysis *analysis = ssa;
3583
3584     TRACE("(%p)\n", ssa);
3585
3586     if (!analysis) return NULL;
3587     if (!(analysis->dwFlags & SSA_BREAK)) return NULL;
3588     return analysis->logattrs;
3589 }
3590
3591 /***********************************************************************
3592  *      ScriptString_pcOutChars (USP10.@)
3593  *
3594  * Retrieve the length of a string after clipping.
3595  *
3596  * PARAMS
3597  *  ssa [I] String analysis.
3598  *
3599  * RETURNS
3600  *  Success: Pointer to the length.
3601  *  Failure: NULL
3602  */
3603 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
3604 {
3605     StringAnalysis *analysis = ssa;
3606
3607     TRACE("(%p)\n", ssa);
3608
3609     if (!analysis) return NULL;
3610     return &analysis->clip_len;
3611 }
3612
3613 /***********************************************************************
3614  *      ScriptStringGetOrder (USP10.@)
3615  *
3616  * Retrieve a glyph order map.
3617  *
3618  * PARAMS
3619  *  ssa   [I]   String analysis.
3620  *  order [I/O] Array of glyph positions.
3621  *
3622  * RETURNS
3623  *  Success: S_OK
3624  *  Failure: a non-zero HRESULT.
3625  */
3626 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
3627 {
3628     int i, j;
3629     unsigned int k;
3630     StringAnalysis *analysis = ssa;
3631
3632     TRACE("(%p)\n", ssa);
3633
3634     if (!analysis) return S_FALSE;
3635     if (!(analysis->dwFlags & SSA_GLYPHS)) return S_FALSE;
3636
3637     /* FIXME: handle RTL scripts */
3638     for (i = 0, k = 0; i < analysis->numItems; i++)
3639         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
3640             order[k] = k;
3641
3642     return S_OK;
3643 }
3644
3645 /***********************************************************************
3646  *      ScriptGetLogicalWidths (USP10.@)
3647  *
3648  * Convert advance widths to logical widths.
3649  *
3650  * PARAMS
3651  *  sa          [I] Script analysis.
3652  *  nbchars     [I] Number of characters.
3653  *  nbglyphs    [I] Number of glyphs.
3654  *  glyph_width [I] Array of glyph widths.
3655  *  log_clust   [I] Array of logical clusters.
3656  *  sva         [I] Visual attributes.
3657  *  widths      [O] Array of logical widths.
3658  *
3659  * RETURNS
3660  *  Success: S_OK
3661  *  Failure: a non-zero HRESULT.
3662  */
3663 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
3664                                       const int *glyph_width, const WORD *log_clust,
3665                                       const SCRIPT_VISATTR *sva, int *widths)
3666 {
3667     int i;
3668
3669     TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
3670           sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
3671
3672     /* FIXME */
3673     for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
3674     return S_OK;
3675 }
3676
3677 /***********************************************************************
3678  *      ScriptApplyLogicalWidth (USP10.@)
3679  *
3680  * Generate glyph advance widths.
3681  *
3682  * PARAMS
3683  *  dx          [I]   Array of logical advance widths.
3684  *  num_chars   [I]   Number of characters.
3685  *  num_glyphs  [I]   Number of glyphs.
3686  *  log_clust   [I]   Array of logical clusters.
3687  *  sva         [I]   Visual attributes.
3688  *  advance     [I]   Array of glyph advance widths.
3689  *  sa          [I]   Script analysis.
3690  *  abc         [I/O] Summed ABC widths.
3691  *  justify     [O]   Array of glyph advance widths.
3692  *
3693  * RETURNS
3694  *  Success: S_OK
3695  *  Failure: a non-zero HRESULT.
3696  */
3697 HRESULT WINAPI ScriptApplyLogicalWidth(const int *dx, int num_chars, int num_glyphs,
3698                                        const WORD *log_clust, const SCRIPT_VISATTR *sva,
3699                                        const int *advance, const SCRIPT_ANALYSIS *sa,
3700                                        ABC *abc, int *justify)
3701 {
3702     int i;
3703
3704     FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
3705           dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
3706
3707     for (i = 0; i < num_chars; i++) justify[i] = advance[i];
3708     return S_OK;
3709 }
3710
3711 HRESULT WINAPI ScriptJustify(const SCRIPT_VISATTR *sva, const int *advance,
3712                              int num_glyphs, int dx, int min_kashida, int *justify)
3713 {
3714     int i;
3715
3716     FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
3717
3718     for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
3719     return S_OK;
3720 }
3721
3722 HRESULT WINAPI ScriptGetFontScriptTags( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
3723 {
3724     HRESULT hr;
3725     if (!pScriptTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
3726     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3727
3728     return SHAPE_GetFontScriptTags(hdc, (ScriptCache *)*psc, psa, cMaxTags, pScriptTags, pcTags);
3729 }
3730
3731 HRESULT WINAPI ScriptGetFontLanguageTags( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript, int cMaxTags, OPENTYPE_TAG *pLangSysTags, int *pcTags)
3732 {
3733     HRESULT hr;
3734     if (!pLangSysTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
3735     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3736
3737     return SHAPE_GetFontLanguageTags(hdc, (ScriptCache *)*psc, psa, tagScript, cMaxTags, pLangSysTags, pcTags);
3738 }
3739
3740 HRESULT WINAPI ScriptGetFontFeatureTags( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys, int cMaxTags, OPENTYPE_TAG *pFeatureTags, int *pcTags)
3741 {
3742     HRESULT hr;
3743     if (!pFeatureTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
3744     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
3745
3746     return SHAPE_GetFontFeatureTags(hdc, (ScriptCache *)*psc, psa, tagScript, tagLangSys, cMaxTags, pFeatureTags, pcTags);
3747 }