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     int* logical2visual;
 338 } StringAnalysis;
 339
 340 static inline void *heap_alloc(SIZE_T size)
 341 {
 342     return HeapAlloc(GetProcessHeap(), 0, size);
 343 }
 344
 345 static inline void *heap_alloc_zero(SIZE_T size)
 346 {
 347     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 348 }
 349
 350 static inline void *heap_realloc_zero(LPVOID mem, SIZE_T size)
 351 {
 352     return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size);
 353 }
 354
 355 static inline BOOL heap_free(LPVOID mem)
 356 {
 357     return HeapFree(GetProcessHeap(), 0, mem);
 358 }
 359
 360 static inline WCHAR get_cache_default_char(SCRIPT_CACHE *psc)
 361 {
 362     return ((ScriptCache *)*psc)->tm.tmDefaultChar;
 363 }
 364
 365 static inline LONG get_cache_height(SCRIPT_CACHE *psc)
 366 {
 367     return ((ScriptCache *)*psc)->tm.tmHeight;
 368 }
 369
 370 static inline BYTE get_cache_pitch_family(SCRIPT_CACHE *psc)
 371 {
 372     return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
 373 }
 374
 375 static inline WORD get_cache_glyph(SCRIPT_CACHE *psc, WCHAR c)
 376 {
 377     WORD *block = ((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
 378
 379     if (!block) return 0;
 380     return block[c & GLYPH_BLOCK_MASK];
 381 }
 382
 383 static inline WORD set_cache_glyph(SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
 384 {
 385     WORD **block = &((ScriptCache *)*psc)->glyphs[c >> GLYPH_BLOCK_SHIFT];
 386
 387     if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
 388     return ((*block)[c & GLYPH_BLOCK_MASK] = glyph);
 389 }
 390
 391 static inline BOOL get_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
 392 {
 393     static const ABC nil;
 394     ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 395
 396     if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
 397     memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
 398     return TRUE;
 399 }
 400
 401 static inline BOOL set_cache_glyph_widths(SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
 402 {
 403     ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 404
 405     if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
 406     memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
 407     return TRUE;
 408 }
 409
 410 static HRESULT init_script_cache(const HDC hdc, SCRIPT_CACHE *psc)
 411 {
 412     ScriptCache *sc;
 413
 414     if (!psc) return E_INVALIDARG;
 415     if (*psc) return S_OK;
 416     if (!hdc) return E_PENDING;
 417
 418     if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
 419     if (!GetTextMetricsW(hdc, &sc->tm))
 420     {
 421         heap_free(sc);
 422         return E_INVALIDARG;
 423     }
 424     if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(LOGFONTW), &sc->lf))
 425     {
 426         heap_free(sc);
 427         return E_INVALIDARG;
 428     }
 429     *psc = sc;
 430     TRACE("<- %p\n", sc);
 431     return S_OK;
 432 }
 433
 434 static WCHAR mirror_char( WCHAR ch )
 435 {
 436     extern const WCHAR wine_mirror_map[];
 437     return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
 438 }
 439
 440 static WORD get_char_script( WCHAR ch)
 441 {
 442     WORD type = 0;
 443     int i;
 444
 445     if (ch == 0xc || ch == 0x20 || ch == 0x202f)
 446         return Script_CR;
 447
 448     GetStringTypeW(CT_CTYPE1, &ch, 1, &type);
 449
 450     if (type == 0)
 451         return SCRIPT_UNDEFINED;
 452
 453     if (type & C1_CNTRL)
 454         return Script_Control;
 455
 456     i = 0;
 457     do
 458     {
 459         if (ch < scriptRanges[i].rangeFirst || scriptRanges[i].script == SCRIPT_UNDEFINED)
 460             break;
 461
 462         if (ch >= scriptRanges[i].rangeFirst && ch <= scriptRanges[i].rangeLast)
 463         {
 464             if (scriptRanges[i].numericScript && type & C1_DIGIT)
 465                 return scriptRanges[i].numericScript;
 466             if (scriptRanges[i].punctScript && type & C1_PUNCT)
 467                 return scriptRanges[i].punctScript;
 468             return scriptRanges[i].script;
 469         }
 470         i++;
 471     } while (1);
 472
 473     return SCRIPT_UNDEFINED;
 474 }
 475
 476 /***********************************************************************
 477  *      DllMain
 478  *
 479  */
 480 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 481 {
 482     switch(fdwReason)
 483     {
 484     case DLL_PROCESS_ATTACH:
 485         DisableThreadLibraryCalls(hInstDLL);
 486         break;
 487     case DLL_PROCESS_DETACH:
 488         break;
 489     }
 490     return TRUE;
 491 }
 492
 493 /***********************************************************************
 494  *      ScriptFreeCache (USP10.@)
 495  *
 496  * Free a script cache.
 497  *
 498  * PARAMS
 499  *   psc [I/O] Script cache.
 500  *
 501  * RETURNS
 502  *  Success: S_OK
 503  *  Failure: Non-zero HRESULT value.
 504  */
 505 HRESULT WINAPI ScriptFreeCache(SCRIPT_CACHE *psc)
 506 {
 507     TRACE("%p\n", psc);
 508
 509     if (psc && *psc)
 510     {
 511         unsigned int i;
 512         for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
 513         {
 514             heap_free(((ScriptCache *)*psc)->glyphs[i]);
 515             heap_free(((ScriptCache *)*psc)->widths[i]);
 516         }
 517         heap_free(((ScriptCache *)*psc)->GSUB_Table);
 518         heap_free(((ScriptCache *)*psc)->GDEF_Table);
 519         heap_free(((ScriptCache *)*psc)->features);
 520         heap_free(*psc);
 521         *psc = NULL;
 522     }
 523     return S_OK;
 524 }
 525
 526 /***********************************************************************
 527  *      ScriptGetProperties (USP10.@)
 528  *
 529  * Retrieve a list of script properties.
 530  *
 531  * PARAMS
 532  *  props [I] Pointer to an array of SCRIPT_PROPERTIES pointers.
 533  *  num   [I] Pointer to the number of scripts.
 534  *
 535  * RETURNS
 536  *  Success: S_OK
 537  *  Failure: Non-zero HRESULT value.
 538  *
 539  * NOTES
 540  *  Behaviour matches WinXP.
 541  */
 542 HRESULT WINAPI ScriptGetProperties(const SCRIPT_PROPERTIES ***props, int *num)
 543 {
 544     TRACE("(%p,%p)\n", props, num);
 545
 546     if (!props && !num) return E_INVALIDARG;
 547
 548     if (num) *num = sizeof(script_props)/sizeof(script_props[0]);
 549     if (props) *props = script_props;
 550
 551     return S_OK;
 552 }
 553
 554 /***********************************************************************
 555  *      ScriptGetFontProperties (USP10.@)
 556  *
 557  * Get information on special glyphs.
 558  *
 559  * PARAMS
 560  *  hdc [I]   Device context.
 561  *  psc [I/O] Opaque pointer to a script cache.
 562  *  sfp [O]   Font properties structure.
 563  */
 564 HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
 565 {
 566     HRESULT hr;
 567
 568     TRACE("%p,%p,%p\n", hdc, psc, sfp);
 569
 570     if (!sfp) return E_INVALIDARG;
 571     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 572
 573     if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
 574         return E_INVALIDARG;
 575
 576     /* return something sensible? */
 577     sfp->wgBlank = 0;
 578     sfp->wgDefault = get_cache_default_char(psc);
 579     sfp->wgInvalid = 0;
 580     sfp->wgKashida = 0xffff;
 581     sfp->iKashidaWidth = 0;
 582
 583     return S_OK;
 584 }
 585
 586 /***********************************************************************
 587  *      ScriptRecordDigitSubstitution (USP10.@)
 588  *
 589  *  Record digit substitution settings for a given locale.
 590  *
 591  *  PARAMS
 592  *   locale [I] Locale identifier.
 593  *   sds    [I] Structure to record substitution settings.
 594  *
 595  *  RETURNS
 596  *   Success: S_OK
 597  *   Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
 598  *
 599  *  SEE ALSO
 600  *   http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
 601  */
 602 HRESULT WINAPI ScriptRecordDigitSubstitution(LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
 603 {
 604     DWORD plgid, sub;
 605
 606     TRACE("0x%x, %p\n", locale, sds);
 607
 608     /* This implementation appears to be correct for all languages, but it's
 609      * not clear if sds->DigitSubstitute is ever set to anything except
 610      * CONTEXT or NONE in reality */
 611
 612     if (!sds) return E_POINTER;
 613
 614     locale = ConvertDefaultLocale(locale);
 615
 616     if (!IsValidLocale(locale, LCID_INSTALLED))
 617         return E_INVALIDARG;
 618
 619     plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
 620     sds->TraditionalDigitLanguage = plgid;
 621
 622     if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
 623         sds->NationalDigitLanguage = plgid;
 624     else
 625         sds->NationalDigitLanguage = LANG_ENGLISH;
 626
 627     if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
 628                         (LPWSTR)&sub, sizeof(sub)/sizeof(WCHAR))) return E_INVALIDARG;
 629
 630     switch (sub)
 631     {
 632     case 0:
 633         if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
 634             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
 635         else
 636             sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
 637         break;
 638     case 1:
 639         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
 640         break;
 641     case 2:
 642         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
 643         break;
 644     default:
 645         sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
 646         break;
 647     }
 648
 649     sds->dwReserved = 0;
 650     return S_OK;
 651 }
 652
 653 /***********************************************************************
 654  *      ScriptApplyDigitSubstitution (USP10.@)
 655  *
 656  *  Apply digit substitution settings.
 657  *
 658  *  PARAMS
 659  *   sds [I] Structure with recorded substitution settings.
 660  *   sc  [I] Script control structure.
 661  *   ss  [I] Script state structure.
 662  *
 663  *  RETURNS
 664  *   Success: S_OK
 665  *   Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
 666  */
 667 HRESULT WINAPI ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE *sds,
 668                                             SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
 669 {
 670     SCRIPT_DIGITSUBSTITUTE psds;
 671
 672     TRACE("%p, %p, %p\n", sds, sc, ss);
 673
 674     if (!sc || !ss) return E_POINTER;
 675     if (!sds)
 676     {
 677         sds = &psds;
 678         if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
 679             return E_INVALIDARG;
 680     }
 681
 682     sc->uDefaultLanguage = LANG_ENGLISH;
 683     sc->fContextDigits = 0;
 684     ss->fDigitSubstitute = 0;
 685
 686     switch (sds->DigitSubstitute) {
 687         case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
 688         case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
 689         case SCRIPT_DIGITSUBSTITUTE_NONE:
 690         case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
 691             return S_OK;
 692         default:
 693             return E_INVALIDARG;
 694     }
 695 }
 696
 697 /***********************************************************************
 698  *      ScriptItemizeOpenType (USP10.@)
 699  *
 700  * Split a Unicode string into shapeable parts.
 701  *
 702  * PARAMS
 703  *  pwcInChars  [I] String to split.
 704  *  cInChars    [I] Number of characters in pwcInChars.
 705  *  cMaxItems   [I] Maximum number of items to return.
 706  *  psControl   [I] Pointer to a SCRIPT_CONTROL structure.
 707  *  psState     [I] Pointer to a SCRIPT_STATE structure.
 708  *  pItems      [O] Buffer to receive SCRIPT_ITEM structures.
 709  *  pScriptTags [O] Buffer to receive OPENTYPE_TAGs.
 710  *  pcItems     [O] Number of script items returned.
 711  *
 712  * RETURNS
 713  *  Success: S_OK
 714  *  Failure: Non-zero HRESULT value.
 715  */
 716 HRESULT WINAPI ScriptItemizeOpenType(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
 717                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
 718                              SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
 719 {
 720
 721 #define Numeric_space 0x0020
 722 #define ZWNJ 0x200C
 723 #define ZWJ  0x200D
 724
 725     int   cnt = 0, index = 0, str = 0;
 726     int   New_Script = SCRIPT_UNDEFINED;
 727     WORD  *levels = NULL;
 728     WORD  *strength = NULL;
 729     WORD  baselevel = 0;
 730
 731     TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems,
 732           psControl, psState, pItems, pcItems);
 733
 734     if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
 735         return E_INVALIDARG;
 736
 737     if (psState && psControl)
 738     {
 739         int i;
 740         levels = heap_alloc_zero(cInChars * sizeof(WORD));
 741         if (!levels)
 742             return E_OUTOFMEMORY;
 743
 744         BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels);
 745         baselevel = levels[0];
 746         for (i = 0; i < cInChars; i++)
 747             if (levels[i]!=levels[0])
 748                 break;
 749         if (i >= cInChars && !odd(baselevel))
 750         {
 751             heap_free(levels);
 752             levels = NULL;
 753         }
 754         else
 755         {
 756             if (!psControl->fMergeNeutralItems)
 757             {
 758                 strength = heap_alloc_zero(cInChars * sizeof(WORD));
 759                 BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
 760             }
 761         }
 762     }
 763
 764     while ((pwcInChars[cnt] == Numeric_space || pwcInChars[cnt] == ZWJ || pwcInChars[cnt] == ZWNJ) && cnt < cInChars)
 765         cnt++;
 766
 767     if (cnt == cInChars) /* All Spaces */
 768     {
 769         cnt = 0;
 770         New_Script = get_char_script(pwcInChars[cnt]);
 771     }
 772
 773     pItems[index].iCharPos = 0;
 774     pItems[index].a = scriptInformation[get_char_script(pwcInChars[cnt])].a;
 775     pScriptTags[index] = scriptInformation[get_char_script(pwcInChars[cnt])].scriptTag;
 776
 777     if (strength)
 778         str = strength[cnt];
 779
 780     cnt = 0;
 781     if (levels)
 782     {
 783         pItems[index].a.fRTL = odd(levels[cnt]);
 784         pItems[index].a.fLayoutRTL = odd(levels[cnt]);
 785         pItems[index].a.s.uBidiLevel = levels[cnt];
 786     }
 787     else if (!pItems[index].a.s.uBidiLevel)
 788     {
 789         pItems[index].a.s.uBidiLevel = baselevel;
 790         pItems[index].a.fLayoutRTL = odd(baselevel);
 791         pItems[index].a.fRTL = odd(baselevel);
 792     }
 793
 794     TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
 795           levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
 796           pItems[index].iCharPos);
 797
 798     for (cnt=1; cnt < cInChars; cnt++)
 799     {
 800         if (levels && (levels[cnt] == pItems[index].a.s.uBidiLevel && (!strength || (strength[cnt] == 0 || strength[cnt] == str))))
 801             continue;
 802
 803         if(pwcInChars[cnt] != Numeric_space && pwcInChars[cnt] != ZWJ && pwcInChars[cnt] != ZWNJ)
 804             New_Script = get_char_script(pwcInChars[cnt]);
 805         else if (levels)
 806         {
 807             int j = 1;
 808             while (cnt + j < cInChars - 1 && (pwcInChars[cnt+j] == Numeric_space || pwcInChars[cnt+j] == ZWJ || pwcInChars[cnt+j] == ZWNJ))
 809                 j++;
 810             New_Script = get_char_script(pwcInChars[cnt+j]);
 811         }
 812
 813         if ((levels && (levels[cnt] != pItems[index].a.s.uBidiLevel || (strength && (strength[cnt] != str)))) || New_Script != pItems[index].a.eScript || New_Script == Script_Control)
 814         {
 815             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);
 816
 817             if (strength && strength[cnt] != 0)
 818                 str = strength[cnt];
 819
 820             index++;
 821             if  (index+1 > cMaxItems)
 822                 return E_OUTOFMEMORY;
 823
 824             pItems[index].iCharPos = cnt;
 825             memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
 826
 827             pItems[index].a = scriptInformation[New_Script].a;
 828             pScriptTags[index] = scriptInformation[New_Script].scriptTag;
 829             if (levels)
 830             {
 831                 pItems[index].a.fRTL = odd(levels[cnt]);
 832                 pItems[index].a.fLayoutRTL = odd(levels[cnt]);
 833                 pItems[index].a.s.uBidiLevel = levels[cnt];
 834             }
 835             else if (!pItems[index].a.s.uBidiLevel)
 836             {
 837                 pItems[index].a.s.uBidiLevel = baselevel;
 838                 pItems[index].a.fLayoutRTL = odd(baselevel);
 839                 pItems[index].a.fRTL = odd(baselevel);
 840             }
 841
 842             TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
 843         }
 844     }
 845
 846     /* While not strictly necessary according to the spec, make sure the n+1
 847      * item is set up to prevent random behaviour if the caller erroneously
 848      * checks the n+1 structure                                              */
 849     index++;
 850     memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
 851
 852     TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
 853
 854     /*  Set one SCRIPT_STATE item being returned  */
 855     if  (index + 1 > cMaxItems) return E_OUTOFMEMORY;
 856     if (pcItems) *pcItems = index;
 857
 858     /*  Set SCRIPT_ITEM                                     */
 859     pItems[index].iCharPos = cnt;         /* the last item contains the ptr to the lastchar */
 860     heap_free(levels);
 861     heap_free(strength);
 862     return S_OK;
 863 }
 864
 865 /***********************************************************************
 866  *      ScriptItemize (USP10.@)
 867  *
 868  * Split a Unicode string into shapeable parts.
 869  *
 870  * PARAMS
 871  *  pwcInChars [I] String to split.
 872  *  cInChars   [I] Number of characters in pwcInChars.
 873  *  cMaxItems  [I] Maximum number of items to return.
 874  *  psControl  [I] Pointer to a SCRIPT_CONTROL structure.
 875  *  psState    [I] Pointer to a SCRIPT_STATE structure.
 876  *  pItems     [O] Buffer to receive SCRIPT_ITEM structures.
 877  *  pcItems    [O] Number of script items returned.
 878  *
 879  * RETURNS
 880  *  Success: S_OK
 881  *  Failure: Non-zero HRESULT value.
 882  */
 883 HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems,
 884                              const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState,
 885                              SCRIPT_ITEM *pItems, int *pcItems)
 886 {
 887     OPENTYPE_TAG *discarded_tags;
 888     HRESULT res;
 889
 890     discarded_tags = heap_alloc(cMaxItems * sizeof(OPENTYPE_TAG));
 891     if (!discarded_tags)
 892         return E_OUTOFMEMORY;
 893     res = ScriptItemizeOpenType(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, discarded_tags, pcItems);
 894     heap_free(discarded_tags);
 895     return res;
 896 }
 897
 898 /***********************************************************************
 899  *      ScriptStringAnalyse (USP10.@)
 900  *
 901  */
 902 HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString,
 903                                    int cGlyphs, int iCharset, DWORD dwFlags,
 904                                    int iReqWidth, SCRIPT_CONTROL *psControl,
 905                                    SCRIPT_STATE *psState, const int *piDx,
 906                                    SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass,
 907                                    SCRIPT_STRING_ANALYSIS *pssa)
 908 {
 909     HRESULT hr = E_OUTOFMEMORY;
 910     StringAnalysis *analysis = NULL;
 911     SCRIPT_CONTROL sControl;
 912     SCRIPT_STATE sState;
 913     int i, num_items = 255;
 914     BYTE   *BidiLevel;
 915
 916     TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
 917           hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
 918           psControl, psState, piDx, pTabdef, pbInClass, pssa);
 919
 920     if (iCharset != -1)
 921     {
 922         FIXME("Only Unicode strings are supported\n");
 923         return E_INVALIDARG;
 924     }
 925     if (cString < 1 || !pString) return E_INVALIDARG;
 926     if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
 927
 928     if (!(analysis = heap_alloc_zero(sizeof(StringAnalysis)))) return E_OUTOFMEMORY;
 929     if (!(analysis->pItem = heap_alloc_zero(num_items * sizeof(SCRIPT_ITEM) + 1))) goto error;
 930
 931     /* FIXME: handle clipping */
 932     analysis->clip_len = cString;
 933     analysis->hdc = hdc;
 934
 935     if (psState)
 936         sState = *psState;
 937     else
 938         memset(&sState, 0, sizeof(SCRIPT_STATE));
 939
 940     if (psControl)
 941         sControl = *psControl;
 942     else
 943         memset(&sControl, 0, sizeof(SCRIPT_CONTROL));
 944
 945     hr = ScriptItemize(pString, cString, num_items, &sControl, &sState, analysis->pItem,
 946                        &analysis->numItems);
 947
 948     while (hr == E_OUTOFMEMORY)
 949     {
 950         SCRIPT_ITEM *tmp;
 951
 952         num_items *= 2;
 953         if (!(tmp = heap_realloc_zero(analysis->pItem, num_items * sizeof(SCRIPT_ITEM) + 1)))
 954             goto error;
 955
 956         analysis->pItem = tmp;
 957         hr = ScriptItemize(pString, cString, num_items, psControl, psState, analysis->pItem,
 958                            &analysis->numItems);
 959     }
 960     if (hr != S_OK) goto error;
 961
 962     if ((analysis->logattrs = heap_alloc(sizeof(SCRIPT_LOGATTR) * cString)))
 963         ScriptBreak(pString, cString, (SCRIPT_STRING_ANALYSIS)analysis, analysis->logattrs);
 964     else
 965         goto error;
 966
 967     if (!(analysis->glyphs = heap_alloc_zero(sizeof(StringGlyphs) * analysis->numItems)))
 968         goto error;
 969
 970     if (!(analysis->logical2visual = heap_alloc_zero(sizeof(int) * analysis->numItems)))
 971         goto error;
 972     if (!(BidiLevel = heap_alloc_zero(analysis->numItems)))
 973         goto error;
 974
 975     for (i = 0; i < analysis->numItems; i++)
 976     {
 977         SCRIPT_CACHE *sc = (SCRIPT_CACHE *)&analysis->sc;
 978         int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
 979         int numGlyphs = 1.5 * cChar + 16;
 980         WORD *glyphs = heap_alloc_zero(sizeof(WORD) * numGlyphs);
 981         WORD *pwLogClust = heap_alloc_zero(sizeof(WORD) * cChar);
 982         int *piAdvance = heap_alloc_zero(sizeof(int) * numGlyphs);
 983         SCRIPT_VISATTR *psva = heap_alloc_zero(sizeof(SCRIPT_VISATTR) * cChar);
 984         GOFFSET *pGoffset = heap_alloc_zero(sizeof(GOFFSET) * numGlyphs);
 985         ABC *abc = heap_alloc_zero(sizeof(ABC));
 986         int numGlyphsReturned;
 987
 988         /* FIXME: non unicode strings */
 989         const WCHAR* pStr = (const WCHAR*)pString;
 990         hr = ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos],
 991                          cChar, numGlyphs, &analysis->pItem[i].a,
 992                          glyphs, pwLogClust, psva, &numGlyphsReturned);
 993         hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
 994                          piAdvance, pGoffset, abc);
 995
 996         analysis->glyphs[i].numGlyphs = numGlyphsReturned;
 997         analysis->glyphs[i].glyphs = glyphs;
 998         analysis->glyphs[i].pwLogClust = pwLogClust;
 999         analysis->glyphs[i].piAdvance = piAdvance;
