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

   1 /*
   2  * Implementation of Uniscribe Script Processor (usp10.dll)
   3  *
   4  * Copyright 2005 Steven Edwards for CodeWeavers
   5  * Copyright 2006 Hans Leidekker
   6  * Copyright 2010 CodeWeavers, Aric Stewart
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * Notes:
  23  * Uniscribe allows for processing of complex scripts such as joining
  24  * and filtering characters and bi-directional text with custom line breaks.
  25  */
  26
  27 #include <stdarg.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winnls.h"
  34 #include "usp10.h"
  35
  36 #include "usp10_internal.h"
  37
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  42
  43 typedef struct _scriptRange
  44 {
  45     WORD script;
  46     WORD rangeFirst;
  47     WORD rangeLast;
  48     WORD numericScript;
  49     WORD punctScript;
  50 } scriptRange;
  51
  52 static const scriptRange scriptRanges[] = {
  53     /* Basic Latin: U+0000–U+007A */
  54     /* Latin-1 Supplement: U+0080–U+00FF */
  55     /* Latin Extended-A: U+0100–U+017F */
  56     /* Latin Extended-B: U+0180–U+024F */
  57     /* IPA Extensions: U+0250–U+02AF */
  58     { Script_Latin,      0x00,   0x2af ,  Script_Numeric, Script_Punctuation},
  59     /* Greek: U+0370–U+03FF */
  60     { Script_Greek,      0x370,  0x3ff,  0, 0},
  61     /* Cyrillic: U+0400–U+04FF */
  62     /* Cyrillic Supplement: U+0500–U+052F */
  63     { Script_Cyrillic,   0x400,  0x52f,  0, 0},
  64     /* Armenian: U+0530–U+058F */
  65     { Script_Armenian,   0x530,  0x58f,  0, 0},
  66     /* Hebrew: U+0590–U+05FF */
  67     { Script_Hebrew,     0x590,  0x5ff,  0, 0},
  68     /* Arabic: U+0600–U+06FF */
  69     { Script_Arabic,     0x600,  0x6ef,  Script_Arabic_Numeric, 0},
  70     /* Defined by Windows */
  71     { Script_Persian,    0x6f0,  0x6f9,  0, 0},
  72     /* Continue Arabic: U+0600–U+06FF */
  73     { Script_Arabic,     0x6fa,  0x6ff,  0, 0},
  74     /* Syriac: U+0700–U+074F*/
  75     { Script_Syriac,     0x700,  0x74f,  0, 0},
  76     /* Arabic Supplement: U+0750–U+077F */
  77     { Script_Arabic,     0x750,  0x77f,  0, 0},
  78     /* Thaana: U+0780–U+07BF */
  79     { Script_Thaana,     0x780,  0x7bf,  0, 0},
  80     /* Devanagari: U+0900–U+097F */
  81     { Script_Devanagari, 0x900,  0x97f,  Script_Devanagari_Numeric, 0},
  82     /* Bengali: U+0980–U+09FF */
  83     { Script_Bengali,    0x980,  0x9ff,  Script_Bengali_Numeric, 0},
  84     /* Gurmukhi: U+0A00–U+0A7F*/
  85     { Script_Gurmukhi,   0xa00,  0xa7f,  Script_Gurmukhi_Numeric, 0},
  86     /* Gujarati: U+0A80–U+0AFF*/
  87     { Script_Gujarati,   0xa80,  0xaff,  Script_Gujarati_Numeric, 0},
  88     /* Oriya: U+0B00–U+0B7F */
  89     { Script_Oriya,      0xb00,  0xb7f,  Script_Oriya_Numeric, 0},
  90     /* Tamil: U+0B80–U+0BFF */
  91     { Script_Tamil,      0xb80,  0xbff,  Script_Tamil_Numeric, 0},
  92     /* Telugu: U+0C00–U+0C7F */
  93     { Script_Telugu,     0xc00,  0xc7f,  Script_Telugu_Numeric, 0},
  94     /* Kannada: U+0C80–U+0CFF */
  95     { Script_Kannada,    0xc80,  0xcff,  Script_Kannada_Numeric, 0},
  96     /* Malayalam: U+0D00–U+0D7F */
  97     { Script_Malayalam,  0xd00,  0xd7f,  Script_Malayalam_Numeric, 0},
  98     /* Sinhala: U+0D80–U+0DFF */
  99     { Script_Sinhala,   0xd80,  0xdff,  0, 0},
 100     /* Thai: U+0E00–U+0E7F */
 101     { Script_Thai,      0xe00,  0xe7f,  Script_Thai_Numeric, 0},
 102     /* Lao: U+0E80–U+0EFF */
 103     { Script_Lao,       0xe80,  0xeff,  Script_Lao_Numeric, 0},
 104     /* Tibetan: U+0F00–U+0FFF */
 105     { Script_Tibetan,   0xf00,  0xfff,  Script_Tibetan_Numeric, 0},
 106     /* Georgian: U+10A0–U+10FF */
 107     { Script_Georgian,   0x10a0,  0x10ff,  0, 0},
 108     /* Vedic Extensions: U+1CD0-U+1CFF */
 109     { Script_Devanagari, 0x1cd0, 0x1cff, Script_Devanagari_Numeric, 0},
 110     /* Phonetic Extensions: U+1D00–U+1DBF */
 111     { Script_Latin,      0x1d00, 0x1dbf, 0, 0},
 112     /* Latin Extended Additional: U+1E00–U+1EFF */
 113     { Script_Latin,      0x1e00, 0x1eff, 0, 0},
 114     /* Greek Extended: U+1F00–U+1FFF */
 115     { Script_Greek,      0x1f00, 0x1fff, 0, 0},
 116     /* Latin Extended-C: U+2C60–U+2C7F */
 117     { Script_Latin,      0x2c60, 0x2c7f, 0, 0},
 118     /* Georgian: U+2D00–U+2D2F */
 119     { Script_Georgian,   0x2d00,  0x2d2f,  0, 0},
 120     /* Cyrillic Extended-A: U+2DE0–U+2DFF */
 121     { Script_Cyrillic,   0x2de0, 0x2dff,  0, 0},
 122     /* Cyrillic Extended-B: U+A640–U+A69F */
 123     { Script_Cyrillic,   0xa640, 0xa69f,  0, 0},
 124     /* Modifier Tone Letters: U+A700–U+A71F */
 125     /* Latin Extended-D: U+A720–U+A7FF */
 126     { Script_Latin,      0xa700, 0xa7ff, 0, 0},
 127     /* Phags-pa: U+A840–U+A87F */
 128     { Script_Phags_pa,   0xa840, 0xa87f, 0, 0},
 129     /* Devanagari Extended: U+A8E0-U+A8FF */
 130     { Script_Devanagari, 0xa8e0, 0xa8ff, Script_Devanagari_Numeric, 0},
 131     /* Latin Ligatures: U+FB00–U+FB06 */
 132     { Script_Latin,      0xfb00, 0xfb06, 0, 0},
 133     /* Armenian ligatures U+FB13..U+FB17 */
 134     { Script_Armenian,   0xfb13, 0xfb17,  0, 0},
 135     /* Alphabetic Presentation Forms: U+FB1D–U+FB4F */
 136     { Script_Hebrew,     0xfb1d, 0xfb4f, 0, 0},
 137     /* Arabic Presentation Forms-A: U+FB50–U+FDFF*/
 138     { Script_Arabic,     0xfb50, 0xfdff, 0, 0},
 139     /* Arabic Presentation Forms-B: U+FE70–U+FEFF*/
 140     { Script_Arabic,     0xfe70, 0xfeff, 0, 0},
 141     /* END */
 142     { SCRIPT_UNDEFINED,  0, 0, 0}
 143 };
 144
 145 typedef struct _scriptData
 146 {
 147     SCRIPT_ANALYSIS a;
 148     SCRIPT_PROPERTIES props;
 149     OPENTYPE_TAG scriptTag;
 150 } scriptData;
 151
 152 /* the must be in order so that the index matches the Script value */
 153 static const scriptData scriptInformation[] = {
 154     {{SCRIPT_UNDEFINED, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 155      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 156      0x00000000},
 157     {{Script_Latin, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 158      {LANG_ENGLISH, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 159      MS_MAKE_TAG('l','a','t','n')},
 160     {{Script_CR, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 161      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 162      0x00000000},
 163     {{Script_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 164      {LANG_ENGLISH, 1, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 165      0x00000000},
 166     {{Script_Control, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 167      {LANG_ENGLISH, 0, 1, 0, 0, ANSI_CHARSET, 1, 0, 0, 0, 0, 0, 1, 0, 0},
 168      0x00000000},
 169     {{Script_Punctuation, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 170      {LANG_NEUTRAL, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 171      0x00000000},
 172     {{Script_Arabic, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 173      {LANG_ARABIC, 0, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 1, 0},
 174      MS_MAKE_TAG('a','r','a','b')},
 175     {{Script_Arabic_Numeric, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 176      {LANG_ARABIC, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 177      MS_MAKE_TAG('a','r','a','b')},
 178     {{Script_Hebrew, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 179      {LANG_HEBREW, 0, 1, 0, 1, HEBREW_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 180      MS_MAKE_TAG('h','e','b','r')},
 181     {{Script_Syriac, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 182      {LANG_SYRIAC, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 1, 0},
 183      MS_MAKE_TAG('s','y','r','c')},
 184     {{Script_Persian, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 185      {LANG_PERSIAN, 1, 1, 0, 0, ARABIC_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 186      MS_MAKE_TAG('s','y','r','c')},
 187     {{Script_Thaana, 1, 1, 0, 0, 0, 0, { 1,0,0,0,0,0,0,0,0,0,0}},
 188      {LANG_DIVEHI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 189      MS_MAKE_TAG('t','h','a','a')},
 190     {{Script_Greek, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 191      {LANG_GREEK, 0, 0, 0, 0, GREEK_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 192      MS_MAKE_TAG('g','r','e','k')},
 193     {{Script_Cyrillic, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 194      {LANG_RUSSIAN, 0, 0, 0, 0, RUSSIAN_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 195      MS_MAKE_TAG('c','y','r','l')},
 196     {{Script_Armenian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 197      {LANG_ARMENIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 198      MS_MAKE_TAG('a','r','m','n')},
 199     {{Script_Georgian, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 200      {LANG_GEORGIAN, 0, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, 0, 0, 1, 0, 0},
 201      MS_MAKE_TAG('g','e','o','r')},
 202     {{Script_Sinhala, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 203      {LANG_SINHALESE, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 204      MS_MAKE_TAG('s','i','n','h')},
 205     {{Script_Tibetan, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 206      {LANG_TIBETAN, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0},
 207      MS_MAKE_TAG('t','i','b','t')},
 208     {{Script_Tibetan_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 209      {LANG_TIBETAN, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 210      MS_MAKE_TAG('t','i','b','t')},
 211     {{Script_Phags_pa, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 212      {LANG_MONGOLIAN, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 213      MS_MAKE_TAG('p','h','a','g')},
 214     {{Script_Thai, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 215      {LANG_THAI, 0, 1, 1, 1, THAI_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 1},
 216      MS_MAKE_TAG('t','h','a','i')},
 217     {{Script_Thai_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 218      {LANG_THAI, 1, 1, 0, 0, THAI_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 219      MS_MAKE_TAG('t','h','a','i')},
 220     {{Script_Lao, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 221      {LANG_LAO, 0, 1, 1, 1, DEFAULT_CHARSET, 0, 0, 1, 0, 1, 0, 0, 0, 0},
 222      MS_MAKE_TAG('l','a','o',' ')},
 223     {{Script_Lao_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 224      {LANG_LAO, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 225      MS_MAKE_TAG('l','a','o',' ')},
 226     {{Script_Devanagari, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 227      {LANG_HINDI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 228      MS_MAKE_TAG('d','e','v','a')},
 229     {{Script_Devanagari_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 230      {LANG_HINDI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 231      MS_MAKE_TAG('d','e','v','a')},
 232     {{Script_Bengali, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 233      {LANG_BENGALI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 234      MS_MAKE_TAG('b','e','n','g')},
 235     {{Script_Bengali_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 236      {LANG_BENGALI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 237      MS_MAKE_TAG('b','e','n','g')},
 238     {{Script_Bengali_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 239      {LANG_BENGALI, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 240      MS_MAKE_TAG('b','e','n','g')},
 241     {{Script_Gurmukhi, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 242      {LANG_PUNJABI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 243      MS_MAKE_TAG('g','u','r','u')},
 244     {{Script_Gurmukhi_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 245      {LANG_PUNJABI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 246      MS_MAKE_TAG('g','u','r','u')},
 247     {{Script_Gujarati, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 248      {LANG_GUJARATI, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 249      MS_MAKE_TAG('g','u','j','r')},
 250     {{Script_Gujarati_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 251      {LANG_GUJARATI, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 252      MS_MAKE_TAG('g','u','j','r')},
 253     {{Script_Gujarati_Currency, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 254      {LANG_GUJARATI, 0, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 255      MS_MAKE_TAG('g','u','j','r')},
 256     {{Script_Oriya, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 257      {LANG_ORIYA, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 258      MS_MAKE_TAG('o','r','y','a')},
 259     {{Script_Oriya_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 260      {LANG_ORIYA, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 261      MS_MAKE_TAG('o','r','y','a')},
 262     {{Script_Tamil, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 263      {LANG_TAMIL, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 264      MS_MAKE_TAG('t','a','m','l')},
 265     {{Script_Tamil_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 266      {LANG_TAMIL, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 267      MS_MAKE_TAG('t','a','m','l')},
 268     {{Script_Telugu, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 269      {LANG_TELUGU, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 270      MS_MAKE_TAG('t','e','l','u')},
 271     {{Script_Telugu_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 272      {LANG_TELUGU, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 273      MS_MAKE_TAG('t','e','l','u')},
 274     {{Script_Kannada, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 275      {LANG_KANNADA, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 276      MS_MAKE_TAG('k','n','d','a')},
 277     {{Script_Kannada_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 278      {LANG_KANNADA, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 279      MS_MAKE_TAG('k','n','d','a')},
 280     {{Script_Malayalam, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 281      {LANG_MALAYALAM, 0, 1, 0, 1, DEFAULT_CHARSET, 0, 0, 0, 0, 1, 0, 0, 0, 0},
 282      MS_MAKE_TAG('m','l','y','m')},
 283     {{Script_Malayalam_Numeric, 0, 0, 0, 0, 0, 0, { 0,0,0,0,0,0,0,0,0,0,0}},
 284      {LANG_MALAYALAM, 1, 1, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 285      MS_MAKE_TAG('m','l','y','m')},
 286 };
 287
 288 static const SCRIPT_PROPERTIES *script_props[] =
 289 {
 290     &scriptInformation[0].props, &scriptInformation[1].props,
 291     &scriptInformation[2].props, &scriptInformation[3].props,
 292     &scriptInformation[4].props, &scriptInformation[5].props,
 293     &scriptInformation[6].props, &scriptInformation[7].props,
 294     &scriptInformation[8].props, &scriptInformation[9].props,
 295     &scriptInformation[10].props, &scriptInformation[11].props,
 296     &scriptInformation[12].props, &scriptInformation[13].props,
 297     &scriptInformation[14].props, &scriptInformation[15].props,
 298     &scriptInformation[16].props, &scriptInformation[17].props,
 299     &scriptInformation[18].props, &scriptInformation[19].props,
 300     &scriptInformation[20].props, &scriptInformation[21].props,
 301     &scriptInformation[22].props, &scriptInformation[23].props,
 302     &scriptInformation[24].props, &scriptInformation[25].props,
 303     &scriptInformation[26].props, &scriptInformation[27].props,
 304     &scriptInformation[28].props, &scriptInformation[29].props,
 305     &scriptInformation[30].props, &scriptInformation[31].props,
 306     &scriptInformation[32].props, &scriptInformation[33].props,
 307     &scriptInformation[34].props, &scriptInformation[35].props,
 308     &scriptInformation[36].props, &scriptInformation[37].props,
 309     &scriptInformation[38].props, &scriptInformation[39].props,
 310     &scriptInformation[40].props, &scriptInformation[41].props,
 311     &scriptInformation[42].props, &scriptInformation[43].props
 312 };
 313
 314 typedef struct {
 315     int numGlyphs;
 316     WORD* glyphs;
 317     WORD* pwLogClust;
 318     int* piAdvance;
 319     SCRIPT_VISATTR* psva;
 320     GOFFSET* pGoffset;
 321     ABC* abc;
 322     int iMaxPosX;
 323 } StringGlyphs;
 324
 325 typedef struct {
 326     HDC hdc;
 327     BOOL invalid;
 328     int clip_len;
 329     ScriptCache *sc;
 330     int cItems;
 331     int cMaxGlyphs;
 332     SCRIPT_ITEM* pItem;
 333     int numItems;
 334     StringGlyphs* glyphs;
 335     SCRIPT_LOGATTR* logattrs;
 336     SIZE* sz;
 337 } StringAnalysis;
 338
 339 static inline void *heap_alloc(SIZE_T size)
 340 {
 341     return HeapAlloc(GetProcessHeap(), 0, size);
 342 }
 343
 344 static inline void *heap_alloc_zero(SIZE_T size)
 345 {
 346     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 347 }
 348
 349 static inline void *heap_realloc_zero(LPVOID mem, SIZE_T size)
 350 {
 351     return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
 352 }
 353
 354 static inline BOOL heap_free(LPVOID mem)
 355 {
 356     return HeapFree(GetProcessHeap(), 0, mem);
 357 }
 358
 359 static inline WCHAR get_cache_default_char(SCRIPT_CACHE *psc)
 360 {
 361     return ((ScriptCache *)*psc)->tm.tmDefaultChar;
 362 }
 363
 364 static inline LONG get_cache_height(SCRIPT_CACHE *psc)
 365 {
 366     return ((ScriptCache *)*psc)->tm.tmHeight;
 367 }
 368
 369 static inline BYTE get_cache_pitch_family(SCRIPT_CACHE *psc)
 370 {
 371     return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
 372 }
 373
 374 static inline WORD get_cache_glyph(SCRIPT_CACHE *psc, WCHAR c)
 375 {
 376     WORD *block = ((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
 377
 378     if (!block) return 0;
 379     return block[c & GLYPH_BLOCK_MASK];
 380 }
 381
 382 static inline WORD set_cache_glyph(SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
 383 {
 384     WORD **block = &((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
 385
 386     if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
 387     return ((*block)[c & GLYPH_BLOCK_MASK] = glyph);
 388 }
 389
 390 static inline BOOL get_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
 391 {
 392     static const ABC nil;
 393     ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 394
 395     if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
 396     memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
 397     return TRUE;
 398 }
 399
 400 static inline BOOL set_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
 401 {
 402     ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 403
 404     if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
 405     memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
 406     return TRUE;
 407 }
 408
 409 static HRESULT init_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
 410 {
 411     ScriptCache *sc;
 412
 413     if (!psc) return E_INVALIDARG;
 414     if (*psc) return S_OK;
 415     if (!hdc) return E_PENDING;
 416
 417     if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
 418     if (!GetTextMetricsW(hdc, &sc->tm))
 419     {
 420         heap_free(sc);
 421         return E_INVALIDARG;
 422     }
 423     if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(LOGFONTW), &sc->lf))
 424     {
 425         heap_free(sc);
 426         return E_INVALIDARG;
 427     }
 428     *psc = sc;
 429     TRACE("<- %p\n", sc);
 430     return S_OK;
 431 }
 432
 433 static WCHAR mirror_char( WCHAR ch )
 434 {
 435     extern const WCHAR wine_mirror_map[];
 436     return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
 437 }
 438
 439 static WORD get_char_script( WCHAR ch)
 440 {
 441     WORD type = 0;
 442     int i;
 443
 444     if (ch == 0xc || ch == 0x20 || ch == 0x202f)
 445         return Script_CR;
 446
 447     GetStringTypeW(CT_CTYPE1, &ch, 1, &type);
 448
 449     if (type == 0)
 450         return SCRIPT_UNDEFINED;
 451
 452     if (type & C1_CNTRL)
 453         return Script_Control;
 454
 455     i = 0;
 456     do
 457     {
 458         if (ch < scriptRanges[i].rangeFirst || scriptRanges[i].script == SCRIPT_UNDEFINED)
 459             break;
 460
 461         if (ch >= scriptRanges[i].rangeFirst && ch <= scriptRanges[i].rangeLast)
 462         {
 463             if (scriptRanges[i].numericScript && type & C1_DIGIT)
 464                 return scriptRanges[i].numericScript;
 465             if (scriptRanges[i].punctScript && type & C1_PUNCT)
 466                 return scriptRanges[i].punctScript;
 467             return scriptRanges[i].script;
 468         }
 469         i++;
 470     } while (1);
 471
 472     return SCRIPT_UNDEFINED;
 473 }
 474
 475 /***********************************************************************
 476  *      DllMain
 477  *
 478  */
 479 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 480 {
 481     switch(fdwReason)
 482     {
 483     case DLL_PROCESS_ATTACH:
 484         DisableThreadLibraryCalls(hInstDLL);
 485         break;
 486     case DLL_PROCESS_DETACH:
 487         break;
 488     }
 489     return TRUE;
 490 }
 491
 492 /***********************************************************************
 493  *      ScriptFreeCache (USP10.@)
 494  *
 495  * Free a script cache.
 496  *
 497  * PARAMS
 498  *   psc [I/O] Script cache.
 499  *
 500  * RETURNS
 501  *  Success: S_OK
 502  *  Failure: Non-zero HRESULT value.
 503  */
 504 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
 505 {
 506     TRACE("%p\n", psc);
 507
 508     if (psc && *psc)
 509     {
 510         unsigned int i;
 511         for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
 512         {
 513             heap_free(((ScriptCache *)*psc)->glyphs[i]);
 514             heap_free(((ScriptCache *)*psc)->widths[i]);
 515         }
 516         heap_free(((ScriptCache *)*psc)->GSUB_Table);
 517         heap_free(((ScriptCache *)*psc)->GDEF_Table);
 518         heap_free(((ScriptCache *)*psc)->features);
 519         heap_free(*psc);
 520         *psc = NULL;
 521     }
 522     return S_OK;
 523 }
 524
 525 /***********************************************************************
 526  *      ScriptGetProperties (USP10.@)
 527  *
 528  * Retrieve a list of script properties.
 529  *
 530  * PARAMS
 531  *  props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
 532  *  num   [I] Pointer to the number of scripts.
 533  *
 534  * RETURNS
 535  *  Success: S_OK
 536  *  Failure: Non-zero HRESULT value.
 537  *
 538  * NOTES
 539  *  Behaviour matches WinXP.
 540  */
 541 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
 542 {
 543     TRACE("(%p,%p)\n", props, num);
 544
 545     if (!props && !num) return E_INVALIDARG;
 546
 547     if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
 548     if (props) *props = script_props;
 549
 550     return S_OK;
 551 }
 552
 553 /***********************************************************************
 554  *      ScriptGetFontProperties (USP10.@)
 555  *
 556  * Get information on special glyphs.
 557  *
 558  * PARAMS
 559  *  hdc [I]   Device context.
 560  *  psc [I/O] Opaque pointer to a script cache.
 561  *  sfp [O]   Font properties structure.
 562  */
 563 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
 564 {
 565     HRESULT hr;
 566
 567     TRACE("%p,%p,%p\n", hdc, psc, sfp);
 568
 569     if (!sfp) return E_INVALIDARG;
 570     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 571
 572     if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
 573         return E_INVALIDARG;
 574
 575     /* return something sensible? */
 576     sfp->wgBlank = 0;
 577     sfp->wgDefault = get_cache_default_char(psc);
 578     sfp->wgInvalid = 0;
 579     sfp->wgKashida = 0xffff;
 580     sfp->iKashidaWidth = 0;
 581
 582     return S_OK;
 583 }
 584
 585 /***********************************************************************
 586  *      ScriptRecordDigitSubstitution (USP10.@)
 587  *
 588  *  Record digit substitution settings for a given locale.
 589  *
 590  *  PARAMS
 591  *   locale [I] Locale identifier.
 592  *   sds    [I] Structure to record substitution settings.
 593  *
 594  *  RETURNS
 595  *   Success: S_OK
 596  *   Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
 597  *
 598  *  SEE ALSO
 599  *   http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
 600  */
 601 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
 602 {
 603     DWORD plgid, sub;
 604
 605     TRACE("0x%x, %p\n", locale, sds);
 606
 607     /* This implementation appears to be correct for all languages, but it's
 608      * not clear if sds->DigitSubstitute is ever set to anything except
 609      * CONTEXT or NONE in reality */
 610
 611     if (!sds) return E_POINTER;
 612
 613     locale = ConvertDefaultLocale(locale);
 614
 615     if (!IsValidLocale(locale, LCID_INSTALLED))
 616         return E_INVALIDARG;
 617
 618     plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
 619     sds->TraditionalDigitLanguage = plgid;
 620
 621     if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
 622         sds->NationalDigitLanguage = plgid;
 623     else
 624         sds->NationalDigitLanguage = LANG_ENGLISH;
 625
 626     if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
 627                         (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
 628
 629     switch (sub)
 630     {
 631     case 0:
 632         if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
 633             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
 634         else
 635             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
 636         break;
 637     case 1:
 638         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
 639         break;
 640     case 2:
 641         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
 642         break;
 643     default:
 644         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
 645         break;
 646     }
 647
 648     sds->dwReserved = 0;
 649     return S_OK;
 650 }
 651
 652 /***********************************************************************
 653  *      ScriptApplyDigitSubstitution (USP10.@)
 654  *
 655  *  Apply digit substitution settings.
 656  *
 657  *  PARAMS
 658  *   sds [I] Structure with recorded substitution settings.
 659  *   sc  [I] Script control structure.
 660  *   ss  [I] Script state structure.
 661  *
 662  *  RETURNS
 663  *   Success: S_OK
 664  *   Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
 665  */
 666 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds,
 667                                             SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
 668 {
 669     SCRIPT_DIGITSUBSTITUTE psds;
 670
 671     TRACE("%p, %p, %p\n", sds, sc, ss);
 672
 673     if (!sc || !ss) return E_POINTER;
 674     if (!sds)
 675     {
 676         sds = &psds;
 677         if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
 678             return E_INVALIDARG;
 679     }
 680
 681     sc->uDefaultLanguage = LANG_ENGLISH;
 682     sc->fContextDigits = 0;
 683     ss->fDigitSubstitute = 0;
 684
 685     switch (sds->DigitSubstitute) {
 686         case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
 687         case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
 688         case SCRIPT_DIGITSUBSTITUTE_NONE:
 689         case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
 690             return S_OK;
 691         default:
 692             return E_INVALIDARG;
 693     }
 694 }
 695
 696 /***********************************************************************
 697  *      ScriptItemizeOpenType (USP10.@)
 698  *
 699  * Split a Unicode string into shapeable parts.
 700  *
 701  * PARAMS
 702  *  pwcInChars  [I] String to split.
 703  *  cInChars    [I] Number of characters in pwcInChars.
 704  *  cMaxItems   [I] Maximum number of items to return.
 705  *  psControl   [I] Pointer to a SCRIPT_CONTROL structure.
 706  *  psState     [I] Pointer to a SCRIPT_STATE structure.
 707  *  pItems      [O] Buffer to receive SCRIPT_ITEM structures.
 708  *  pScriptTags [O] Buffer to receive OPENTYPE_TAGs.
 709  *  pcItems     [O] Number of script items returned.
 710  *
 711  * RETURNS
 712  *  Success: S_OK
 713  *  Failure: Non-zero HRESULT value.
 714  */
 715 HRESULT WINAPI ScriptItemizeOpenType(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
 716                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
 717                              SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
 718 {
 719
 720 #define Numeric_space 0x0020
 721 #define ZWNJ 0x200C
 722 #define ZWJ  0x200D
 723
 724     int   cnt = 0, index = 0, str = 0;
 725     int   New_Script = SCRIPT_UNDEFINED;
 726     WORD  *levels = NULL;
 727     WORD  *strength = NULL;
 728     WORD  baselevel = 0;
 729
 730     TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems,
 731           psControl, psState, pItems, pcItems);
 732
 733     if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
 734         return E_INVALIDARG;
 735
 736     if (psState && psControl)
 737     {
 738         int i;
 739         levels = heap_alloc_zero(cInChars * sizeof(WORD));
 740         if (!levels)
 741             return E_OUTOFMEMORY;
 742
 743         BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels);
 744         baselevel = levels[0];
 745         for (i = 0; i < cInChars; i++)
 746             if (levels[i]!=levels[0])
 747                 break;
 748         if (i >= cInChars && !odd(baselevel))
 749         {
 750             heap_free(levels);
 751             levels = NULL;
 752         }
 753         else
 754         {
 755             if (!psControl->fMergeNeutralItems)
 756             {
 757                 strength = heap_alloc_zero(cInChars * sizeof(WORD));
 758                 BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
 759             }
 760         }
 761     }
 762
 763     while ((pwcInChars[cnt] == Numeric_space || pwcInChars[cnt] == ZWJ || pwcInChars[cnt] == ZWNJ) && cnt < cInChars)
 764         cnt++;
 765
 766     if (cnt == cInChars) /* All Spaces */
 767     {
 768         cnt = 0;
 769         New_Script = get_char_script(pwcInChars[cnt]);
 770     }
 771
 772     pItems[index].iCharPos = 0;
 773     pItems[index].a = scriptInformation[get_char_script(pwcInChars[cnt])].a;
 774     pScriptTags[index] = scriptInformation[get_char_script(pwcInChars[cnt])].scriptTag;
 775
 776     if (strength)
 777         str = strength[cnt];
 778
 779     cnt = 0;
 780     if (levels)
 781     {
 782         pItems[index].a.fRTL = odd(levels[cnt]);
 783         pItems[index].a.fLayoutRTL = odd(levels[cnt]);
 784         pItems[index].a.s.uBidiLevel = levels[cnt];
 785     }
 786     else if (!pItems[index].a.s.uBidiLevel)
 787     {
 788         pItems[index].a.s.uBidiLevel = baselevel;
 789         pItems[index].a.fLayoutRTL = odd(baselevel);
 790         pItems[index].a.fRTL = odd(baselevel);
 791     }
 792
 793     TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
 794           levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
 795           pItems[index].iCharPos);
 796
 797     for (cnt=1; cnt < cInChars; cnt++)
 798     {
 799         if (levels && (levels[cnt] == pItems[index].a.s.uBidiLevel && (!strength || (strength[cnt] == 0 || strength[cnt] == str))))
 800             continue;
 801
 802         if(pwcInChars[cnt] != Numeric_space && pwcInChars[cnt] != ZWJ && pwcInChars[cnt] != ZWNJ)
 803             New_Script = get_char_script(pwcInChars[cnt]);
 804         else if (levels)
 805         {
 806             int j = 1;
 807             while (cnt + j < cInChars - 1 && (pwcInChars[cnt+j] == Numeric_space || pwcInChars[cnt+j] == ZWJ || pwcInChars[cnt+j] == ZWNJ))
 808                 j++;
 809             New_Script = get_char_script(pwcInChars[cnt+j]);
 810         }
 811
 812         if ((levels && (levels[cnt] != pItems[index].a.s.uBidiLevel || (strength && (strength[cnt] != str)))) || New_Script != pItems[index].a.eScript || New_Script == Script_Control)
 813         {
 814             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);
 815
 816             if (strength && strength[cnt] != 0)
 817                 str = strength[cnt];
 818
 819             index++;
 820             if  (index+1 > cMaxItems)
 821                 return E_OUTOFMEMORY;
 822
 823             pItems[index].iCharPos = cnt;
 824             memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
 825
 826             pItems[index].a = scriptInformation[New_Script].a;
 827             pScriptTags[index] = scriptInformation[New_Script].scriptTag;
 828             if (levels)
 829             {
 830                 pItems[index].a.fRTL = odd(levels[cnt]);
 831                 pItems[index].a.fLayoutRTL = odd(levels[cnt]);
 832                 pItems[index].a.s.uBidiLevel = levels[cnt];
 833             }
 834             else if (!pItems[index].a.s.uBidiLevel)
 835             {
 836                 pItems[index].a.s.uBidiLevel = baselevel;
 837                 pItems[index].a.fLayoutRTL = odd(baselevel);
 838                 pItems[index].a.fRTL = odd(baselevel);
 839             }
 840
 841             TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
 842         }
 843     }
 844
 845     /* While not strictly necessary according to the spec, make sure the n+1
 846      * item is set up to prevent random behaviour if the caller erroneously
 847      * checks the n+1 structure                                              */
 848     index++;
 849     memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
 850
 851     TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
 852
 853     /*  Set one SCRIPT_STATE item being returned  */
 854     if  (index + 1 > cMaxItems) return E_OUTOFMEMORY;
 855     if (pcItems) *pcItems = index;
 856
 857     /*  Set SCRIPT_ITEM                                     */
 858     pItems[index].iCharPos = cnt;         /* the last item contains the ptr to the lastchar */
 859     heap_free(levels);
 860     heap_free(strength);
 861     return S_OK;
 862 }
 863
 864 /***********************************************************************
 865  *      ScriptItemize (USP10.@)
 866  *
 867  * Split a Unicode string into shapeable parts.
 868  *
 869  * PARAMS
 870  *  pwcInChars [I] String to split.
 871  *  cInChars   [I] Number of characters in pwcInChars.
 872  *  cMaxItems  [I] Maximum number of items to return.
 873  *  psControl  [I] Pointer to a SCRIPT_CONTROL structure.
 874  *  psState    [I] Pointer to a SCRIPT_STATE structure.
 875  *  pItems     [O] Buffer to receive SCRIPT_ITEM structures.
 876  *  pcItems    [O] Number of script items returned.
 877  *
 878  * RETURNS
 879  *  Success: S_OK
 880  *  Failure: Non-zero HRESULT value.
 881  */
 882 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
 883                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
 884                              SCRIPT_ITEM *pItems, int *pcItems)
 885 {
 886     OPENTYPE_TAG *discarded_tags;
 887     HRESULT res;
 888
 889     discarded_tags = heap_alloc(cMaxItems * sizeof(OPENTYPE_TAG));
 890     if (!discarded_tags)
 891         return E_OUTOFMEMORY;
 892     res = ScriptItemizeOpenType(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, discarded_tags, pcItems);
 893     heap_free(discarded_tags);
 894     return res;
 895 }
 896
 897 /***********************************************************************
 898  *      ScriptStringAnalyse (USP10.@)
 899  *
 900  */
 901 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
 902                                    int cGlyphs, int iCharset, DWORD dwFlags,
 903                                    int iReqWidth, SCRIPT_CONTROL *psControl,
 904                                    SCRIPT_STATE *psState, const int *piDx,
 905                                    SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
 906                                    SCRIPT_STRING_ANALYSIS *pssa)
 907 {
 908     HRESULT hr = E_OUTOFMEMORY;
 909     StringAnalysis *analysis = NULL;
 910     int i, num_items = 255;
 911
 912     TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
 913           hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
 914           psControl, psState, piDx, pTabdef, pbInClass, pssa);
 915
 916     if (iCharset != -1)
 917     {
 918         FIXME("Only Unicode strings are supported\n");
 919         return E_INVALIDARG;
 920     }
 921     if (cString < 1 || !pString) return E_INVALIDARG;
 922     if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
 923
 924     if (!(analysis = heap_alloc_zero(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
 925     if (!(analysis->pItem = heap_alloc_zero(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
 926
 927     /* FIXME: handle clipping */
 928     analysis->clip_len = cString;
 929     analysis->hdc = hdc;
 930
 931     hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
 932                        &analysis->numItems);
 933
 934     while (hr == E_OUTOFMEMORY)
 935     {
 936         SCRIPT_ITEM *tmp;
 937
 938         num_items *= 2;
 939         if (!(tmp = heap_realloc_zero(analysis->pItem, num_items * sizeof(SCRIPT_ITEM) + 1)))
 940             goto error;
 941
 942         analysis->pItem = tmp;
 943         hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
 944                            &analysis->numItems);
 945     }
 946     if (hr != S_OK) goto error;
 947
 948     if ((analysis->logattrs = heap_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
 949         ScriptBreak(pString, cString, (SCRIPT_STRING_ANALYSIS)analysis, analysis->logattrs);
 950     else
 951         goto error;
 952
 953     if (!(analysis->glyphs = heap_alloc_zero(sizeof(StringGlyphs) * analysis->numItems)))
 954         goto error;
 955
 956     for (i = 0; i < analysis->numItems; i++)
 957     {
 958         SCRIPT_CACHE *sc = (SCRIPT_CACHE *)&analysis->sc;
 959         int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
 960         int numGlyphs = 1.5 * cChar + 16;
 961         WORD *glyphs = heap_alloc_zero(sizeof(WORD) * numGlyphs);
 962         WORD *pwLogClust = heap_alloc_zero(sizeof(WORD) * cChar);
 963         int *piAdvance = heap_alloc_zero(sizeof(int) * numGlyphs);
 964         SCRIPT_VISATTR *psva = heap_alloc_zero(sizeof(SCRIPT_VISATTR) * cChar);
 965         GOFFSET *pGoffset = heap_alloc_zero(sizeof(GOFFSET) * numGlyphs);
 966         ABC *abc = heap_alloc_zero(sizeof(ABC));
 967         int numGlyphsReturned;
 968
 969         /* FIXME: non unicode strings */
 970         const WCHAR* pStr = (const WCHAR*)pString;
 971         hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
 972                          cChar, numGlyphs, &analysis->pItem[i].a,
 973                          glyphs, pwLogClust, psva, &numGlyphsReturned);
 974         hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
 975                          piAdvance, pGoffset, abc);
 976
 977         analysis->glyphs[i].numGlyphs = numGlyphsReturned;
 978         analysis->glyphs[i].glyphs = glyphs;
 979         analysis->glyphs[i].pwLogClust = pwLogClust;
 980         analysis->glyphs[i].piAdvance = piAdvance;
 981         analysis->glyphs[i].psva = psva;
 982         analysis->glyphs[i].pGoffset = pGoffset;
 983         analysis->glyphs[i].abc = abc;
 984         analysis->glyphs[i].iMaxPosX= -1;
 985     }
 986
 987     *pssa = analysis;
 988     return S_OK;
 989
 990 error:
 991     heap_free(analysis->glyphs);
 992     heap_free(analysis->logattrs);
 993     heap_free(analysis->pItem);
 994     heap_free(analysis->sc);
 995     heap_free(analysis);
 996     return hr;
 997 }
 998
 999 /***********************************************************************
1000  *      ScriptStringOut (USP10.@)
1001  *
1002  * This function takes the output of ScriptStringAnalyse and joins the segments
1003  * of glyphs and passes the resulting string to ScriptTextOut.  ScriptStringOut
1004  * only processes glyphs.
1005  *
1006  * Parameters:
1007  *  ssa       [I] buffer to hold the analysed string components
1008  *  iX        [I] X axis displacement for output
1009  *  iY        [I] Y axis displacement for output
1010  *  uOptions  [I] flags controling output processing
1011  *  prc       [I] rectangle coordinates
1012  *  iMinSel   [I] starting pos for substringing output string
1013  *  iMaxSel   [I] ending pos for substringing output string
1014  *  fDisabled [I] controls text highlighting
1015  *
1016  *  RETURNS
1017  *   Success: S_OK
1018  *   Failure: is the value returned by ScriptTextOut
1019  */
1020 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
1021                                int iX,
1022                                int iY,
1023                                UINT uOptions,
1024                                const RECT *prc,
1025                                int iMinSel,
1026                                int iMaxSel,
1027                                BOOL fDisabled)
1028 {
1029     StringAnalysis *analysis;
1030     WORD *glyphs;
1031     int   item, cnt, x;
1032     HRESULT hr;
1033
1034     TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
1035          ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
1036
1037     if (!(analysis = ssa)) return E_INVALIDARG;
1038
1039     /*
1040      * Get storage for the output buffer for the consolidated strings
1041      */
1042     cnt = 0;
1043     for (item = 0; item < analysis->numItems; item++)
1044     {
1045         cnt += analysis->glyphs[item].numGlyphs;
1046     }
1047     if (!(glyphs = heap_alloc(sizeof(WCHAR) * cnt))) return E_OUTOFMEMORY;
1048
1049     /*
1050      * ScriptStringOut only processes glyphs hence set ETO_GLYPH_INDEX
1051      */
1052     uOptions |= ETO_GLYPH_INDEX;
1053     analysis->pItem[0].a.fNoGlyphIndex = FALSE; /* say that we have glyphs */
1054
1055     /*
1056      * Copy the string items into the output buffer
1057      */
1058
1059     TRACE("numItems %d\n", analysis->numItems);
1060
1061     cnt = 0;
1062     for (item = 0; item < analysis->numItems; item++)
1063     {
1064         memcpy(&glyphs[cnt], analysis->glyphs[item].glyphs,
1065               sizeof(WCHAR) * analysis->glyphs[item].numGlyphs);
1066
1067         TRACE("Item %d, Glyphs %d ", item, analysis->glyphs[item].numGlyphs);
1068         for (x = cnt; x < analysis->glyphs[item].numGlyphs + cnt; x ++)
1069             TRACE("%04x", glyphs[x]);
1070         TRACE("\n");
1071
1072         cnt += analysis->glyphs[item].numGlyphs; /* point to the end of the copied text */
1073     }
1074
1075     hr = ScriptTextOut(analysis->hdc, (SCRIPT_CACHE *)&analysis->sc, iX, iY,
1076                        uOptions, prc, &analysis->pItem->a, NULL, 0, glyphs, cnt,
1077                        analysis->glyphs->piAdvance, NULL, analysis->glyphs->pGoffset);
1078     TRACE("ScriptTextOut hr=%08x\n", hr);
1079
1080     /*
1081      * Free the output buffer and script cache
1082      */
1083     heap_free(glyphs);
1084     return hr;
1085 }
1086
1087 /***********************************************************************
1088  *      ScriptStringCPtoX (USP10.@)
1089  *
1090  */
1091 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
1092 {
1093     int i;
1094     int runningX = 0;
1095     StringAnalysis* analysis = ssa;
1096
1097     TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
1098
1099     if (!ssa || !pX) return S_FALSE;
1100
1101     /* icp out of range */
1102     if(icp < 0)
1103     {
1104         analysis->invalid = TRUE;
1105         return E_INVALIDARG;
1106     }
1107
1108     for(i=0; i<analysis->numItems; i++)
1109     {
1110         int CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1111         int offset;
1112         /* initialize max extents for uninitialized runs */
1113         if (analysis->glyphs[i].iMaxPosX == -1)
1114         {
1115             if (analysis->pItem[i].a.fRTL)
1116                 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1117                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1118                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1119             else
1120                 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1121                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1122                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1123         }
1124
1125         if (icp >= CP)
1126         {
1127             runningX += analysis->glyphs[i].iMaxPosX;
1128             icp -= CP;
1129             continue;
1130         }
1131
1132         ScriptCPtoX(icp, fTrailing, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1133                     analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1134                     &analysis->pItem[i].a, &offset);
1135         runningX += offset;
1136
1137         *pX = runningX;
1138         return S_OK;
1139     }
1140
1141     /* icp out of range */
1142     analysis->invalid = TRUE;
1143     return E_INVALIDARG;
1144 }
1145
1146 /***********************************************************************
1147  *      ScriptStringXtoCP (USP10.@)
1148  *
1149  */
1150 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing)
1151 {
1152     StringAnalysis* analysis = ssa;
1153     int i;
1154     int runningCp = 0;
1155
1156     TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
1157
1158     if (!ssa || !piCh || !piTrailing) return S_FALSE;
1159
1160     /* out of range */
1161     if(iX < 0)
1162     {
1163         if (analysis->pItem[0].a.fRTL)
1164         {
1165             *piCh = 1;
1166             *piTrailing = FALSE;
1167         }
1168         else
1169         {
1170             *piCh = -1;
1171             *piTrailing = TRUE;
1172         }
1173         return S_OK;
1174     }
1175
1176     for(i=0; i<analysis->numItems; i++)
1177     {
1178         int CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1179         /* initialize max extents for uninitialized runs */
1180         if (analysis->glyphs[i].iMaxPosX == -1)
1181         {
1182             if (analysis->pItem[i].a.fRTL)
1183                 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1184                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1185                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1186             else
1187                 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1188                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1189                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1190         }
1191
1192         if (iX > analysis->glyphs[i].iMaxPosX)
1193         {
1194             iX -= analysis->glyphs[i].iMaxPosX;
1195             runningCp += CP;
1196             continue;
1197         }
1198
1199         ScriptXtoCP(iX, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1200                     analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1201                     &analysis->pItem[i].a, piCh, piTrailing);
1202         *piCh += runningCp;
1203
1204         return S_OK;
1205     }
1206
1207     /* out of range */
1208     *piCh = analysis->pItem[analysis->numItems].iCharPos;
1209     *piTrailing = FALSE;
1210
1211     return S_OK;
1212 }
1213
1214
1215 /***********************************************************************
1216  *      ScriptStringFree (USP10.@)
1217  *
1218  * Free a string analysis.
1219  *
1220  * PARAMS
1221  *  pssa [I] string analysis.
1222  *
1223  * RETURNS
1224  *  Success: S_OK
1225  *  Failure: Non-zero HRESULT value.
1226  */
1227 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
1228 {
1229     StringAnalysis* analysis;
1230     BOOL invalid;
1231     int i;
1232
1233     TRACE("(%p)\n", pssa);
1234
1235     if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
1236
1237     invalid = analysis->invalid;
1238     ScriptFreeCache((SCRIPT_CACHE *)&analysis->sc);
1239
1240     for (i = 0; i < analysis->numItems; i++)
1241     {
1242         heap_free(analysis->glyphs[i].glyphs);
1243         heap_free(analysis->glyphs[i].pwLogClust);
1244         heap_free(analysis->glyphs[i].piAdvance);
1245         heap_free(analysis->glyphs[i].psva);
1246         heap_free(analysis->glyphs[i].pGoffset);
1247         heap_free(analysis->glyphs[i].abc);
1248     }
1249
1250     heap_free(analysis->glyphs);
1251     heap_free(analysis->pItem);
1252     heap_free(analysis->logattrs);
1253     heap_free(analysis->sz);
1254     heap_free(analysis->sc);
1255     heap_free(analysis);
1256
1257     if (invalid) return E_INVALIDARG;
1258     return S_OK;
1259 }
1260
1261 /***********************************************************************
1262  *      ScriptCPtoX (USP10.@)
1263  *
1264  */
1265 HRESULT WINAPI ScriptCPtoX(int iCP,
1266                            BOOL fTrailing,
1267                            int cChars,
1268                            int cGlyphs,
1269                            const WORD *pwLogClust,
1270                            const SCRIPT_VISATTR *psva,
1271                            const int *piAdvance,
1272                            const SCRIPT_ANALYSIS *psa,
1273                            int *piX)
1274 {
1275     int item;
1276     float iPosX;
1277     int iSpecial = -1;
1278     int iCluster = -1;
1279     int clust_size = 1;
1280     float special_size = 0.0;
1281     int iMaxPos = 0;
1282     BOOL rtl = FALSE;
1283
1284     TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
1285           iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
1286           psa, piX);
1287
1288     if (psa->fRTL && ! psa->fLogicalOrder)
1289         rtl = TRUE;
1290
1291     if (fTrailing)
1292         iCP++;
1293
1294     if (rtl)
1295     {
1296         int max_clust = pwLogClust[0];
1297
1298         for (item=0; item < cGlyphs; item++)
1299             if (pwLogClust[item] > max_clust)
1300             {
1301                 ERR("We do not handle non reversed clusters properly\n");
1302                 break;
1303             }
1304
1305         iMaxPos = 0;
1306         for (item = max_clust; item >=0; item --)
1307             iMaxPos += piAdvance[item];
1308     }
1309
1310     iPosX = 0.0;
1311     for (item=0; item < iCP && item < cGlyphs; item++)
1312     {
1313         if (iSpecial == -1 && (iCluster == -1 || (iCluster != -1 && iCluster+clust_size <= item)))
1314         {
1315             int check;
1316             int clust = pwLogClust[item];
1317
1318             clust_size = 1;
1319             iCluster = -1;
1320
1321             for (check = item+1; check < cGlyphs; check++)
1322             {
1323                 if (pwLogClust[check] == clust)
1324                 {
1325                     clust_size ++;
1326                     if (iCluster == -1)
1327                         iCluster = item;
1328                 }
1329                 else break;
1330             }
1331
1332             if (check >= cGlyphs && !iMaxPos)
1333             {
1334                 for (check = clust; check < cGlyphs; check++)
1335                     special_size += piAdvance[check];
1336                 iSpecial = item;
1337                 special_size /= (cChars - item);
1338                 iPosX += special_size;
1339             }
1340             else
1341                 iPosX += piAdvance[clust] / (float)clust_size;
1342         }
1343         else if (iSpecial != -1)
1344             iPosX += special_size;
1345         else /* (iCluster != -1) */
1346             iPosX += piAdvance[pwLogClust[iCluster]] / (float)clust_size;
1347     }
1348
1349     if (iMaxPos > 0)
1350     {
1351         iPosX = iMaxPos - iPosX;
1352         if (iPosX < 0)
1353             iPosX = 0;
1354     }
1355
1356     *piX = iPosX;
1357     TRACE("*piX=%d\n", *piX);
1358     return S_OK;
1359 }
1360
1361 /***********************************************************************
1362  *      ScriptXtoCP (USP10.@)
1363  *
1364  */
1365 HRESULT WINAPI ScriptXtoCP(int iX,
1366                            int cChars,
1367                            int cGlyphs,
1368                            const WORD *pwLogClust,
1369                            const SCRIPT_VISATTR *psva,
1370                            const int *piAdvance,
1371                            const SCRIPT_ANALYSIS *psa,
1372                            int *piCP,
1373                            int *piTrailing)
1374 {
1375     int item;
1376     float iPosX;
1377     float iLastPosX;
1378     int iSpecial = -1;
1379     int iCluster = -1;
1380     int clust_size = 1;
1381     float special_size = 0.0;
1382     int direction = 1;
1383
1384     TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
1385           iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
1386           psa, piCP, piTrailing);
1387
1388     if (psa->fRTL && ! psa->fLogicalOrder)
1389         direction = -1;
1390
1391     if (direction<0)
1392     {
1393         int max_clust = pwLogClust[0];
1394
1395         if (iX < 0)
1396         {
1397             *piCP = cGlyphs;
1398             *piTrailing = 0;
1399             return S_OK;
1400         }
1401
1402         for (item=0; item < cGlyphs; item++)
1403             if (pwLogClust[item] > max_clust)
1404             {
1405                 ERR("We do not handle non reversed clusters properly\n");
1406                 break;
1407             }
1408     }
1409
1410     if (iX < 0)
1411     {
1412         *piCP = -1;
1413         *piTrailing = 1;
1414         return S_OK;
1415     }
1416
1417     iPosX = iLastPosX = 0;
1418     if (direction > 0)
1419         item = 0;
1420     else
1421         item = cGlyphs - 1;
1422     for (; iPosX <= iX && item < cGlyphs && item >= 0; item+=direction)
1423     {
1424         iLastPosX = iPosX;
1425         if (iSpecial == -1 &&
1426              (iCluster == -1 ||
1427               (iCluster != -1 &&
1428                  ((direction > 0 && iCluster+clust_size <= item) ||
1429                   (direction < 0 && iCluster-clust_size >= item))
1430               )
1431              )
1432             )
1433         {
1434             int check;
1435             int clust = pwLogClust[item];
1436
1437             clust_size = 1;
1438             iCluster = -1;
1439
1440             for (check = item+direction; check < cGlyphs && check >= 0; check+=direction)
1441             {
1442                 if (pwLogClust[check] == clust)
1443                 {
1444                     clust_size ++;
1445                     if (iCluster == -1)
1446                         iCluster = item;
1447                 }
1448                 else break;
1449             }
1450
1451             if (check >= cGlyphs && direction > 0)
1452             {
1453                 for (check = clust; check < cGlyphs; check++)
1454                     special_size += piAdvance[check];
1455                 iSpecial = item;
1456                 special_size /= (cChars - item);
1457                 iPosX += special_size;
1458             }
1459             else
1460                 iPosX += piAdvance[clust] / (float)clust_size;
1461         }
1462         else if (iSpecial != -1)
1463             iPosX += special_size;
1464         else /* (iCluster != -1) */
1465             iPosX += piAdvance[pwLogClust[iCluster]] / (float)clust_size;
1466     }
1467
1468     if (direction > 0)
1469     {
1470         if (iPosX > iX)
1471             item--;
1472         if (item < cGlyphs && ((iPosX - iLastPosX) / 2.0) + iX > iPosX)
1473             *piTrailing = 1;
1474         else
1475             *piTrailing = 0;
1476     }
1477     else
1478     {
1479         if (iX == iLastPosX)
1480             item++;
1481         if (iX >= iLastPosX && iX <= iPosX)
1482             item++;
1483
1484         if (iLastPosX == iX)
1485             *piTrailing = 0;
1486         else if (item < 0 || ((iLastPosX - iPosX) / 2.0) + iX <= iLastPosX)
1487             *piTrailing = 1;
1488         else
1489             *piTrailing = 0;
1490     }
1491
1492     *piCP = item;
1493
1494     TRACE("*piCP=%d\n", *piCP);
1495     TRACE("*piTrailing=%d\n", *piTrailing);
1496     return S_OK;
1497 }
1498
1499 /***********************************************************************
1500  *      ScriptBreak (USP10.@)
1501  *
1502  *  Retrieve line break information.
1503  *
1504  *  PARAMS
1505  *   chars [I] Array of characters.
1506  *   sa    [I] String analysis.
1507  *   la    [I] Array of logical attribute structures.
1508  *
1509  *  RETURNS
1510  *   Success: S_OK
1511  *   Failure: S_FALSE
1512  */
1513 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
1514 {
1515     int i;
1516
1517     TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
1518
1519     if (!la) return S_FALSE;
1520
1521     for (i = 0; i < count; i++)
1522     {
1523         memset(&la[i], 0, sizeof(SCRIPT_LOGATTR));
1524
1525         /* FIXME: set the other flags */
1526         la[i].fWhiteSpace = (chars[i] == ' ');
1527         la[i].fCharStop = 1;
1528
1529         if (i > 0 && la[i - 1].fWhiteSpace)
1530         {
1531             la[i].fSoftBreak = 1;
1532             la[i].fWordStop = 1;
1533         }
1534     }
1535     return S_OK;
1536 }
1537
1538 /***********************************************************************
1539  *      ScriptIsComplex (USP10.@)
1540  *
1541  *  Determine if a string is complex.
1542  *
1543  *  PARAMS
1544  *   chars [I] Array of characters to test.
1545  *   len   [I] Length in characters.
1546  *   flag  [I] Flag.
1547  *
1548  *  RETURNS
1549  *   Success: S_OK
1550  *   Failure: S_FALSE
1551  *
1552  */
1553 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
1554 {
1555     int i;
1556
1557     TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
1558
1559     for (i = 0; i < len; i++)
1560     {
1561         int script;
1562
1563         if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
1564             return S_OK;
1565
1566         script = get_char_script(chars[i]);
1567         if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
1568             (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
1569             return S_OK;
1570     }
1571     return S_FALSE;
1572 }
1573
1574 /***********************************************************************
1575  *      ScriptShapeOpenType (USP10.@)
1576  *
1577  * Produce glyphs and visual attributes for a run.
1578  *
1579  * PARAMS
1580  *  hdc         [I]   Device context.
1581  *  psc         [I/O] Opaque pointer to a script cache.
1582  *  psa         [I/O] Script analysis.
1583  *  tagScript   [I]   The OpenType tag for the Script
1584  *  tagLangSys  [I]   The OpenType tag for the Language
1585  *  rcRangeChars[I]   Array of Character counts in each range
1586  *  rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
1587  *  cRanges     [I]   Count of ranges
1588  *  pwcChars    [I]   Array of characters specifying the run.
1589  *  cChars      [I]   Number of characters in pwcChars.
1590  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
1591  *  pwLogClust  [O]   Array of logical cluster info.
1592  *  pCharProps  [O]   Array of character property values
1593  *  pwOutGlyphs [O]   Array of glyphs.
1594  *  pOutGlyphProps [O]  Array of attributes for the retrieved glyphs
1595  *  pcGlyphs    [O]   Number of glyphs returned.
1596  *
1597  * RETURNS
1598  *  Success: S_OK
1599  *  Failure: Non-zero HRESULT value.
1600  */
1601 HRESULT WINAPI ScriptShapeOpenType( HDC hdc, SCRIPT_CACHE *psc,
1602                                     SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript,
1603                                     OPENTYPE_TAG tagLangSys, int *rcRangeChars,
1604                                     TEXTRANGE_PROPERTIES **rpRangeProperties,
1605                                     int cRanges, const WCHAR *pwcChars, int cChars,
1606                                     int cMaxGlyphs, WORD *pwLogClust,
1607                                     SCRIPT_CHARPROP *pCharProps, WORD *pwOutGlyphs,
1608                                     SCRIPT_GLYPHPROP *pOutGlyphProps, int *pcGlyphs)
1609 {
1610     HRESULT hr;
1611     unsigned int i;
1612     BOOL rtl;
1613
1614     TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %d, %d, %p, %p, %p, %p, %p )\n",
1615      hdc, psc, psa,
1616      debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
1617      rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
1618      cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
1619
1620     if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
1621                    psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
1622
1623     if (!pOutGlyphProps || !pcGlyphs || !pCharProps) return E_INVALIDARG;
1624     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
1625
1626     if (cRanges)
1627         FIXME("Ranges not supported yet\n");
1628
1629     rtl = (!psa->fLogicalOrder && psa->fRTL);
1630
1631     *pcGlyphs = cChars;
1632     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1633     if (!pwLogClust) return E_FAIL;
1634
1635     ((ScriptCache *)*psc)->userScript = tagScript;
1636     ((ScriptCache *)*psc)->userLang = tagLangSys;
1637
1638     /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
1639     for (i = 0; i < cChars; i++)
1640     {
1641         int idx = i;
1642         if (rtl) idx = cChars - 1 - i;
1643         /* FIXME: set to better values */
1644         pOutGlyphProps[i].sva.uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
1645         pOutGlyphProps[i].sva.fClusterStart  = 1;
1646         pOutGlyphProps[i].sva.fDiacritic     = 0;
1647         pOutGlyphProps[i].sva.fZeroWidth     = 0;
1648         pOutGlyphProps[i].sva.fReserved      = 0;
1649         pOutGlyphProps[i].sva.fShapeReserved = 0;
1650
1651         /* FIXME: have the shaping engine set this */
1652         pCharProps[i].fCanGlyphAlone = 0;
1653
1654         pwLogClust[i] = idx;
1655     }
1656
1657     if (!psa->fNoGlyphIndex)
1658     {
1659         WCHAR *rChars;
1660         if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
1661
1662         rChars = heap_alloc(sizeof(WCHAR) * cChars);
1663         if (!rChars) return E_OUTOFMEMORY;
1664         for (i = 0; i < cChars; i++)
1665         {
1666             int idx = i;
1667             WCHAR chInput;
1668             if (rtl) idx = cChars - 1 - i;
1669             if (psa->fRTL)
1670                 chInput = mirror_char(pwcChars[idx]);
1671             else
1672                 chInput = pwcChars[idx];
1673             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, chInput)))
1674             {
1675                 WORD glyph;
1676                 if (!hdc) return E_PENDING;
1677                 if (GetGlyphIndicesW(hdc, &chInput, 1, &glyph, 0) == GDI_ERROR) return S_FALSE;
1678                 pwOutGlyphs[i] = set_cache_glyph(psc, chInput, glyph);
1679             }
1680             rChars[i] = chInput;
1681         }
1682
1683         if (get_cache_pitch_family(psc) & TMPF_TRUETYPE)
1684         {
1685             SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
1686             SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
1687             SHAPE_CharGlyphProp(hdc, (ScriptCache *)*psc, psa, pwcChars, cChars, pwOutGlyphs, *pcGlyphs, pwLogClust, pCharProps, pOutGlyphProps);
1688         }
1689         heap_free(rChars);
1690     }
1691     else
1692     {
1693         TRACE("no glyph translation\n");
1694         for (i = 0; i < cChars; i++)
1695         {
1696             int idx = i;
1697             /* No mirroring done here */
1698             if (rtl) idx = cChars - 1 - i;
1699             pwOutGlyphs[i] = pwcChars[idx];
1700         }
1701     }
1702
1703     return S_OK;
1704 }
1705
1706
1707 /***********************************************************************
1708  *      ScriptShape (USP10.@)
1709  *
1710  * Produce glyphs and visual attributes for a run.
1711  *
1712  * PARAMS
1713  *  hdc         [I]   Device context.
1714  *  psc         [I/O] Opaque pointer to a script cache.
1715  *  pwcChars    [I]   Array of characters specifying the run.
1716  *  cChars      [I]   Number of characters in pwcChars.
1717  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
1718  *  psa         [I/O] Script analysis.
1719  *  pwOutGlyphs [O]   Array of glyphs.
1720  *  pwLogClust  [O]   Array of logical cluster info.
1721  *  psva        [O]   Array of visual attributes.
1722  *  pcGlyphs    [O]   Number of glyphs returned.
1723  *
1724  * RETURNS
1725  *  Success: S_OK
1726  *  Failure: Non-zero HRESULT value.
1727  */
1728 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars,
1729                            int cChars, int cMaxGlyphs,
1730                            SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
1731                            SCRIPT_VISATTR *psva, int *pcGlyphs)
1732 {
1733     HRESULT hr;
1734     int i;
1735     SCRIPT_CHARPROP *charProps;
1736     SCRIPT_GLYPHPROP *glyphProps;
1737
1738     if (!psva || !pcGlyphs) return E_INVALIDARG;
1739     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
1740
1741     charProps = heap_alloc_zero(sizeof(SCRIPT_CHARPROP)*cChars);
1742     if (!charProps) return E_OUTOFMEMORY;
1743     glyphProps = heap_alloc_zero(sizeof(SCRIPT_GLYPHPROP)*cMaxGlyphs);
1744     if (!glyphProps) return E_OUTOFMEMORY;
1745
1746     hr = ScriptShapeOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, pwcChars, cChars, cMaxGlyphs, pwLogClust, charProps, pwOutGlyphs, glyphProps, pcGlyphs);
1747
1748     if (SUCCEEDED(hr))
1749     {
1750         for (i = 0; i < *pcGlyphs; i++)
1751             psva[i] = glyphProps[i].sva;
1752     }
1753
1754     heap_free(charProps);
1755     heap_free(glyphProps);
1756
1757     return hr;
1758 }
1759
1760 /***********************************************************************
1761  *      ScriptPlaceOpenType (USP10.@)
1762  *
1763  * Produce advance widths for a run.
1764  *
1765  * PARAMS
1766  *  hdc       [I]   Device context.
1767  *  psc       [I/O] Opaque pointer to a script cache.
1768  *  psa       [I/O] String analysis.
1769  *  tagScript   [I]   The OpenType tag for the Script
1770  *  tagLangSys  [I]   The OpenType tag for the Language
1771  *  rcRangeChars[I]   Array of Character counts in each range
1772  *  rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
1773  *  cRanges     [I]   Count of ranges
1774  *  pwcChars    [I]   Array of characters specifying the run.
1775  *  pwLogClust  [I]   Array of logical cluster info
1776  *  pCharProps  [I]   Array of character property values
1777  *  cChars      [I]   Number of characters in pwcChars.
1778  *  pwGlyphs  [I]   Array of glyphs.
1779  *  pGlyphProps [I]  Array of attributes for the retrieved glyphs
1780  *  cGlyphs [I] Count of Glyphs
1781  *  piAdvance [O]   Array of advance widths.
1782  *  pGoffset  [O]   Glyph offsets.
1783  *  pABC      [O]   Combined ABC width.
1784  *
1785  * RETURNS
1786  *  Success: S_OK
1787  *  Failure: Non-zero HRESULT value.
1788  */
1789
1790 HRESULT WINAPI ScriptPlaceOpenType( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
1791                                     OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys,
1792                                     int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties,
1793                                     int cRanges, const WCHAR *pwcChars, WORD *pwLogClust,
1794                                     SCRIPT_CHARPROP *pCharProps, int cChars,
1795                                     const WORD *pwGlyphs, const SCRIPT_GLYPHPROP *pGlyphProps,
1796                                     int cGlyphs, int *piAdvance,
1797                                     GOFFSET *pGoffset, ABC *pABC
1798 )
1799 {
1800     HRESULT hr;
1801     int i;
1802
1803     TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %p, %p, %d, %p, %p, %d, %p %p %p)\n",
1804      hdc, psc, psa,
1805      debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
1806      rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
1807      pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance,
1808      pGoffset, pABC);
1809
1810     if (!pGlyphProps) return E_INVALIDARG;
1811     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1812     if (!pGoffset) return E_FAIL;
1813
1814     if (cRanges)
1815         FIXME("Ranges not supported yet\n");
1816
1817     ((ScriptCache *)*psc)->userScript = tagScript;
1818     ((ScriptCache *)*psc)->userLang = tagLangSys;
1819
1820     if (pABC) memset(pABC, 0, sizeof(ABC));
1821     for (i = 0; i < cGlyphs; i++)
1822     {
1823         ABC abc;
1824         if (!get_cache_glyph_widths(psc, pwGlyphs[i], &abc))
1825         {
1826             if (!hdc) return E_PENDING;
1827             if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE) && !psa->fNoGlyphIndex)
1828             {
1829                 if (!GetCharABCWidthsI(hdc, 0, 1, (WORD *)&pwGlyphs[i], &abc)) return S_FALSE;
1830             }
1831             else
1832             {
1833                 INT width;
1834                 if (!GetCharWidth32W(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
1835                 abc.abcB = width;
1836                 abc.abcA = abc.abcC = 0;
1837             }
1838             set_cache_glyph_widths(psc, pwGlyphs[i], &abc);
1839         }
1840         if (pABC)
1841         {
1842             pABC->abcA += abc.abcA;
1843             pABC->abcB += abc.abcB;
1844             pABC->abcC += abc.abcC;
1845         }
1846         /* FIXME: set to more reasonable values */
1847         pGoffset[i].du = pGoffset[i].dv = 0;
1848         if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
1849     }
1850
1851     if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
1852     return S_OK;
1853 }
1854
1855 /***********************************************************************
1856  *      ScriptPlace (USP10.@)
1857  *
1858  * Produce advance widths for a run.
1859  *
1860  * PARAMS
1861  *  hdc       [I]   Device context.
1862  *  psc       [I/O] Opaque pointer to a script cache.
1863  *  pwGlyphs  [I]   Array of glyphs.
1864  *  cGlyphs   [I]   Number of glyphs in pwGlyphs.
1865  *  psva      [I]   Array of visual attributes.
1866  *  psa       [I/O] String analysis.
1867  *  piAdvance [O]   Array of advance widths.
1868  *  pGoffset  [O]   Glyph offsets.
1869  *  pABC      [O]   Combined ABC width.
1870  *
1871  * RETURNS
1872  *  Success: S_OK
1873  *  Failure: Non-zero HRESULT value.
1874  */
1875 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs,
1876                            int cGlyphs, const SCRIPT_VISATTR *psva,
1877                            SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
1878 {
1879     HRESULT hr;
1880     SCRIPT_GLYPHPROP *glyphProps;
1881     int i;
1882
1883     TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n",  hdc, psc, pwGlyphs, cGlyphs, psva, psa,
1884           piAdvance, pGoffset, pABC);
1885
1886     if (!psva) return E_INVALIDARG;
1887     if (!pGoffset) return E_FAIL;
1888
1889     glyphProps = heap_alloc(sizeof(SCRIPT_GLYPHPROP)*cGlyphs);
1890     if (!glyphProps) return E_OUTOFMEMORY;
1891
1892     for (i = 0; i < cGlyphs; i++)
1893         glyphProps[i].sva = psva[i];
1894
1895     hr = ScriptPlaceOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, NULL, NULL, NULL, 0, pwGlyphs, glyphProps, cGlyphs, piAdvance, pGoffset, pABC);
1896
1897     heap_free(glyphProps);
1898
1899     return hr;
1900 }
1901
1902 /***********************************************************************
1903  *      ScriptGetCMap (USP10.@)
1904  *
1905  * Retrieve glyph indices.
1906  *
1907  * PARAMS
1908  *  hdc         [I]   Device context.
1909  *  psc         [I/O] Opaque pointer to a script cache.
1910  *  pwcInChars  [I]   Array of Unicode characters.
1911  *  cChars      [I]   Number of characters in pwcInChars.
1912  *  dwFlags     [I]   Flags.
1913  *  pwOutGlyphs [O]   Buffer to receive the array of glyph indices.
1914  *
1915  * RETURNS
1916  *  Success: S_OK
1917  *  Failure: Non-zero HRESULT value.
1918  */
1919 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
1920                              int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
1921 {
1922     HRESULT hr;
1923     int i;
1924
1925     TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
1926           cChars, dwFlags, pwOutGlyphs);
1927
1928     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1929
1930     hr = S_OK;
1931
1932     if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
1933     {
1934         for (i = 0; i < cChars; i++)
1935         {
1936             WCHAR inChar;
1937             if (dwFlags == SGCM_RTL)
1938                 inChar = mirror_char(pwcInChars[i]);
1939             else
1940                 inChar = pwcInChars[i];
1941             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
1942             {
1943                 WORD glyph;
1944                 if (!hdc) return E_PENDING;
1945                 if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
1946                 if (glyph == 0xffff)
1947                 {
1948                     hr = S_FALSE;
1949                     glyph = 0x0;
1950                 }
1951                 pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
1952             }
1953         }
1954     }
1955     else
1956     {
1957         TRACE("no glyph translation\n");
1958         for (i = 0; i < cChars; i++)
1959         {
1960             WCHAR inChar;
1961             if (dwFlags == SGCM_RTL)
1962                 inChar = mirror_char(pwcInChars[i]);
1963             else
1964                 inChar = pwcInChars[i];
1965             pwOutGlyphs[i] = inChar;
1966         }
1967     }
1968     return hr;
1969 }
1970
1971 /***********************************************************************
1972  *      ScriptTextOut (USP10.@)
1973  *
1974  */
1975 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
1976                              const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
1977                              int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
1978                              const int *piJustify, const GOFFSET *pGoffset)
1979 {
1980     HRESULT hr = S_OK;
1981
1982     TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
1983          hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
1984          piAdvance, piJustify, pGoffset);
1985
1986     if (!hdc || !psc) return E_INVALIDARG;
1987     if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
1988
1989     fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
1990     fuOptions |= ETO_IGNORELANGUAGE;
1991     if  (!psa->fNoGlyphIndex)                                     /* Have Glyphs?                      */
1992         fuOptions |= ETO_GLYPH_INDEX;                             /* Say don't do translation to glyph */
1993
1994     if (psa->fRTL && psa->fLogicalOrder)
1995     {
1996         int i;
1997         WORD *rtlGlyphs;
1998
1999         rtlGlyphs = heap_alloc(cGlyphs * sizeof(WORD));
2000         if (!rtlGlyphs)
2001             return E_OUTOFMEMORY;
2002
2003         for (i = 0; i < cGlyphs; i++)
2004             rtlGlyphs[i] = pwGlyphs[cGlyphs-1-i];
2005
2006         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, rtlGlyphs, cGlyphs, NULL))
2007             hr = S_FALSE;
2008         heap_free(rtlGlyphs);
2009     }
2010     else
2011         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
2012             hr = S_FALSE;
2013
2014     return hr;
2015 }
2016
2017 /***********************************************************************
2018  *      ScriptCacheGetHeight (USP10.@)
2019  *
2020  * Retrieve the height of the font in the cache.
2021  *
2022  * PARAMS
2023  *  hdc    [I]    Device context.
2024  *  psc    [I/O]  Opaque pointer to a script cache.
2025  *  height [O]    Receives font height.
2026  *
2027  * RETURNS
2028  *  Success: S_OK
2029  *  Failure: Non-zero HRESULT value.
2030  */
2031 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
2032 {
2033     HRESULT hr;
2034
2035     TRACE("(%p, %p, %p)\n", hdc, psc, height);
2036
2037     if (!height) return E_INVALIDARG;
2038     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2039
2040     *height = get_cache_height(psc);
2041     return S_OK;
2042 }
2043
2044 /***********************************************************************
2045  *      ScriptGetGlyphABCWidth (USP10.@)
2046  *
2047  * Retrieve the width of a glyph.
2048  *
2049  * PARAMS
2050  *  hdc    [I]    Device context.
2051  *  psc    [I/O]  Opaque pointer to a script cache.
2052  *  glyph  [I]    Glyph to retrieve the width for.
2053  *  abc    [O]    ABC widths of the glyph.
2054  *
2055  * RETURNS
2056  *  Success: S_OK
2057  *  Failure: Non-zero HRESULT value.
2058  */
2059 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
2060 {
2061     HRESULT hr;
2062
2063     TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
2064
2065     if (!abc) return E_INVALIDARG;
2066     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2067
2068     if (!get_cache_glyph_widths(psc, glyph, abc))
2069     {
2070         if (!hdc) return E_PENDING;
2071         if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
2072         {
2073             if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
2074         }
2075         else
2076         {
2077             INT width;
2078             if (!GetCharWidth32W(hdc, glyph, glyph, &width)) return S_FALSE;
2079             abc->abcB = width;
2080             abc->abcA = abc->abcC = 0;
2081         }
2082         set_cache_glyph_widths(psc, glyph, abc);
2083     }
2084     return S_OK;
2085 }
2086
2087 /***********************************************************************
2088  *      ScriptLayout (USP10.@)
2089  *
2090  * Map embedding levels to visual and/or logical order.
2091  *
2092  * PARAMS
2093  *  runs     [I] Size of level array.
2094  *  level    [I] Array of embedding levels.
2095  *  vistolog [O] Map of embedding levels from visual to logical order.
2096  *  logtovis [O] Map of embedding levels from logical to visual order.
2097  *
2098  * RETURNS
2099  *  Success: S_OK
2100  *  Failure: Non-zero HRESULT value.
2101  *
2102  * BUGS
2103  *  This stub works correctly for any sequence of a single
2104  *  embedding level but not for sequences of different
2105  *  embedding levels, i.e. mixtures of RTL and LTR scripts.
2106  */
2107 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
2108 {
2109     int* indexs;
2110     int ich;
2111
2112     TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
2113
2114     if (!level || (!vistolog && !logtovis))
2115         return E_INVALIDARG;
2116
2117     indexs = heap_alloc(sizeof(int) * runs);
2118     if (!indexs)
2119         return E_OUTOFMEMORY;
2120
2121
2122     if (vistolog)
2123     {
2124         for( ich = 0; ich < runs; ich++)
2125             indexs[ich] = ich;
2126
2127         ich = 0;
2128         while (ich < runs)
2129             ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
2130         for (ich = 0; ich < runs; ich++)
2131             vistolog[ich] = indexs[ich];
2132     }
2133
2134
2135     if (logtovis)
2136     {
2137         for( ich = 0; ich < runs; ich++)
2138             indexs[ich] = ich;
2139
2140         ich = 0;
2141         while (ich < runs)
2142             ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
2143         for (ich = 0; ich < runs; ich++)
2144             logtovis[ich] = indexs[ich];
2145     }
2146     heap_free(indexs);
2147
2148     return S_OK;
2149 }
2150
2151 /***********************************************************************
2152  *      ScriptStringGetLogicalWidths (USP10.@)
2153  *
2154  * Returns logical widths from a string analysis.
2155  *
2156  * PARAMS
2157  *  ssa  [I] string analysis.
2158  *  piDx [O] logical widths returned.
2159  *
2160  * RETURNS
2161  *  Success: S_OK
2162  *  Failure: a non-zero HRESULT.
2163  */
2164 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
2165 {
2166     int i, j, next = 0;
2167     StringAnalysis *analysis = ssa;
2168
2169     TRACE("%p, %p\n", ssa, piDx);
2170
2171     if (!analysis) return S_FALSE;
2172
2173     for (i = 0; i < analysis->numItems; i++)
2174     {
2175         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
2176         {
2177             piDx[next] = analysis->glyphs[i].piAdvance[j];
2178             next++;
2179         }
2180     }
2181     return S_OK;
2182 }
2183
2184 /***********************************************************************
2185  *      ScriptStringValidate (USP10.@)
2186  *
2187  * Validate a string analysis.
2188  *
2189  * PARAMS
2190  *  ssa [I] string analysis.
2191  *
2192  * RETURNS
2193  *  Success: S_OK
2194  *  Failure: S_FALSE if invalid sequences are found
2195  *           or a non-zero HRESULT if it fails.
2196  */
2197 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
2198 {
2199     StringAnalysis *analysis = ssa;
2200
2201     TRACE("(%p)\n", ssa);
2202
2203     if (!analysis) return E_INVALIDARG;
2204     return (analysis->invalid) ? S_FALSE : S_OK;
2205 }
2206
2207 /***********************************************************************
2208  *      ScriptString_pSize (USP10.@)
2209  *
2210  * Retrieve width and height of an analysed string.
2211  *
2212  * PARAMS
2213  *  ssa [I] string analysis.
2214  *
2215  * RETURNS
2216  *  Success: Pointer to a SIZE structure.
2217  *  Failure: NULL
2218  */
2219 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
2220 {
2221     int i, j;
2222     StringAnalysis *analysis = ssa;
2223
2224     TRACE("(%p)\n", ssa);
2225
2226     if (!analysis) return NULL;
2227
2228     if (!analysis->sz)
2229     {
2230         if (!(analysis->sz = heap_alloc(sizeof(SIZE)))) return NULL;
2231         analysis->sz->cy = analysis->sc->tm.tmHeight;
2232
2233         analysis->sz->cx = 0;
2234         for (i = 0; i < analysis->numItems; i++)
2235             for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
2236                 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
2237     }
2238     return analysis->sz;
2239 }
2240
2241 /***********************************************************************
2242  *      ScriptString_pLogAttr (USP10.@)
2243  *
2244  * Retrieve logical attributes of an analysed string.
2245  *
2246  * PARAMS
2247  *  ssa [I] string analysis.
2248  *
2249  * RETURNS
2250  *  Success: Pointer to an array of SCRIPT_LOGATTR structures.
2251  *  Failure: NULL
2252  */
2253 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
2254 {
2255     StringAnalysis *analysis = ssa;
2256
2257     TRACE("(%p)\n", ssa);
2258
2259     if (!analysis) return NULL;
2260     return analysis->logattrs;
2261 }
2262
2263 /***********************************************************************
2264  *      ScriptString_pcOutChars (USP10.@)
2265  *
2266  * Retrieve the length of a string after clipping.
2267  *
2268  * PARAMS
2269  *  ssa [I] String analysis.
2270  *
2271  * RETURNS
2272  *  Success: Pointer to the length.
2273  *  Failure: NULL
2274  */
2275 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
2276 {
2277     StringAnalysis *analysis = ssa;
2278
2279     TRACE("(%p)\n", ssa);
2280
2281     if (!analysis) return NULL;
2282     return &analysis->clip_len;
2283 }
2284
2285 /***********************************************************************
2286  *      ScriptStringGetOrder (USP10.@)
2287  *
2288  * Retrieve a glyph order map.
2289  *
2290  * PARAMS
2291  *  ssa   [I]   String analysis.
2292  *  order [I/O] Array of glyph positions.
2293  *
2294  * RETURNS
2295  *  Success: S_OK
2296  *  Failure: a non-zero HRESULT.
2297  */
2298 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
2299 {
2300     int i, j;
2301     unsigned int k;
2302     StringAnalysis *analysis = ssa;
2303
2304     TRACE("(%p)\n", ssa);
2305
2306     if (!analysis) return S_FALSE;
2307
2308     /* FIXME: handle RTL scripts */
2309     for (i = 0, k = 0; i < analysis->numItems; i++)
2310         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
2311             order[k] = k;
2312
2313     return S_OK;
2314 }
2315
2316 /***********************************************************************
2317  *      ScriptGetLogicalWidths (USP10.@)
2318  *
2319  * Convert advance widths to logical widths.
2320  *
2321  * PARAMS
2322  *  sa          [I] Script analysis.
2323  *  nbchars     [I] Number of characters.
2324  *  nbglyphs    [I] Number of glyphs.
2325  *  glyph_width [I] Array of glyph widths.
2326  *  log_clust   [I] Array of logical clusters.
2327  *  sva         [I] Visual attributes.
2328  *  widths      [O] Array of logical widths.
2329  *
2330  * RETURNS
2331  *  Success: S_OK
2332  *  Failure: a non-zero HRESULT.
2333  */
2334 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
2335                                       const int *glyph_width, const WORD *log_clust,
2336                                       const SCRIPT_VISATTR *sva, int *widths)
2337 {
2338     int i;
2339
2340     TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
2341           sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
2342
2343     /* FIXME */
2344     for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
2345     return S_OK;
2346 }
2347
2348 /***********************************************************************
2349  *      ScriptApplyLogicalWidth (USP10.@)
2350  *
2351  * Generate glyph advance widths.
2352  *
2353  * PARAMS
2354  *  dx          [I]   Array of logical advance widths.
2355  *  num_chars   [I]   Number of characters.
2356  *  num_glyphs  [I]   Number of glyphs.
2357  *  log_clust   [I]   Array of logical clusters.
2358  *  sva         [I]   Visual attributes.
2359  *  advance     [I]   Array of glyph advance widths.
2360  *  sa          [I]   Script analysis.
2361  *  abc         [I/O] Summed ABC widths.
2362  *  justify     [O]   Array of glyph advance widths.
2363  *
2364  * RETURNS
2365  *  Success: S_OK
2366  *  Failure: a non-zero HRESULT.
2367  */
2368 HRESULT WINAPI ScriptApplyLogicalWidth(const int *dx, int num_chars, int num_glyphs,
2369                                        const WORD *log_clust, const SCRIPT_VISATTR *sva,
2370                                        const int *advance, const SCRIPT_ANALYSIS *sa,
2371                                        ABC *abc, int *justify)
2372 {
2373     int i;
2374
2375     FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
2376           dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
2377
2378     for (i = 0; i < num_chars; i++) justify[i] = advance[i];
2379     return S_OK;
2380 }
2381
2382 HRESULT WINAPI ScriptJustify(const SCRIPT_VISATTR *sva, const int *advance,
2383                              int num_glyphs, int dx, int min_kashida, int *justify)
2384 {
2385     int i;
2386
2387     FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
2388
2389     for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
2390     return S_OK;
2391 }