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

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