1000         analysis->glyphs[i].psva = psva;
1001         analysis->glyphs[i].pGoffset = pGoffset;
1002         analysis->glyphs[i].abc = abc;
1003         analysis->glyphs[i].iMaxPosX= -1;
1004
1005         BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
1006     }
1007
1008     ScriptLayout(analysis->numItems, BidiLevel, NULL, analysis->logical2visual);
1009     heap_free(BidiLevel);
1010
1011     *pssa = analysis;
1012     return S_OK;
1013
1014 error:
1015     heap_free(analysis->glyphs);
1016     heap_free(analysis->logattrs);
1017     heap_free(analysis->pItem);
1018     heap_free(analysis->logical2visual);
1019     heap_free(analysis->sc);
1020     heap_free(analysis);
1021     return hr;
1022 }
1023
1024 static HRESULT SS_ItemOut( SCRIPT_STRING_ANALYSIS ssa,
1025                            int iX,
1026                            int iY,
1027                            int iItem,
1028                            int cStart,
1029                            int cEnd,
1030                            UINT uOptions,
1031                            const RECT *prc,
1032                            BOOL fSelected,
1033                            BOOL fDisabled)
1034 {
1035     StringAnalysis *analysis;
1036     int off_x = 0;
1037     HRESULT hr;
1038     COLORREF BkColor = 0x0;
1039     COLORREF TextColor = 0x0;
1040     INT BkMode = 0;
1041     INT runStart, runEnd;
1042     INT iGlyph, cGlyphs;
1043
1044     TRACE("(%p,%d,%d,%d,%d,%d, 0x%1x, %d, %d)\n",
1045          ssa, iX, iY, iItem, cStart, cEnd, uOptions, fSelected, fDisabled);
1046
1047     if (!(analysis = ssa)) return E_INVALIDARG;
1048
1049     if ((cStart >= 0 && analysis->pItem[iItem+1].iCharPos <= cStart) ||
1050          (cEnd >= 0 && analysis->pItem[iItem].iCharPos >= cEnd))
1051             return S_OK;
1052
1053     if (fSelected)
1054     {
1055         BkMode = GetBkMode(analysis->hdc);
1056         SetBkMode( analysis->hdc, OPAQUE);
1057         BkColor = GetBkColor(analysis->hdc);
1058         SetBkColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHT));
1059         if (!fDisabled)
1060         {
1061             TextColor = GetTextColor(analysis->hdc);
1062             SetTextColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1063         }
1064
1065     }
1066
1067     if (cStart >= 0 && analysis->pItem[iItem+1].iCharPos > cStart && analysis->pItem[iItem].iCharPos <= cStart)
1068         runStart = cStart - analysis->pItem[iItem].iCharPos;
1069     else
1070         runStart =  0;
1071     if (cEnd >= 0 && analysis->pItem[iItem+1].iCharPos > cEnd && analysis->pItem[iItem].iCharPos <= cEnd)
1072         runEnd = (cEnd-1) - analysis->pItem[iItem].iCharPos;
1073     else
1074         runEnd = (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos) - 1;
1075
1076     if (analysis->pItem[iItem].a.fRTL)
1077     {
1078         if (cEnd >= 0 && cEnd < analysis->pItem[iItem+1].iCharPos)
1079             ScriptStringCPtoX(ssa, cEnd, FALSE, &off_x);
1080         else
1081             ScriptStringCPtoX(ssa, analysis->pItem[iItem+1].iCharPos-1, TRUE, &off_x);
1082     }
1083     else
1084     {
1085         if (cStart >=0 && runStart)
1086             ScriptStringCPtoX(ssa, cStart, FALSE, &off_x);
1087         else
1088             ScriptStringCPtoX(ssa, analysis->pItem[iItem].iCharPos, FALSE, &off_x);
1089     }
1090
1091     if (analysis->pItem[iItem].a.fRTL)
1092         iGlyph = analysis->glyphs[iItem].pwLogClust[runEnd];
1093     else
1094         iGlyph = analysis->glyphs[iItem].pwLogClust[runStart];
1095
1096     if (analysis->pItem[iItem].a.fRTL)
1097         cGlyphs = analysis->glyphs[iItem].pwLogClust[runStart] - iGlyph;
1098     else
1099         cGlyphs = analysis->glyphs[iItem].pwLogClust[runEnd] - iGlyph;
1100
1101     cGlyphs++;
1102
1103     hr = ScriptTextOut(analysis->hdc, (SCRIPT_CACHE *)&analysis->sc, iX + off_x,
1104                        iY, uOptions, prc, &analysis->pItem[iItem].a, NULL, 0,
1105                        &analysis->glyphs[iItem].glyphs[iGlyph], cGlyphs,
1106                        &analysis->glyphs[iItem].piAdvance[iGlyph], NULL,
1107                        &analysis->glyphs[iItem].pGoffset[iGlyph]);
1108
1109     TRACE("ScriptTextOut hr=%08x\n", hr);
1110
1111     if (fSelected)
1112     {
1113         SetBkColor(analysis->hdc, BkColor);
1114         SetBkMode( analysis->hdc, BkMode);
1115         if (!fDisabled)
1116             SetTextColor(analysis->hdc, TextColor);
1117     }
1118
1119     return hr;
1120 }
1121
1122 /***********************************************************************
1123  *      ScriptStringOut (USP10.@)
1124  *
1125  * This function takes the output of ScriptStringAnalyse and joins the segments
1126  * of glyphs and passes the resulting string to ScriptTextOut.  ScriptStringOut
1127  * only processes glyphs.
1128  *
1129  * Parameters:
1130  *  ssa       [I] buffer to hold the analysed string components
1131  *  iX        [I] X axis displacement for output
1132  *  iY        [I] Y axis displacement for output
1133  *  uOptions  [I] flags controling output processing
1134  *  prc       [I] rectangle coordinates
1135  *  iMinSel   [I] starting pos for substringing output string
1136  *  iMaxSel   [I] ending pos for substringing output string
1137  *  fDisabled [I] controls text highlighting
1138  *
1139  *  RETURNS
1140  *   Success: S_OK
1141  *   Failure: is the value returned by ScriptTextOut
1142  */
1143 HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa,
1144                                int iX,
1145                                int iY,
1146                                UINT uOptions,
1147                                const RECT *prc,
1148                                int iMinSel,
1149                                int iMaxSel,
1150                                BOOL fDisabled)
1151 {
1152     StringAnalysis *analysis;
1153     int   item;
1154     HRESULT hr;
1155
1156     TRACE("(%p,%d,%d,0x%1x,%p,%d,%d,%d)\n",
1157          ssa, iX, iY, uOptions, prc, iMinSel, iMaxSel, fDisabled);
1158
1159     if (!(analysis = ssa)) return E_INVALIDARG;
1160
1161     for (item = 0; item < analysis->numItems; item++)
1162     {
1163         hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], -1, -1, uOptions, prc, FALSE, fDisabled);
1164         if (FAILED(hr))
1165             return hr;
1166     }
1167
1168     if (iMinSel < iMaxSel && (iMinSel > 0 || iMaxSel > 0))
1169     {
1170         if (iMaxSel > 0 &&  iMinSel < 0)
1171             iMinSel = 0;
1172         for (item = 0; item < analysis->numItems; item++)
1173         {
1174             hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], iMinSel, iMaxSel, uOptions, prc, TRUE, fDisabled);
1175             if (FAILED(hr))
1176                 return hr;
1177         }
1178     }
1179
1180     return S_OK;
1181 }
1182
1183 /***********************************************************************
1184  *      ScriptStringCPtoX (USP10.@)
1185  *
1186  */
1187 HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int* pX)
1188 {
1189     int item;
1190     int runningX = 0;
1191     StringAnalysis* analysis = ssa;
1192
1193     TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
1194
1195     if (!ssa || !pX) return S_FALSE;
1196
1197     /* icp out of range */
1198     if(icp < 0)
1199     {
1200         analysis->invalid = TRUE;
1201         return E_INVALIDARG;
1202     }
1203
1204     for(item=0; item<analysis->numItems; item++)
1205     {
1206         int CP, i;
1207         int offset;
1208
1209         i = analysis->logical2visual[item];
1210         CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1211         /* initialize max extents for uninitialized runs */
1212         if (analysis->glyphs[i].iMaxPosX == -1)
1213         {
1214             if (analysis->pItem[i].a.fRTL)
1215                 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1216                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1217                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1218             else
1219                 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1220                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1221                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1222         }
1223
1224         if (icp >= analysis->pItem[i+1].iCharPos || icp < analysis->pItem[i].iCharPos)
1225         {
1226             runningX += analysis->glyphs[i].iMaxPosX;
1227             continue;
1228         }
1229
1230         icp -= analysis->pItem[i].iCharPos;
1231         ScriptCPtoX(icp, fTrailing, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1232                     analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1233                     &analysis->pItem[i].a, &offset);
1234         runningX += offset;
1235
1236         *pX = runningX;
1237         return S_OK;
1238     }
1239
1240     /* icp out of range */
1241     analysis->invalid = TRUE;
1242     return E_INVALIDARG;
1243 }
1244
1245 /***********************************************************************
1246  *      ScriptStringXtoCP (USP10.@)
1247  *
1248  */
1249 HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int* piCh, int* piTrailing)
1250 {
1251     StringAnalysis* analysis = ssa;
1252     int item;
1253
1254     TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
1255
1256     if (!ssa || !piCh || !piTrailing) return S_FALSE;
1257
1258     /* out of range */
1259     if(iX < 0)
1260     {
1261         if (analysis->pItem[0].a.fRTL)
1262         {
1263             *piCh = 1;
1264             *piTrailing = FALSE;
1265         }
1266         else
1267         {
1268             *piCh = -1;
1269             *piTrailing = TRUE;
1270         }
1271         return S_OK;
1272     }
1273
1274     for(item=0; item<analysis->numItems; item++)
1275     {
1276         int i;
1277         int CP;
1278
1279         for (i = 0; i < analysis->numItems && analysis->logical2visual[i] != item; i++)
1280         /* nothing */;
1281
1282         CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
1283         /* initialize max extents for uninitialized runs */
1284         if (analysis->glyphs[i].iMaxPosX == -1)
1285         {
1286             if (analysis->pItem[i].a.fRTL)
1287                 ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1288                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1289                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1290             else
1291                 ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1292                             analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1293                             &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
1294         }
1295
1296         if (iX > analysis->glyphs[i].iMaxPosX)
1297         {
1298             iX -= analysis->glyphs[i].iMaxPosX;
1299             continue;
1300         }
1301
1302         ScriptXtoCP(iX, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
1303                     analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
1304                     &analysis->pItem[i].a, piCh, piTrailing);
1305         *piCh += analysis->pItem[i].iCharPos;
1306
1307         return S_OK;
1308     }
1309
1310     /* out of range */
1311     *piCh = analysis->pItem[analysis->numItems].iCharPos;
1312     *piTrailing = FALSE;
1313
1314     return S_OK;
1315 }
1316
1317
1318 /***********************************************************************
1319  *      ScriptStringFree (USP10.@)
1320  *
1321  * Free a string analysis.
1322  *
1323  * PARAMS
1324  *  pssa [I] string analysis.
1325  *
1326  * RETURNS
1327  *  Success: S_OK
1328  *  Failure: Non-zero HRESULT value.
1329  */
1330 HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
1331 {
1332     StringAnalysis* analysis;
1333     BOOL invalid;
1334     int i;
1335
1336     TRACE("(%p)\n", pssa);
1337
1338     if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
1339
1340     invalid = analysis->invalid;
1341     ScriptFreeCache((SCRIPT_CACHE *)&analysis->sc);
1342
1343     for (i = 0; i < analysis->numItems; i++)
1344     {
1345         heap_free(analysis->glyphs[i].glyphs);
1346         heap_free(analysis->glyphs[i].pwLogClust);
1347         heap_free(analysis->glyphs[i].piAdvance);
1348         heap_free(analysis->glyphs[i].psva);
1349         heap_free(analysis->glyphs[i].pGoffset);
1350         heap_free(analysis->glyphs[i].abc);
1351     }
1352
1353     heap_free(analysis->glyphs);
1354     heap_free(analysis->pItem);
1355     heap_free(analysis->logattrs);
1356     heap_free(analysis->sz);
1357     heap_free(analysis->sc);
1358     heap_free(analysis->logical2visual);
1359     heap_free(analysis);
1360
1361     if (invalid) return E_INVALIDARG;
1362     return S_OK;
1363 }
1364
1365 /***********************************************************************
1366  *      ScriptCPtoX (USP10.@)
1367  *
1368  */
1369 HRESULT WINAPI ScriptCPtoX(int iCP,
1370                            BOOL fTrailing,
1371                            int cChars,
1372                            int cGlyphs,
1373                            const WORD *pwLogClust,
1374                            const SCRIPT_VISATTR *psva,
1375                            const int *piAdvance,
1376                            const SCRIPT_ANALYSIS *psa,
1377                            int *piX)
1378 {
1379     int item;
1380     float iPosX;
1381     int iSpecial = -1;
1382     int iCluster = -1;
1383     int clust_size = 1;
1384     float special_size = 0.0;
1385     int iMaxPos = 0;
1386     BOOL rtl = FALSE;
1387
1388     TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
1389           iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
1390           psa, piX);
1391
1392     if (psa->fRTL && ! psa->fLogicalOrder)
1393         rtl = TRUE;
1394
1395     if (fTrailing)
1396         iCP++;
1397
1398     if (rtl)
1399     {
1400         int max_clust = pwLogClust[0];
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         iMaxPos = 0;
1410         for (item = max_clust; item >=0; item --)
1411             iMaxPos += piAdvance[item];
1412     }
1413
1414     iPosX = 0.0;
1415     for (item=0; item < iCP && item < cChars; item++)
1416     {
1417         if (iSpecial == -1 && (iCluster == -1 || (iCluster != -1 && iCluster+clust_size <= item)))
1418         {
1419             int check;
1420             int clust = pwLogClust[item];
1421
1422             clust_size = 1;
1423             iCluster = -1;
1424
1425             for (check = item+1; check < cChars; check++)
1426             {
1427                 if (pwLogClust[check] == clust)
1428                 {
1429                     clust_size ++;
1430                     if (iCluster == -1)
1431                         iCluster = item;
1432                 }
1433                 else break;
1434             }
1435
1436             if (check >= cChars && !iMaxPos)
1437             {
1438                 for (check = clust; check < cChars; check++)
1439                     special_size += piAdvance[check];
1440                 iSpecial = item;
1441                 special_size /= (cChars - item);
1442                 iPosX += special_size;
1443             }
1444             else
1445                 iPosX += piAdvance[clust] / (float)clust_size;
1446         }
1447         else if (iSpecial != -1)
1448             iPosX += special_size;
1449         else /* (iCluster != -1) */
1450             iPosX += piAdvance[pwLogClust[iCluster]] / (float)clust_size;
1451     }
1452
1453     if (iMaxPos > 0)
1454     {
1455         iPosX = iMaxPos - iPosX;
1456         if (iPosX < 0)
1457             iPosX = 0;
1458     }
1459
1460     *piX = iPosX;
1461     TRACE("*piX=%d\n", *piX);
1462     return S_OK;
1463 }
1464
1465 /***********************************************************************
1466  *      ScriptXtoCP (USP10.@)
1467  *
1468  */
1469 HRESULT WINAPI ScriptXtoCP(int iX,
1470                            int cChars,
1471                            int cGlyphs,
1472                            const WORD *pwLogClust,
1473                            const SCRIPT_VISATTR *psva,
1474                            const int *piAdvance,
1475                            const SCRIPT_ANALYSIS *psa,
1476                            int *piCP,
1477                            int *piTrailing)
1478 {
1479     int item;
1480     float iPosX;
1481     float iLastPosX;
1482     int iSpecial = -1;
1483     int iCluster = -1;
1484     int clust_size = 1;
1485     float special_size = 0.0;
1486     int direction = 1;
1487
1488     TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
1489           iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
1490           psa, piCP, piTrailing);
1491
1492     if (psa->fRTL && ! psa->fLogicalOrder)
1493         direction = -1;
1494
1495     if (direction<0)
1496     {
1497         int max_clust = pwLogClust[0];
1498
1499         if (iX < 0)
1500         {
1501             *piCP = cChars;
1502             *piTrailing = 0;
1503             return S_OK;
1504         }
1505
1506         for (item=0; item < cChars; item++)
1507             if (pwLogClust[item] > max_clust)
1508             {
1509                 ERR("We do not handle non reversed clusters properly\n");
1510                 break;
1511             }
1512     }
1513
1514     if (iX < 0)
1515     {
1516         *piCP = -1;
1517         *piTrailing = 1;
1518         return S_OK;
1519     }
1520
1521     iPosX = iLastPosX = 0;
1522     if (direction > 0)
1523         item = 0;
1524     else
1525         item = cChars - 1;
1526     for (; iPosX <= iX && item < cChars && item >= 0; item+=direction)
1527     {
1528         iLastPosX = iPosX;
1529         if (iSpecial == -1 &&
1530              (iCluster == -1 ||
1531               (iCluster != -1 &&
1532                  ((direction > 0 && iCluster+clust_size <= item) ||
1533                   (direction < 0 && iCluster-clust_size >= item))
1534               )
1535              )
1536             )
1537         {
1538             int check;
1539             int clust = pwLogClust[item];
1540
1541             clust_size = 1;
1542             iCluster = -1;
1543
1544             for (check = item+direction; check < cChars && check >= 0; check+=direction)
1545             {
1546                 if (pwLogClust[check] == clust)
1547                 {
1548                     clust_size ++;
1549                     if (iCluster == -1)
1550                         iCluster = item;
1551                 }
1552                 else break;
1553             }
1554
1555             if (check >= cChars && direction > 0)
1556             {
1557                 for (check = clust; check < cChars; check++)
1558                     special_size += piAdvance[check];
1559                 iSpecial = item;
1560                 special_size /= (cChars - item);
1561                 iPosX += special_size;
1562             }
1563             else
1564                 iPosX += piAdvance[clust] / (float)clust_size;
1565         }
1566         else if (iSpecial != -1)
1567             iPosX += special_size;
1568         else /* (iCluster != -1) */
1569             iPosX += piAdvance[pwLogClust[iCluster]] / (float)clust_size;
1570     }
1571
1572     if (direction > 0)
1573     {
1574         if (iPosX > iX)
1575             item--;
1576         if (item < cChars && ((iPosX - iLastPosX) / 2.0) + iX > iPosX)
1577             *piTrailing = 1;
1578         else
1579             *piTrailing = 0;
1580     }
1581     else
1582     {
1583         if (iX == iLastPosX)
1584             item++;
1585         if (iX >= iLastPosX && iX <= iPosX)
1586             item++;
1587
1588         if (iLastPosX == iX)
1589             *piTrailing = 0;
1590         else if (item < 0 || ((iLastPosX - iPosX) / 2.0) + iX <= iLastPosX)
1591             *piTrailing = 1;
1592         else
1593             *piTrailing = 0;
1594     }
1595
1596     *piCP = item;
1597
1598     TRACE("*piCP=%d\n", *piCP);
1599     TRACE("*piTrailing=%d\n", *piTrailing);
1600     return S_OK;
1601 }
1602
1603 /***********************************************************************
1604  *      ScriptBreak (USP10.@)
1605  *
1606  *  Retrieve line break information.
1607  *
1608  *  PARAMS
1609  *   chars [I] Array of characters.
1610  *   sa    [I] String analysis.
1611  *   la    [I] Array of logical attribute structures.
1612  *
1613  *  RETURNS
1614  *   Success: S_OK
1615  *   Failure: S_FALSE
1616  */
1617 HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
1618 {
1619     TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
1620
1621     if (!la) return S_FALSE;
1622
1623     BREAK_line(chars, count, sa, la);
1624
1625     return S_OK;
1626 }
1627
1628 /***********************************************************************
1629  *      ScriptIsComplex (USP10.@)
1630  *
1631  *  Determine if a string is complex.
1632  *
1633  *  PARAMS
1634  *   chars [I] Array of characters to test.
1635  *   len   [I] Length in characters.
1636  *   flag  [I] Flag.
1637  *
1638  *  RETURNS
1639  *   Success: S_OK
1640  *   Failure: S_FALSE
1641  *
1642  */
1643 HRESULT WINAPI ScriptIsComplex(const WCHAR *chars, int len, DWORD flag)
1644 {
1645     int i;
1646
1647     TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
1648
1649     for (i = 0; i < len; i++)
1650     {
1651         int script;
1652
1653         if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
1654             return S_OK;
1655
1656         script = get_char_script(chars[i]);
1657         if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
1658             (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
1659             return S_OK;
1660     }
1661     return S_FALSE;
1662 }
1663
1664 /***********************************************************************
1665  *      ScriptShapeOpenType (USP10.@)
1666  *
1667  * Produce glyphs and visual attributes for a run.
1668  *
1669  * PARAMS
1670  *  hdc         [I]   Device context.
1671  *  psc         [I/O] Opaque pointer to a script cache.
1672  *  psa         [I/O] Script analysis.
1673  *  tagScript   [I]   The OpenType tag for the Script
1674  *  tagLangSys  [I]   The OpenType tag for the Language
1675  *  rcRangeChars[I]   Array of Character counts in each range
1676  *  rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
1677  *  cRanges     [I]   Count of ranges
1678  *  pwcChars    [I]   Array of characters specifying the run.
1679  *  cChars      [I]   Number of characters in pwcChars.
1680  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
1681  *  pwLogClust  [O]   Array of logical cluster info.
1682  *  pCharProps  [O]   Array of character property values
1683  *  pwOutGlyphs [O]   Array of glyphs.
1684  *  pOutGlyphProps [O]  Array of attributes for the retrieved glyphs
1685  *  pcGlyphs    [O]   Number of glyphs returned.
1686  *
1687  * RETURNS
1688  *  Success: S_OK
1689  *  Failure: Non-zero HRESULT value.
1690  */
1691 HRESULT WINAPI ScriptShapeOpenType( HDC hdc, SCRIPT_CACHE *psc,
1692                                     SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript,
1693                                     OPENTYPE_TAG tagLangSys, int *rcRangeChars,
1694                                     TEXTRANGE_PROPERTIES **rpRangeProperties,
1695                                     int cRanges, const WCHAR *pwcChars, int cChars,
1696                                     int cMaxGlyphs, WORD *pwLogClust,
1697                                     SCRIPT_CHARPROP *pCharProps, WORD *pwOutGlyphs,
1698                                     SCRIPT_GLYPHPROP *pOutGlyphProps, int *pcGlyphs)
1699 {
1700     HRESULT hr;
1701     unsigned int i;
1702     BOOL rtl;
1703
1704     TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %d, %d, %p, %p, %p, %p, %p )\n",
1705      hdc, psc, psa,
1706      debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
1707      rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
1708      cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
1709
1710     if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
1711                    psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
1712
1713     if (!pOutGlyphProps || !pcGlyphs || !pCharProps) return E_INVALIDARG;
1714     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
1715
1716     if (cRanges)
1717         FIXME("Ranges not supported yet\n");
1718
1719     rtl = (psa && !psa->fLogicalOrder && psa->fRTL);
1720
1721     *pcGlyphs = cChars;
1722     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1723     if (!pwLogClust) return E_FAIL;
1724
1725     ((ScriptCache *)*psc)->userScript = tagScript;
1726     ((ScriptCache *)*psc)->userLang = tagLangSys;
1727
1728     /* set fNoGlyphIndex for symbolic, and device fonts or non truetype fonts */
1729     if (!psa->fNoGlyphIndex &&
1730         (!(get_cache_pitch_family(psc) & TMPF_TRUETYPE) ||
1731          (get_cache_pitch_family(psc) & TMPF_DEVICE) ||
1732          (((ScriptCache *)*psc)->tm.tmCharSet == SYMBOL_CHARSET)))
1733         psa->fNoGlyphIndex = TRUE;
1734
1735     /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
1736     for (i = 0; i < cChars; i++)
1737     {
1738         int idx = i;
1739         if (rtl) idx = cChars - 1 - i;
1740         /* FIXME: set to better values */
1741         pOutGlyphProps[i].sva.uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
1742         pOutGlyphProps[i].sva.fClusterStart  = 1;
1743         pOutGlyphProps[i].sva.fDiacritic     = 0;
1744         pOutGlyphProps[i].sva.fZeroWidth     = 0;
1745         pOutGlyphProps[i].sva.fReserved      = 0;
1746         pOutGlyphProps[i].sva.fShapeReserved = 0;
1747
1748         /* FIXME: have the shaping engine set this */
1749         pCharProps[i].fCanGlyphAlone = 0;
1750
1751         pwLogClust[i] = idx;
1752     }
1753
1754     if (psa && !psa->fNoGlyphIndex)
1755     {
1756         WCHAR *rChars;
1757         if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
1758
1759         rChars = heap_alloc(sizeof(WCHAR) * cChars);
1760         if (!rChars) return E_OUTOFMEMORY;
1761         for (i = 0; i < cChars; i++)
1762         {
1763             int idx = i;
1764             WCHAR chInput;
1765             if (rtl) idx = cChars - 1 - i;
1766             if (psa->fRTL)
1767                 chInput = mirror_char(pwcChars[idx]);
1768             else
1769                 chInput = pwcChars[idx];
1770             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, chInput)))
1771             {
1772                 WORD glyph;
1773                 if (!hdc) return E_PENDING;
1774                 if (GetGlyphIndicesW(hdc, &chInput, 1, &glyph, 0) == GDI_ERROR) return S_FALSE;
1775                 pwOutGlyphs[i] = set_cache_glyph(psc, chInput, glyph);
1776             }
1777             rChars[i] = chInput;
1778         }
1779
1780         SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
1781         SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
1782         SHAPE_CharGlyphProp(hdc, (ScriptCache *)*psc, psa, pwcChars, cChars, pwOutGlyphs, *pcGlyphs, pwLogClust, pCharProps, pOutGlyphProps);
1783         heap_free(rChars);
1784     }
1785     else
1786     {
1787         TRACE("no glyph translation\n");
1788         for (i = 0; i < cChars; i++)
1789         {
1790             int idx = i;
1791             /* No mirroring done here */
1792             if (rtl) idx = cChars - 1 - i;
1793             pwOutGlyphs[i] = pwcChars[idx];
1794         }
1795     }
1796
1797     return S_OK;
1798 }
1799
1800
1801 /***********************************************************************
1802  *      ScriptShape (USP10.@)
1803  *
1804  * Produce glyphs and visual attributes for a run.
1805  *
1806  * PARAMS
1807  *  hdc         [I]   Device context.
1808  *  psc         [I/O] Opaque pointer to a script cache.
1809  *  pwcChars    [I]   Array of characters specifying the run.
1810  *  cChars      [I]   Number of characters in pwcChars.
1811  *  cMaxGlyphs  [I]   Length of pwOutGlyphs.
1812  *  psa         [I/O] Script analysis.
1813  *  pwOutGlyphs [O]   Array of glyphs.
1814  *  pwLogClust  [O]   Array of logical cluster info.
1815  *  psva        [O]   Array of visual attributes.
1816  *  pcGlyphs    [O]   Number of glyphs returned.
1817  *
1818  * RETURNS
1819  *  Success: S_OK
1820  *  Failure: Non-zero HRESULT value.
1821  */
1822 HRESULT WINAPI ScriptShape(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars,
1823                            int cChars, int cMaxGlyphs,
1824                            SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust,
1825                            SCRIPT_VISATTR *psva, int *pcGlyphs)
1826 {
1827     HRESULT hr;
1828     int i;
1829     SCRIPT_CHARPROP *charProps;
1830     SCRIPT_GLYPHPROP *glyphProps;
1831
1832     if (!psva || !pcGlyphs) return E_INVALIDARG;
1833     if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
1834
1835     charProps = heap_alloc_zero(sizeof(SCRIPT_CHARPROP)*cChars);
1836     if (!charProps) return E_OUTOFMEMORY;
1837     glyphProps = heap_alloc_zero(sizeof(SCRIPT_GLYPHPROP)*cMaxGlyphs);
1838     if (!glyphProps) return E_OUTOFMEMORY;
1839
1840     hr = ScriptShapeOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, pwcChars, cChars, cMaxGlyphs, pwLogClust, charProps, pwOutGlyphs, glyphProps, pcGlyphs);
1841
1842     if (SUCCEEDED(hr))
1843     {
1844         for (i = 0; i < *pcGlyphs; i++)
1845             psva[i] = glyphProps[i].sva;
1846     }
1847
1848     heap_free(charProps);
1849     heap_free(glyphProps);
1850
1851     return hr;
1852 }
1853
1854 /***********************************************************************
1855  *      ScriptPlaceOpenType (USP10.@)
1856  *
1857  * Produce advance widths for a run.
1858  *
1859  * PARAMS
1860  *  hdc       [I]   Device context.
1861  *  psc       [I/O] Opaque pointer to a script cache.
1862  *  psa       [I/O] String analysis.
1863  *  tagScript   [I]   The OpenType tag for the Script
1864  *  tagLangSys  [I]   The OpenType tag for the Language
1865  *  rcRangeChars[I]   Array of Character counts in each range
1866  *  rpRangeProperties [I] Array of TEXTRANGE_PROPERTIES structures
1867  *  cRanges     [I]   Count of ranges
1868  *  pwcChars    [I]   Array of characters specifying the run.
1869  *  pwLogClust  [I]   Array of logical cluster info
1870  *  pCharProps  [I]   Array of character property values
1871  *  cChars      [I]   Number of characters in pwcChars.
1872  *  pwGlyphs  [I]   Array of glyphs.
1873  *  pGlyphProps [I]  Array of attributes for the retrieved glyphs
1874  *  cGlyphs [I] Count of Glyphs
1875  *  piAdvance [O]   Array of advance widths.
1876  *  pGoffset  [O]   Glyph offsets.
1877  *  pABC      [O]   Combined ABC width.
1878  *
1879  * RETURNS
1880  *  Success: S_OK
1881  *  Failure: Non-zero HRESULT value.
1882  */
1883
1884 HRESULT WINAPI ScriptPlaceOpenType( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa,
1885                                     OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys,
1886                                     int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties,
1887                                     int cRanges, const WCHAR *pwcChars, WORD *pwLogClust,
1888                                     SCRIPT_CHARPROP *pCharProps, int cChars,
1889                                     const WORD *pwGlyphs, const SCRIPT_GLYPHPROP *pGlyphProps,
1890                                     int cGlyphs, int *piAdvance,
1891                                     GOFFSET *pGoffset, ABC *pABC
1892 )
1893 {
1894     HRESULT hr;
1895     int i;
1896
1897     TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %p, %p, %d, %p, %p, %d, %p %p %p)\n",
1898      hdc, psc, psa,
1899      debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
1900      rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
1901      pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance,
1902      pGoffset, pABC);
1903
1904     if (!pGlyphProps) return E_INVALIDARG;
1905     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
1906     if (!pGoffset) return E_FAIL;
1907
1908     if (cRanges)
1909         FIXME("Ranges not supported yet\n");
1910
1911     ((ScriptCache *)*psc)->userScript = tagScript;
1912     ((ScriptCache *)*psc)->userLang = tagLangSys;
1913
1914     if (pABC) memset(pABC, 0, sizeof(ABC));
1915     for (i = 0; i < cGlyphs; i++)
1916     {
1917         ABC abc;
1918         if (!get_cache_glyph_widths(psc, pwGlyphs[i], &abc))
1919         {
1920             if (!hdc) return E_PENDING;
1921             if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE) && !psa->fNoGlyphIndex)
1922             {
1923                 if (!GetCharABCWidthsI(hdc, 0, 1, (WORD *)&pwGlyphs[i], &abc)) return S_FALSE;
1924             }
1925             else
1926             {
1927                 INT width;
1928                 if (!GetCharWidth32W(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
1929                 abc.abcB = width;
1930                 abc.abcA = abc.abcC = 0;
1931             }
1932             set_cache_glyph_widths(psc, pwGlyphs[i], &abc);
1933         }
1934         if (pABC)
1935         {
1936             pABC->abcA += abc.abcA;
1937             pABC->abcB += abc.abcB;
1938             pABC->abcC += abc.abcC;
1939         }
1940         /* FIXME: set to more reasonable values */
1941         pGoffset[i].du = pGoffset[i].dv = 0;
1942         if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
1943     }
1944
1945     if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
1946     return S_OK;
1947 }
1948
1949 /***********************************************************************
1950  *      ScriptPlace (USP10.@)
1951  *
1952  * Produce advance widths for a run.
1953  *
1954  * PARAMS
1955  *  hdc       [I]   Device context.
1956  *  psc       [I/O] Opaque pointer to a script cache.
1957  *  pwGlyphs  [I]   Array of glyphs.
1958  *  cGlyphs   [I]   Number of glyphs in pwGlyphs.
1959  *  psva      [I]   Array of visual attributes.
1960  *  psa       [I/O] String analysis.
1961  *  piAdvance [O]   Array of advance widths.
1962  *  pGoffset  [O]   Glyph offsets.
1963  *  pABC      [O]   Combined ABC width.
1964  *
1965  * RETURNS
1966  *  Success: S_OK
1967  *  Failure: Non-zero HRESULT value.
1968  */
1969 HRESULT WINAPI ScriptPlace(HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs,
1970                            int cGlyphs, const SCRIPT_VISATTR *psva,
1971                            SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC )
1972 {
1973     HRESULT hr;
1974     SCRIPT_GLYPHPROP *glyphProps;
1975     int i;
1976
1977     TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n",  hdc, psc, pwGlyphs, cGlyphs, psva, psa,
1978           piAdvance, pGoffset, pABC);
1979
1980     if (!psva) return E_INVALIDARG;
1981     if (!pGoffset) return E_FAIL;
1982
1983     glyphProps = heap_alloc(sizeof(SCRIPT_GLYPHPROP)*cGlyphs);
1984     if (!glyphProps) return E_OUTOFMEMORY;
1985
1986     for (i = 0; i < cGlyphs; i++)
1987         glyphProps[i].sva = psva[i];
1988
1989     hr = ScriptPlaceOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, NULL, NULL, NULL, 0, pwGlyphs, glyphProps, cGlyphs, piAdvance, pGoffset, pABC);
1990
1991     heap_free(glyphProps);
1992
1993     return hr;
1994 }
1995
1996 /***********************************************************************
1997  *      ScriptGetCMap (USP10.@)
1998  *
1999  * Retrieve glyph indices.
2000  *
2001  * PARAMS
2002  *  hdc         [I]   Device context.
2003  *  psc         [I/O] Opaque pointer to a script cache.
2004  *  pwcInChars  [I]   Array of Unicode characters.
2005  *  cChars      [I]   Number of characters in pwcInChars.
2006  *  dwFlags     [I]   Flags.
2007  *  pwOutGlyphs [O]   Buffer to receive the array of glyph indices.
2008  *
2009  * RETURNS
2010  *  Success: S_OK
2011  *  Failure: Non-zero HRESULT value.
2012  */
2013 HRESULT WINAPI ScriptGetCMap(HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars,
2014                              int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
2015 {
2016     HRESULT hr;
2017     int i;
2018
2019     TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
2020           cChars, dwFlags, pwOutGlyphs);
2021
2022     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2023
2024     hr = S_OK;
2025
2026     if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
2027     {
2028         for (i = 0; i < cChars; i++)
2029         {
2030             WCHAR inChar;
2031             if (dwFlags == SGCM_RTL)
2032                 inChar = mirror_char(pwcInChars[i]);
2033             else
2034                 inChar = pwcInChars[i];
2035             if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
2036             {
2037                 WORD glyph;
2038                 if (!hdc) return E_PENDING;
2039                 if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
2040                 if (glyph == 0xffff)
2041                 {
2042                     hr = S_FALSE;
2043                     glyph = 0x0;
2044                 }
2045                 pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
2046             }
2047         }
2048     }
2049     else
2050     {
2051         TRACE("no glyph translation\n");
2052         for (i = 0; i < cChars; i++)
2053         {
2054             WCHAR inChar;
2055             if (dwFlags == SGCM_RTL)
2056                 inChar = mirror_char(pwcInChars[i]);
2057             else
2058                 inChar = pwcInChars[i];
2059             pwOutGlyphs[i] = inChar;
2060         }
2061     }
2062     return hr;
2063 }
2064
2065 /***********************************************************************
2066  *      ScriptTextOut (USP10.@)
2067  *
2068  */
2069 HRESULT WINAPI ScriptTextOut(const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions,
2070                              const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved,
2071                              int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance,
2072                              const int *piJustify, const GOFFSET *pGoffset)
2073 {
2074     HRESULT hr = S_OK;
2075
2076     TRACE("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p)\n",
2077          hdc, psc, x, y, fuOptions, lprc, psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
2078          piAdvance, piJustify, pGoffset);
2079
2080     if (!hdc || !psc) return E_INVALIDARG;
2081     if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
2082
2083     fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
2084     fuOptions |= ETO_IGNORELANGUAGE;
2085     if  (!psa->fNoGlyphIndex)                                     /* Have Glyphs?                      */
2086         fuOptions |= ETO_GLYPH_INDEX;                             /* Say don't do translation to glyph */
2087
2088     if (psa->fRTL && psa->fLogicalOrder)
2089     {
2090         int i;
2091         WORD *rtlGlyphs;
2092
2093         rtlGlyphs = heap_alloc(cGlyphs * sizeof(WORD));
2094         if (!rtlGlyphs)
2095             return E_OUTOFMEMORY;
2096
2097         for (i = 0; i < cGlyphs; i++)
2098             rtlGlyphs[i] = pwGlyphs[cGlyphs-1-i];
2099
2100         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, rtlGlyphs, cGlyphs, NULL))
2101             hr = S_FALSE;
2102         heap_free(rtlGlyphs);
2103     }
2104     else
2105         if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, pwGlyphs, cGlyphs, NULL))
2106             hr = S_FALSE;
2107
2108     return hr;
2109 }
2110
2111 /***********************************************************************
2112  *      ScriptCacheGetHeight (USP10.@)
2113  *
2114  * Retrieve the height of the font in the cache.
2115  *
2116  * PARAMS
2117  *  hdc    [I]    Device context.
2118  *  psc    [I/O]  Opaque pointer to a script cache.
2119  *  height [O]    Receives font height.
2120  *
2121  * RETURNS
2122  *  Success: S_OK
2123  *  Failure: Non-zero HRESULT value.
2124  */
2125 HRESULT WINAPI ScriptCacheGetHeight(HDC hdc, SCRIPT_CACHE *psc, LONG *height)
2126 {
2127     HRESULT hr;
2128
2129     TRACE("(%p, %p, %p)\n", hdc, psc, height);
2130
2131     if (!height) return E_INVALIDARG;
2132     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2133
2134     *height = get_cache_height(psc);
2135     return S_OK;
2136 }
2137
2138 /***********************************************************************
2139  *      ScriptGetGlyphABCWidth (USP10.@)
2140  *
2141  * Retrieve the width of a glyph.
2142  *
2143  * PARAMS
2144  *  hdc    [I]    Device context.
2145  *  psc    [I/O]  Opaque pointer to a script cache.
2146  *  glyph  [I]    Glyph to retrieve the width for.
2147  *  abc    [O]    ABC widths of the glyph.
2148  *
2149  * RETURNS
2150  *  Success: S_OK
2151  *  Failure: Non-zero HRESULT value.
2152  */
2153 HRESULT WINAPI ScriptGetGlyphABCWidth(HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
2154 {
2155     HRESULT hr;
2156
2157     TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
2158
2159     if (!abc) return E_INVALIDARG;
2160     if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
2161
2162     if (!get_cache_glyph_widths(psc, glyph, abc))
2163     {
2164         if (!hdc) return E_PENDING;
2165         if ((get_cache_pitch_family(psc) & TMPF_TRUETYPE))
2166         {
2167             if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
2168         }
2169         else
2170         {
2171             INT width;
2172             if (!GetCharWidth32W(hdc, glyph, glyph, &width)) return S_FALSE;
2173             abc->abcB = width;
2174             abc->abcA = abc->abcC = 0;
2175         }
2176         set_cache_glyph_widths(psc, glyph, abc);
2177     }
2178     return S_OK;
2179 }
2180
2181 /***********************************************************************
2182  *      ScriptLayout (USP10.@)
2183  *
2184  * Map embedding levels to visual and/or logical order.
2185  *
2186  * PARAMS
2187  *  runs     [I] Size of level array.
2188  *  level    [I] Array of embedding levels.
2189  *  vistolog [O] Map of embedding levels from visual to logical order.
2190  *  logtovis [O] Map of embedding levels from logical to visual order.
2191  *
2192  * RETURNS
2193  *  Success: S_OK
2194  *  Failure: Non-zero HRESULT value.
2195  *
2196  * BUGS
2197  *  This stub works correctly for any sequence of a single
2198  *  embedding level but not for sequences of different
2199  *  embedding levels, i.e. mixtures of RTL and LTR scripts.
2200  */
2201 HRESULT WINAPI ScriptLayout(int runs, const BYTE *level, int *vistolog, int *logtovis)
2202 {
2203     int* indexs;
2204     int ich;
2205
2206     TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
2207
2208     if (!level || (!vistolog && !logtovis))
2209         return E_INVALIDARG;
2210
2211     indexs = heap_alloc(sizeof(int) * runs);
2212     if (!indexs)
2213         return E_OUTOFMEMORY;
2214
2215
2216     if (vistolog)
2217     {
2218         for( ich = 0; ich < runs; ich++)
2219             indexs[ich] = ich;
2220
2221         ich = 0;
2222         while (ich < runs)
2223             ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
2224         for (ich = 0; ich < runs; ich++)
2225             vistolog[ich] = indexs[ich];
2226     }
2227
2228
2229     if (logtovis)
2230     {
2231         for( ich = 0; ich < runs; ich++)
2232             indexs[ich] = ich;
2233
2234         ich = 0;
2235         while (ich < runs)
2236             ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
2237         for (ich = 0; ich < runs; ich++)
2238             logtovis[ich] = indexs[ich];
2239     }
2240     heap_free(indexs);
2241
2242     return S_OK;
2243 }
2244
2245 /***********************************************************************
2246  *      ScriptStringGetLogicalWidths (USP10.@)
2247  *
2248  * Returns logical widths from a string analysis.
2249  *
2250  * PARAMS
2251  *  ssa  [I] string analysis.
2252  *  piDx [O] logical widths returned.
2253  *
2254  * RETURNS
2255  *  Success: S_OK
2256  *  Failure: a non-zero HRESULT.
2257  */
2258 HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
2259 {
2260     int i, j, next = 0;
2261     StringAnalysis *analysis = ssa;
2262
2263     TRACE("%p, %p\n", ssa, piDx);
2264
2265     if (!analysis) return S_FALSE;
2266
2267     for (i = 0; i < analysis->numItems; i++)
2268     {
2269         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
2270         {
2271             piDx[next] = analysis->glyphs[i].piAdvance[j];
2272             next++;
2273         }
2274     }
2275     return S_OK;
2276 }
2277
2278 /***********************************************************************
2279  *      ScriptStringValidate (USP10.@)
2280  *
2281  * Validate a string analysis.
2282  *
2283  * PARAMS
2284  *  ssa [I] string analysis.
2285  *
2286  * RETURNS
2287  *  Success: S_OK
2288  *  Failure: S_FALSE if invalid sequences are found
2289  *           or a non-zero HRESULT if it fails.
2290  */
2291 HRESULT WINAPI ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa)
2292 {
2293     StringAnalysis *analysis = ssa;
2294
2295     TRACE("(%p)\n", ssa);
2296
2297     if (!analysis) return E_INVALIDARG;
2298     return (analysis->invalid) ? S_FALSE : S_OK;
2299 }
2300
2301 /***********************************************************************
2302  *      ScriptString_pSize (USP10.@)
2303  *
2304  * Retrieve width and height of an analysed string.
2305  *
2306  * PARAMS
2307  *  ssa [I] string analysis.
2308  *
2309  * RETURNS
2310  *  Success: Pointer to a SIZE structure.
2311  *  Failure: NULL
2312  */
2313 const SIZE * WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
2314 {
2315     int i, j;
2316     StringAnalysis *analysis = ssa;
2317
2318     TRACE("(%p)\n", ssa);
2319
2320     if (!analysis) return NULL;
2321
2322     if (!analysis->sz)
2323     {
2324         if (!(analysis->sz = heap_alloc(sizeof(SIZE)))) return NULL;
2325         analysis->sz->cy = analysis->sc->tm.tmHeight;
2326
2327         analysis->sz->cx = 0;
2328         for (i = 0; i < analysis->numItems; i++)
2329             for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
2330                 analysis->sz->cx += analysis->glyphs[i].piAdvance[j];
2331     }
2332     return analysis->sz;
2333 }
2334
2335 /***********************************************************************
2336  *      ScriptString_pLogAttr (USP10.@)
2337  *
2338  * Retrieve logical attributes of an analysed string.
2339  *
2340  * PARAMS
2341  *  ssa [I] string analysis.
2342  *
2343  * RETURNS
2344  *  Success: Pointer to an array of SCRIPT_LOGATTR structures.
2345  *  Failure: NULL
2346  */
2347 const SCRIPT_LOGATTR * WINAPI ScriptString_pLogAttr(SCRIPT_STRING_ANALYSIS ssa)
2348 {
2349     StringAnalysis *analysis = ssa;
2350
2351     TRACE("(%p)\n", ssa);
2352
2353     if (!analysis) return NULL;
2354     return analysis->logattrs;
2355 }
2356
2357 /***********************************************************************
2358  *      ScriptString_pcOutChars (USP10.@)
2359  *
2360  * Retrieve the length of a string after clipping.
2361  *
2362  * PARAMS
2363  *  ssa [I] String analysis.
2364  *
2365  * RETURNS
2366  *  Success: Pointer to the length.
2367  *  Failure: NULL
2368  */
2369 const int * WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
2370 {
2371     StringAnalysis *analysis = ssa;
2372
2373     TRACE("(%p)\n", ssa);
2374
2375     if (!analysis) return NULL;
2376     return &analysis->clip_len;
2377 }
2378
2379 /***********************************************************************
2380  *      ScriptStringGetOrder (USP10.@)
2381  *
2382  * Retrieve a glyph order map.
2383  *
2384  * PARAMS
2385  *  ssa   [I]   String analysis.
2386  *  order [I/O] Array of glyph positions.
2387  *
2388  * RETURNS
2389  *  Success: S_OK
2390  *  Failure: a non-zero HRESULT.
2391  */
2392 HRESULT WINAPI ScriptStringGetOrder(SCRIPT_STRING_ANALYSIS ssa, UINT *order)
2393 {
2394     int i, j;
2395     unsigned int k;
2396     StringAnalysis *analysis = ssa;
2397
2398     TRACE("(%p)\n", ssa);
2399
2400     if (!analysis) return S_FALSE;
2401
2402     /* FIXME: handle RTL scripts */
2403     for (i = 0, k = 0; i < analysis->numItems; i++)
2404         for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
2405             order[k] = k;
2406
2407     return S_OK;
2408 }
2409
2410 /***********************************************************************
2411  *      ScriptGetLogicalWidths (USP10.@)
2412  *
2413  * Convert advance widths to logical widths.
2414  *
2415  * PARAMS
2416  *  sa          [I] Script analysis.
2417  *  nbchars     [I] Number of characters.
2418  *  nbglyphs    [I] Number of glyphs.
2419  *  glyph_width [I] Array of glyph widths.
2420  *  log_clust   [I] Array of logical clusters.
2421  *  sva         [I] Visual attributes.
2422  *  widths      [O] Array of logical widths.
2423  *
2424  * RETURNS
2425  *  Success: S_OK
2426  *  Failure: a non-zero HRESULT.
2427  */
2428 HRESULT WINAPI ScriptGetLogicalWidths(const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs,
2429                                       const int *glyph_width, const WORD *log_clust,
2430                                       const SCRIPT_VISATTR *sva, int *widths)
2431 {
2432     int i;
2433
2434     TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
2435           sa, nbchars, nbglyphs, glyph_width, log_clust, sva, widths);
2436
2437     /* FIXME */
2438     for (i = 0; i < nbchars; i++) widths[i] = glyph_width[i];
2439     return S_OK;
2440 }
2441
2442 /***********************************************************************
2443  *      ScriptApplyLogicalWidth (USP10.@)
2444  *
2445  * Generate glyph advance widths.
2446  *
2447  * PARAMS
2448  *  dx          [I]   Array of logical advance widths.
2449  *  num_chars   [I]   Number of characters.
2450  *  num_glyphs  [I]   Number of glyphs.
2451  *  log_clust   [I]   Array of logical clusters.
2452  *  sva         [I]   Visual attributes.
2453  *  advance     [I]   Array of glyph advance widths.
2454  *  sa          [I]   Script analysis.
2455  *  abc         [I/O] Summed ABC widths.
2456  *  justify     [O]   Array of glyph advance widths.
2457  *
2458  * RETURNS
2459  *  Success: S_OK
2460  *  Failure: a non-zero HRESULT.
2461  */
2462 HRESULT WINAPI ScriptApplyLogicalWidth(const int *dx, int num_chars, int num_glyphs,
2463                                        const WORD *log_clust, const SCRIPT_VISATTR *sva,
2464                                        const int *advance, const SCRIPT_ANALYSIS *sa,
2465                                        ABC *abc, int *justify)
2466 {
2467     int i;
2468
2469     FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
2470           dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
2471
2472     for (i = 0; i < num_chars; i++) justify[i] = advance[i];
2473     return S_OK;
2474 }
2475
2476 HRESULT WINAPI ScriptJustify(const SCRIPT_VISATTR *sva, const int *advance,
2477                              int num_glyphs, int dx, int min_kashida, int *justify)
2478 {
2479     int i;
2480
2481     FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
2482
2483     for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
2484     return S_OK;
2485 }