dlls/usp10/shape.c

   1 /*
   2  * Implementation of Shaping for the Uniscribe Script Processor (usp10.dll)
   3  *
   4  * Copyright 2010 CodeWeavers, Aric Stewart
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "winuser.h"
  27 #include "winnls.h"
  28 #include "usp10.h"
  29 #include "winternl.h"
  30
  31 #include "usp10_internal.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  36
  37 #define FIRST_ARABIC_CHAR 0x0600
  38 #define LAST_ARABIC_CHAR  0x06ff
  39
  40 typedef VOID (*ContextualShapingProc)(HDC, ScriptCache*, SCRIPT_ANALYSIS*,
  41                                       WCHAR*, INT, WORD*, INT*, INT, WORD*);
  42
  43 static void ContextualShape_Arabic(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  44 static void ContextualShape_Syriac(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  45
  46 extern const unsigned short wine_shaping_table[];
  47 extern const unsigned short wine_shaping_forms[LAST_ARABIC_CHAR - FIRST_ARABIC_CHAR + 1][4];
  48
  49 enum joining_types {
  50     jtU,
  51     jtT,
  52     jtR,
  53     jtL,
  54     jtD,
  55     jtC
  56 };
  57
  58 enum joined_forms {
  59     Xn=0,
  60     Xr,
  61     Xl,
  62     Xm,
  63     /* Syriac Alaph */
  64     Afj,
  65     Afn,
  66     Afx
  67 };
  68
  69 #ifdef WORDS_BIGENDIAN
  70 #define GET_BE_WORD(x) (x)
  71 #else
  72 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
  73 #endif
  74
  75 /* These are all structures needed for the GSUB table */
  76 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
  77           ( ( (ULONG)_x4 << 24 ) |     \
  78             ( (ULONG)_x3 << 16 ) |     \
  79             ( (ULONG)_x2 <<  8 ) |     \
  80               (ULONG)_x1         )
  81
  82 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
  83 #define GSUB_E_NOFEATURE -2
  84 #define GSUB_E_NOGLYPH -1
  85
  86 typedef struct {
  87     DWORD version;
  88     WORD ScriptList;
  89     WORD FeatureList;
  90     WORD LookupList;
  91 } GSUB_Header;
  92
  93 typedef struct {
  94     CHAR ScriptTag[4];
  95     WORD Script;
  96 } GSUB_ScriptRecord;
  97
  98 typedef struct {
  99     WORD ScriptCount;
 100     GSUB_ScriptRecord ScriptRecord[1];
 101 } GSUB_ScriptList;
 102
 103 typedef struct {
 104     CHAR LangSysTag[4];
 105     WORD LangSys;
 106 } GSUB_LangSysRecord;
 107
 108 typedef struct {
 109     WORD DefaultLangSys;
 110     WORD LangSysCount;
 111     GSUB_LangSysRecord LangSysRecord[1];
 112 } GSUB_Script;
 113
 114 typedef struct {
 115     WORD LookupOrder; /* Reserved */
 116     WORD ReqFeatureIndex;
 117     WORD FeatureCount;
 118     WORD FeatureIndex[1];
 119 } GSUB_LangSys;
 120
 121 typedef struct {
 122     CHAR FeatureTag[4];
 123     WORD Feature;
 124 } GSUB_FeatureRecord;
 125
 126 typedef struct {
 127     WORD FeatureCount;
 128     GSUB_FeatureRecord FeatureRecord[1];
 129 } GSUB_FeatureList;
 130
 131 typedef struct {
 132     WORD FeatureParams; /* Reserved */
 133     WORD LookupCount;
 134     WORD LookupListIndex[1];
 135 } GSUB_Feature;
 136
 137 typedef struct {
 138     WORD LookupCount;
 139     WORD Lookup[1];
 140 } GSUB_LookupList;
 141
 142 typedef struct {
 143     WORD LookupType;
 144     WORD LookupFlag;
 145     WORD SubTableCount;
 146     WORD SubTable[1];
 147 } GSUB_LookupTable;
 148
 149 typedef struct {
 150     WORD CoverageFormat;
 151     WORD GlyphCount;
 152     WORD GlyphArray[1];
 153 } GSUB_CoverageFormat1;
 154
 155 typedef struct {
 156     WORD Start;
 157     WORD End;
 158     WORD StartCoverageIndex;
 159 } GSUB_RangeRecord;
 160
 161 typedef struct {
 162     WORD CoverageFormat;
 163     WORD RangeCount;
 164     GSUB_RangeRecord RangeRecord[1];
 165 } GSUB_CoverageFormat2;
 166
 167 typedef struct {
 168     WORD SubstFormat; /* = 1 */
 169     WORD Coverage;
 170     WORD DeltaGlyphID;
 171 } GSUB_SingleSubstFormat1;
 172
 173 typedef struct {
 174     WORD SubstFormat; /* = 2 */
 175     WORD Coverage;
 176     WORD GlyphCount;
 177     WORD Substitute[1];
 178 }GSUB_SingleSubstFormat2;
 179
 180 typedef struct {
 181     WORD SubstFormat; /* = 1 */
 182     WORD Coverage;
 183     WORD LigSetCount;
 184     WORD LigatureSet[1];
 185 }GSUB_LigatureSubstFormat1;
 186
 187 typedef struct {
 188     WORD LigatureCount;
 189     WORD Ligature[1];
 190 }GSUB_LigatureSet;
 191
 192 typedef struct{
 193     WORD LigGlyph;
 194     WORD CompCount;
 195     WORD Component[1];
 196 }GSUB_Ligature;
 197
 198 typedef struct{
 199     WORD SequenceIndex;
 200     WORD LookupListIndex;
 201
 202 }GSUB_SubstLookupRecord;
 203
 204 typedef struct{
 205     WORD SubstFormat; /* = 1 */
 206     WORD Coverage;
 207     WORD ChainSubRuleSetCount;
 208     WORD ChainSubRuleSet[1];
 209 }GSUB_ChainContextSubstFormat1;
 210
 211 typedef struct {
 212     WORD SubstFormat; /* = 3 */
 213     WORD BacktrackGlyphCount;
 214     WORD Coverage[1];
 215 }GSUB_ChainContextSubstFormat3_1;
 216
 217 typedef struct{
 218     WORD InputGlyphCount;
 219     WORD Coverage[1];
 220 }GSUB_ChainContextSubstFormat3_2;
 221
 222 typedef struct{
 223     WORD LookaheadGlyphCount;
 224     WORD Coverage[1];
 225 }GSUB_ChainContextSubstFormat3_3;
 226
 227 typedef struct{
 228     WORD SubstCount;
 229     GSUB_SubstLookupRecord SubstLookupRecord[1];
 230 }GSUB_ChainContextSubstFormat3_4;
 231
 232 typedef struct {
 233     WORD SubstFormat; /* = 1 */
 234     WORD Coverage;
 235     WORD AlternateSetCount;
 236     WORD AlternateSet[1];
 237 } GSUB_AlternateSubstFormat1;
 238
 239 typedef struct{
 240     WORD GlyphCount;
 241     WORD Alternate[1];
 242 } GSUB_AlternateSet;
 243
 244 static INT GSUB_apply_lookup(const GSUB_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count);
 245
 246 /* the orders of joined_forms and contextual_features need to line up */
 247 static const char* contextual_features[] =
 248 {
 249     "isol",
 250     "fina",
 251     "init",
 252     "medi",
 253     /* Syriac Alaph */
 254     "med2",
 255     "fin2",
 256     "fin3"
 257 };
 258
 259 static OPENTYPE_FEATURE_RECORD standard_features[] =
 260 {
 261     { 0x6167696c /*liga*/, 1},
 262     { 0x67696c63 /*clig*/, 1},
 263 };
 264
 265 static OPENTYPE_FEATURE_RECORD arabic_features[] =
 266 {
 267     { 0x67696c72 /*rlig*/, 1},
 268     { 0x746c6163 /*calt*/, 1},
 269     { 0x6167696c /*liga*/, 1},
 270     { 0x67696c64 /*dlig*/, 1},
 271     { 0x68777363 /*cswh*/, 1},
 272     { 0x7465736d /*mset*/, 1},
 273 };
 274
 275 static OPENTYPE_FEATURE_RECORD hebrew_features[] =
 276 {
 277     { 0x67696c64 /*dlig*/, 1},
 278 };
 279
 280 static OPENTYPE_FEATURE_RECORD syriac_features[] =
 281 {
 282     { 0x67696c72 /*rlig*/, 1},
 283     { 0x746c6163 /*calt*/, 1},
 284     { 0x6167696c /*liga*/, 1},
 285     { 0x67696c64 /*dlig*/, 1},
 286 };
 287
 288 typedef struct ScriptShapeDataTag {
 289     TEXTRANGE_PROPERTIES  defaultTextRange;
 290     CHAR                  otTag[5];
 291     ContextualShapingProc contextProc;
 292 } ScriptShapeData;
 293
 294 /* in order of scripts */
 295 static const ScriptShapeData ShapingData[] =
 296 {
 297     {{ standard_features, 2}, "", NULL},
 298     {{ standard_features, 2}, "latn", NULL},
 299     {{ standard_features, 2}, "latn", NULL},
 300     {{ standard_features, 2}, "latn", NULL},
 301     {{ standard_features, 2}, "" , NULL},
 302     {{ standard_features, 2}, "latn", NULL},
 303     {{ arabic_features, 6}, "arab", ContextualShape_Arabic},
 304     {{ arabic_features, 6}, "arab", ContextualShape_Arabic},
 305     {{ hebrew_features, 1}, "hebr", NULL},
 306     {{ syriac_features, 4}, "syrc", ContextualShape_Syriac},
 307     {{ arabic_features, 6}, "arab", ContextualShape_Arabic},
 308 };
 309
 310 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
 311 {
 312     const GSUB_CoverageFormat1* cf1;
 313
 314     cf1 = table;
 315
 316     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
 317     {
 318         int count = GET_BE_WORD(cf1->GlyphCount);
 319         int i;
 320         TRACE("Coverage Format 1, %i glyphs\n",count);
 321         for (i = 0; i < count; i++)
 322             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
 323                 return i;
 324         return -1;
 325     }
 326     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
 327     {
 328         const GSUB_CoverageFormat2* cf2;
 329         int i;
 330         int count;
 331         cf2 = (const GSUB_CoverageFormat2*)cf1;
 332
 333         count = GET_BE_WORD(cf2->RangeCount);
 334         TRACE("Coverage Format 2, %i ranges\n",count);
 335         for (i = 0; i < count; i++)
 336         {
 337             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
 338                 return -1;
 339             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
 340                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
 341             {
 342                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
 343                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
 344             }
 345         }
 346         return -1;
 347     }
 348     else
 349         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
 350
 351     return -1;
 352 }
 353
 354 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
 355 {
 356     const GSUB_ScriptList *script;
 357     const GSUB_Script *deflt = NULL;
 358     int i;
 359     script = (const GSUB_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
 360
 361     TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
 362     for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
 363     {
 364         const GSUB_Script *scr;
 365         int offset;
 366
 367         offset = GET_BE_WORD(script->ScriptRecord[i].Script);
 368         scr = (const GSUB_Script*)((const BYTE*)script + offset);
 369
 370         if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
 371             return scr;
 372         if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
 373             deflt = scr;
 374     }
 375     return deflt;
 376 }
 377
 378 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
 379 {
 380     int i;
 381     int offset;
 382     const GSUB_LangSys *Lang;
 383
 384     TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
 385
 386     for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
 387     {
 388         offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
 389         Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
 390
 391         if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
 392             return Lang;
 393     }
 394     offset = GET_BE_WORD(script->DefaultLangSys);
 395     if (offset)
 396     {
 397         Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
 398         return Lang;
 399     }
 400     return NULL;
 401 }
 402
 403 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
 404 {
 405     int i;
 406     const GSUB_FeatureList *feature;
 407     feature = (const GSUB_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
 408
 409     TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
 410     for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
 411     {
 412         int index = GET_BE_WORD(lang->FeatureIndex[i]);
 413         if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
 414         {
 415             const GSUB_Feature *feat;
 416             feat = (const GSUB_Feature*)((const BYTE*)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
 417             return feat;
 418         }
 419     }
 420     return NULL;
 421 }
 422
 423 static INT GSUB_apply_SingleSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 424 {
 425     int j;
 426     TRACE("Single Substitution Subtable\n");
 427
 428     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 429     {
 430         int offset;
 431         const GSUB_SingleSubstFormat1 *ssf1;
 432         offset = GET_BE_WORD(look->SubTable[j]);
 433         ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
 434         if (GET_BE_WORD(ssf1->SubstFormat) == 1)
 435         {
 436             int offset = GET_BE_WORD(ssf1->Coverage);
 437             TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
 438             if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyphs[glyph_index]) != -1)
 439             {
 440                 TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 441                 glyphs[glyph_index] = glyphs[glyph_index] + GET_BE_WORD(ssf1->DeltaGlyphID);
 442                 TRACE(" 0x%x\n",glyphs[glyph_index]);
 443                 return glyph_index + 1;
 444             }
 445         }
 446         else
 447         {
 448             const GSUB_SingleSubstFormat2 *ssf2;
 449             INT index;
 450             INT offset;
 451
 452             ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
 453             offset = GET_BE_WORD(ssf1->Coverage);
 454             TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
 455             index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyphs[glyph_index]);
 456             TRACE("  Coverage index %i\n",index);
 457             if (index != -1)
 458             {
 459                 TRACE("    Glyph is 0x%x ->",glyphs[glyph_index]);
 460                 glyphs[glyph_index] = GET_BE_WORD(ssf2->Substitute[index]);
 461                 TRACE("0x%x\n",glyphs[glyph_index]);
 462                 return glyph_index + 1;
 463             }
 464         }
 465     }
 466     return GSUB_E_NOGLYPH;
 467 }
 468
 469 static INT GSUB_apply_AlternateSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 470 {
 471     int j;
 472     TRACE("Alternate Substitution Subtable\n");
 473
 474     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 475     {
 476         int offset;
 477         const GSUB_AlternateSubstFormat1 *asf1;
 478         INT index;
 479
 480         offset = GET_BE_WORD(look->SubTable[j]);
 481         asf1 = (const GSUB_AlternateSubstFormat1*)((const BYTE*)look+offset);
 482         offset = GET_BE_WORD(asf1->Coverage);
 483
 484         index = GSUB_is_glyph_covered((const BYTE*)asf1+offset, glyphs[glyph_index]);
 485         if (index != -1)
 486         {
 487             const GSUB_AlternateSet *as;
 488             offset =  GET_BE_WORD(asf1->AlternateSet[index]);
 489             as = (const GSUB_AlternateSet*)((const BYTE*)asf1+offset);
 490             FIXME("%i alternates, picking index 0\n",GET_BE_WORD(as->GlyphCount));
 491
 492             TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 493             glyphs[glyph_index] = GET_BE_WORD(as->Alternate[0]);
 494             TRACE(" 0x%x\n",glyphs[glyph_index]);
 495             return glyph_index + 1;
 496         }
 497     }
 498     return GSUB_E_NOGLYPH;
 499 }
 500
 501 static INT GSUB_apply_LigatureSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 502 {
 503     int j;
 504
 505     TRACE("Ligature Substitution Subtable\n");
 506     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 507     {
 508         const GSUB_LigatureSubstFormat1 *lsf1;
 509         int offset,index;
 510
 511         offset = GET_BE_WORD(look->SubTable[j]);
 512         lsf1 = (const GSUB_LigatureSubstFormat1*)((const BYTE*)look+offset);
 513         offset = GET_BE_WORD(lsf1->Coverage);
 514         index = GSUB_is_glyph_covered((const BYTE*)lsf1+offset, glyphs[glyph_index]);
 515         TRACE("  Coverage index %i\n",index);
 516         if (index != -1)
 517         {
 518             const GSUB_LigatureSet *ls;
 519             int k, count;
 520
 521             offset = GET_BE_WORD(lsf1->LigatureSet[index]);
 522             ls = (const GSUB_LigatureSet*)((const BYTE*)lsf1+offset);
 523             count = GET_BE_WORD(ls->LigatureCount);
 524             TRACE("  LigatureSet has %i members\n",count);
 525             for (k = 0; k < count; k++)
 526             {
 527                 const GSUB_Ligature *lig;
 528                 int CompCount,l,CompIndex;
 529
 530                 offset = GET_BE_WORD(ls->Ligature[k]);
 531                 lig = (const GSUB_Ligature*)((const BYTE*)ls+offset);
 532                 CompCount = GET_BE_WORD(lig->CompCount) - 1;
 533                 CompIndex = glyph_index+write_dir;
 534                 for (l = 0; l < CompCount && CompIndex >= 0 && CompIndex < *glyph_count; l++)
 535                 {
 536                     int CompGlyph;
 537                     CompGlyph = GET_BE_WORD(lig->Component[l]);
 538                     if (CompGlyph != glyphs[CompIndex])
 539                         break;
 540                     CompIndex += write_dir;
 541                 }
 542                 if (l == CompCount)
 543                 {
 544                     int replaceIdx = glyph_index;
 545                     if (write_dir < 0)
 546                         replaceIdx = glyph_index - CompCount;
 547
 548                     TRACE("    Glyph is 0x%x (+%i) ->",glyphs[glyph_index],CompCount);
 549                     glyphs[replaceIdx] = GET_BE_WORD(lig->LigGlyph);
 550                     TRACE("0x%x\n",glyphs[replaceIdx]);
 551                     if (CompCount > 0)
 552                     {
 553                         int j;
 554                         for (j = replaceIdx + 1; j < *glyph_count; j++)
 555                             glyphs[j] =glyphs[j+CompCount];
 556                         *glyph_count = *glyph_count - CompCount;
 557                     }
 558                     return replaceIdx + 1;
 559                 }
 560             }
 561         }
 562     }
 563     return GSUB_E_NOGLYPH;
 564 }
 565
 566 static INT GSUB_apply_ChainContextSubst(const GSUB_LookupList* lookup, const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 567 {
 568     int j;
 569     BOOL done = FALSE;
 570
 571     TRACE("Chaining Contextual Substitution Subtable\n");
 572     for (j = 0; j < GET_BE_WORD(look->SubTableCount) && !done; j++)
 573     {
 574         const GSUB_ChainContextSubstFormat1 *ccsf1;
 575         int offset;
 576         int dirLookahead = write_dir;
 577         int dirBacktrack = -1 * write_dir;
 578
 579         offset = GET_BE_WORD(look->SubTable[j]);
 580         ccsf1 = (const GSUB_ChainContextSubstFormat1*)((const BYTE*)look+offset);
 581         if (GET_BE_WORD(ccsf1->SubstFormat) == 1)
 582         {
 583             FIXME("  TODO: subtype 1 (Simple context glyph substitution)\n");
 584             return -1;
 585         }
 586         else if (GET_BE_WORD(ccsf1->SubstFormat) == 2)
 587         {
 588             FIXME("  TODO: subtype 2 (Class-based Chaining Context Glyph Substitution)\n");
 589             return -1;
 590         }
 591         else if (GET_BE_WORD(ccsf1->SubstFormat) == 3)
 592         {
 593             int k;
 594             int indexGlyphs;
 595             const GSUB_ChainContextSubstFormat3_1 *ccsf3_1;
 596             const GSUB_ChainContextSubstFormat3_2 *ccsf3_2;
 597             const GSUB_ChainContextSubstFormat3_3 *ccsf3_3;
 598             const GSUB_ChainContextSubstFormat3_4 *ccsf3_4;
 599             int newIndex = glyph_index;
 600
 601             ccsf3_1 = (const GSUB_ChainContextSubstFormat3_1 *)ccsf1;
 602
 603             TRACE("  subtype 3 (Coverage-based Chaining Context Glyph Substitution)\n");
 604
 605             for (k = 0; k < GET_BE_WORD(ccsf3_1->BacktrackGlyphCount); k++)
 606             {
 607                 offset = GET_BE_WORD(ccsf3_1->Coverage[k]);
 608                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
 609                     break;
 610             }
 611             if (k != GET_BE_WORD(ccsf3_1->BacktrackGlyphCount))
 612                 return -1;
 613             TRACE("Matched Backtrack\n");
 614
 615             ccsf3_2 = (const GSUB_ChainContextSubstFormat3_2 *)(((LPBYTE)ccsf1)+sizeof(GSUB_ChainContextSubstFormat3_1) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_1->BacktrackGlyphCount)-1)));
 616
 617             indexGlyphs = GET_BE_WORD(ccsf3_2->InputGlyphCount);
 618             for (k = 0; k < indexGlyphs; k++)
 619             {
 620                 offset = GET_BE_WORD(ccsf3_2->Coverage[k]);
 621                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
 622                     break;
 623             }
 624             if (k != indexGlyphs)
 625                 return -1;
 626             TRACE("Matched IndexGlyphs\n");
 627
 628             ccsf3_3 = (const GSUB_ChainContextSubstFormat3_3 *)(((LPBYTE)ccsf3_2)+sizeof(GSUB_ChainContextSubstFormat3_2) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_2->InputGlyphCount)-1)));
 629
 630             for (k = 0; k < GET_BE_WORD(ccsf3_3->LookaheadGlyphCount); k++)
 631             {
 632                 offset = GET_BE_WORD(ccsf3_3->Coverage[k]);
 633                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k+1))]) == -1)
 634                     break;
 635             }
 636             if (k != GET_BE_WORD(ccsf3_3->LookaheadGlyphCount))
 637                 return -1;
 638             TRACE("Matched LookAhead\n");
 639
 640             ccsf3_4 = (const GSUB_ChainContextSubstFormat3_4 *)(((LPBYTE)ccsf3_3)+sizeof(GSUB_ChainContextSubstFormat3_3) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_3->LookaheadGlyphCount)-1)));
 641
 642             for (k = 0; k < GET_BE_WORD(ccsf3_4->SubstCount); k++)
 643             {
 644                 int lookupIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].LookupListIndex);
 645                 int SequenceIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].SequenceIndex) * write_dir;
 646
 647                 TRACE("SUBST: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
 648                 newIndex = GSUB_apply_lookup(lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count);
 649                 if (newIndex == -1)
 650                 {
 651                     ERR("Chain failed to generate a glyph\n");
 652                     return -1;
 653                 }
 654             }
 655             return newIndex + 1;
 656         }
 657     }
 658     return -1;
 659 }
 660
 661 static INT GSUB_apply_lookup(const GSUB_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 662 {
 663     int offset;
 664     const GSUB_LookupTable *look;
 665
 666     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
 667     look = (const GSUB_LookupTable*)((const BYTE*)lookup + offset);
 668     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
 669     switch(GET_BE_WORD(look->LookupType))
 670     {
 671         case 1:
 672             return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 673         case 3:
 674             return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 675         case 4:
 676             return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 677         case 6:
 678             return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
 679         default:
 680             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
 681     }
 682     return GSUB_E_NOGLYPH;
 683 }
 684
 685 static INT GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 686 {
 687     int i;
 688     int out_index = GSUB_E_NOGLYPH;
 689     const GSUB_LookupList *lookup;
 690
 691     lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
 692
 693     TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
 694     for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
 695     {
 696         out_index = GSUB_apply_lookup(lookup, GET_BE_WORD(feature->LookupListIndex[i]), glyphs, glyph_index, write_dir, glyph_count);
 697         if (out_index != GSUB_E_NOGLYPH)
 698             break;
 699     }
 700     if (out_index == GSUB_E_NOGLYPH)
 701         TRACE("lookups found no glyphs\n");
 702     return out_index;
 703 }
 704
 705 static const char* get_opentype_script(HDC hdc, SCRIPT_ANALYSIS *psa)
 706 {
 707     UINT charset;
 708
 709     if (ShapingData[psa->eScript].otTag[0] != 0)
 710         return ShapingData[psa->eScript].otTag;
 711
 712     /*
 713      * fall back to the font charset
 714      */
 715     charset = GetTextCharsetInfo(hdc, NULL, 0x0);
 716     switch (charset)
 717     {
 718         case ANSI_CHARSET: return "latn";
 719         case BALTIC_CHARSET: return "latn"; /* ?? */
 720         case CHINESEBIG5_CHARSET: return "hani";
 721         case EASTEUROPE_CHARSET: return "latn"; /* ?? */
 722         case GB2312_CHARSET: return "hani";
 723         case GREEK_CHARSET: return "grek";
 724         case HANGUL_CHARSET: return "hang";
 725         case RUSSIAN_CHARSET: return "cyrl";
 726         case SHIFTJIS_CHARSET: return "kana";
 727         case TURKISH_CHARSET: return "latn"; /* ?? */
 728         case VIETNAMESE_CHARSET: return "latn";
 729         case JOHAB_CHARSET: return "latn"; /* ?? */
 730         case ARABIC_CHARSET: return "arab";
 731         case HEBREW_CHARSET: return "hebr";
 732         case THAI_CHARSET: return "thai";
 733         default: return "latn";
 734     }
 735 }
 736
 737 static LPCVOID load_GSUB_feature(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache *psc, const char* feat)
 738 {
 739     const GSUB_Feature *feature;
 740     int i;
 741
 742     for (i = 0; i <  psc->feature_count; i++)
 743         if (strncmp(psc->features[i].tag,feat,4)==0)
 744             return psc->features[i].feature;
 745
 746     feature = NULL;
 747
 748     if (psc->GSUB_Table)
 749     {
 750         const GSUB_Script *script;
 751         const GSUB_LangSys *language;
 752
 753         script = GSUB_get_script_table(psc->GSUB_Table, get_opentype_script(hdc,psa));
 754         if (script)
 755         {
 756             language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
 757             if (language)
 758                 feature = GSUB_get_feature(psc->GSUB_Table, language, feat);
 759         }
 760
 761         /* try in the default (latin) table */
 762         if (!feature)
 763         {
 764             script = GSUB_get_script_table(psc->GSUB_Table, "latn");
 765             if (script)
 766             {
 767                 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
 768                 if (language)
 769                     feature = GSUB_get_feature(psc->GSUB_Table, language, feat);
 770             }
 771         }
 772     }
 773
 774     TRACE("Feature %s located at %p\n",debugstr_an(feat,4),feature);
 775
 776     psc->feature_count++;
 777
 778     if (psc->features)
 779         psc->features = HeapReAlloc(GetProcessHeap(), 0, psc->features, psc->feature_count * sizeof(LoadedFeature));
 780     else
 781         psc->features = HeapAlloc(GetProcessHeap(), 0, psc->feature_count * sizeof(LoadedFeature));
 782
 783     lstrcpynA(psc->features[psc->feature_count - 1].tag, feat, 5);
 784     psc->features[psc->feature_count - 1].feature = feature;
 785     return feature;
 786 }
 787
 788 static INT apply_GSUB_feature_to_glyph(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, WORD *glyphs, INT index, INT write_dir, INT* glyph_count, const char* feat)
 789 {
 790     const GSUB_Feature *feature;
 791
 792     feature = load_GSUB_feature(hdc, psa, psc, feat);
 793     if (!feature)
 794         return GSUB_E_NOFEATURE;
 795
 796     TRACE("applying feature %s\n",feat);
 797     return GSUB_apply_feature(psc->GSUB_Table, feature, glyphs, index, write_dir, glyph_count);
 798 }
 799
 800 static VOID *load_gsub_table(HDC hdc)
 801 {
 802     VOID* GSUB_Table = NULL;
 803     int length = GetFontData(hdc, GSUB_TAG , 0, NULL, 0);
 804     if (length != GDI_ERROR)
 805     {
 806         GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
 807         GetFontData(hdc, GSUB_TAG , 0, GSUB_Table, length);
 808         TRACE("Loaded GSUB table of %i bytes\n",length);
 809     }
 810     return GSUB_Table;
 811 }
 812
 813 static void UpdateClusters(int nextIndex, int changeCount, int write_dir, int chars, WORD* pwLogClust )
 814 {
 815     if (changeCount == 0)
 816         return;
 817     else
 818     {
 819         int i;
 820         int target_glyph = nextIndex - 1;
 821         int target_index = -1;
 822         int replacing_glyph = -1;
 823         int changed = 0;
 824
 825         if (write_dir > 0)
 826             for (i = 0; i < chars; i++)
 827             {
 828                 if (pwLogClust[i] == target_glyph)
 829                 {
 830                     target_index = i;
 831                     break;
 832                 }
 833             }
 834         else
 835             for (i = chars - 1; i >= 0; i--)
 836             {
 837                 if (pwLogClust[i] == target_glyph)
 838                 {
 839                     target_index = i;
 840                     break;
 841                 }
 842             }
 843         if (target_index == -1)
 844         {
 845             ERR("Unable to find target glyph\n");
 846             return;
 847         }
 848
 849         if (changeCount < 0)
 850         {
 851             /* merge glyphs */
 852             for(i = target_index; i < chars && i >= 0; i+=write_dir)
 853             {
 854                 if (pwLogClust[i] == target_glyph)
 855                     continue;
 856                 if(pwLogClust[i] == replacing_glyph)
 857                     pwLogClust[i] = target_glyph;
 858                 else
 859                 {
 860                     changed--;
 861                     if (changed >= changeCount)
 862                     {
 863                         replacing_glyph = pwLogClust[i];
 864                         pwLogClust[i] = target_glyph;
 865                     }
 866                     else
 867                         break;
 868                 }
 869             }
 870         }
 871
 872         /* renumber trailing indexes*/
 873         for(i = target_index; i < chars && i >= 0; i+=write_dir)
 874         {
 875             if (pwLogClust[i] != target_glyph)
 876                 pwLogClust[i] += changeCount;
 877         }
 878     }
 879 }
 880
 881 static int apply_GSUB_feature(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, WORD *pwOutGlyphs, int write_dir, INT* pcGlyphs, INT cChars, const char* feat, WORD *pwLogClust )
 882 {
 883     int i;
 884
 885     if (psc->GSUB_Table)
 886     {
 887         const GSUB_Feature *feature;
 888
 889         feature = load_GSUB_feature(hdc, psa, psc, feat);
 890         if (!feature)
 891             return GSUB_E_NOFEATURE;
 892
 893         i = 0;
 894         TRACE("applying feature %s\n",debugstr_an(feat,4));
 895         while(i < *pcGlyphs)
 896         {
 897                 INT nextIndex;
 898                 INT prevCount = *pcGlyphs;
 899                 nextIndex = GSUB_apply_feature(psc->GSUB_Table, feature, pwOutGlyphs, i, write_dir, pcGlyphs);
 900                 if (nextIndex > GSUB_E_NOGLYPH)
 901                 {
 902                     UpdateClusters(nextIndex, *pcGlyphs - prevCount, write_dir, cChars, pwLogClust);
 903                     i = nextIndex;
 904                 }
 905                 else
 906                     i++;
 907         }
 908         return *pcGlyphs;
 909     }
 910     return GSUB_E_NOFEATURE;
 911 }
 912
 913 static WCHAR neighbour_char(int i, int delta, const WCHAR* chars, INT cchLen)
 914 {
 915     if (i + delta < 0)
 916         return 0;
 917     if ( i+ delta >= cchLen)
 918         return 0;
 919
 920     i += delta;
 921
 922     return chars[i];
 923 }
 924
 925 static CHAR neighbour_joining_type(int i, int delta, const CHAR* context_type, INT cchLen, SCRIPT_ANALYSIS *psa)
 926 {
 927     if (i + delta < 0)
 928     {
 929         if (psa->fLinkBefore)
 930             return jtR;
 931         else
 932             return jtU;
 933     }
 934     if ( i+ delta >= cchLen)
 935     {
 936         if (psa->fLinkAfter)
 937             return jtL;
 938         else
 939             return jtU;
 940     }
 941
 942     i += delta;
 943
 944     if (context_type[i] == jtT)
 945         return neighbour_joining_type(i,delta,context_type,cchLen,psa);
 946     else
 947         return context_type[i];
 948 }
 949
 950 static inline BOOL right_join_causing(CHAR joining_type)
 951 {
 952     return (joining_type == jtL || joining_type == jtD || joining_type == jtC);
 953 }
 954
 955 static inline BOOL left_join_causing(CHAR joining_type)
 956 {
 957     return (joining_type == jtR || joining_type == jtD || joining_type == jtC);
 958 }
 959
 960 static inline BOOL word_break_causing(WCHAR chr)
 961 {
 962     /* we are working within a string of characters already guareented to
 963        be within one script, Syriac, so we do not worry about any characers
 964        other than the space character outside of that range */
 965     return (chr == 0 || chr == 0x20 );
 966 }
 967
 968 /*
 969  * ContextualShape_Arabic
 970  */
 971 static void ContextualShape_Arabic(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
 972 {
 973     CHAR *context_type;
 974     INT *context_shape;
 975     INT dirR, dirL;
 976     int i;
 977
 978     if (*pcGlyphs != cChars)
 979     {
 980         ERR("Number of Glyphs and Chars need to match at the beginning\n");
 981         return;
 982     }
 983
 984     if (!psa->fLogicalOrder && psa->fRTL)
 985     {
 986         dirR = 1;
 987         dirL = -1;
 988     }
 989     else
 990     {
 991         dirR = -1;
 992         dirL = 1;
 993     }
 994
 995     if (!psc->GSUB_Table)
 996         psc->GSUB_Table = load_gsub_table(hdc);
 997
 998     context_type = HeapAlloc(GetProcessHeap(),0,cChars);
 999     context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1000
1001     for (i = 0; i < cChars; i++)
1002         context_type[i] = wine_shaping_table[wine_shaping_table[pwcChars[i] >> 8] + (pwcChars[i] & 0xff)];
1003
1004     for (i = 0; i < cChars; i++)
1005     {
1006         if (context_type[i] == jtR && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1007             context_shape[i] = Xr;
1008         else if (context_type[i] == jtL && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1009             context_shape[i] = Xl;
1010         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)) && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1011             context_shape[i] = Xm;
1012         else if (context_type[i] == jtD && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1013             context_shape[i] = Xr;
1014         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1015             context_shape[i] = Xl;
1016         else
1017             context_shape[i] = Xn;
1018     }
1019
1020     /* Contextual Shaping */
1021     i = 0;
1022     while(i < *pcGlyphs)
1023     {
1024         BOOL shaped = FALSE;
1025
1026         if (psc->GSUB_Table)
1027         {
1028             INT nextIndex;
1029             INT prevCount = *pcGlyphs;
1030             nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1031             if (nextIndex > GSUB_E_NOGLYPH)
1032             {
1033                 i = nextIndex;
1034                 UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1035             }
1036             shaped = (nextIndex > GSUB_E_NOGLYPH);
1037         }
1038
1039         if (!shaped)
1040         {
1041             WORD newGlyph = pwOutGlyphs[i];
1042             if (pwcChars[i] >= FIRST_ARABIC_CHAR && pwcChars[i] <= LAST_ARABIC_CHAR)
1043             {
1044                 /* fall back to presentation form B */
1045                 WCHAR context_char = wine_shaping_forms[pwcChars[i] - FIRST_ARABIC_CHAR][context_shape[i]];
1046                 if (context_char != pwcChars[i] && GetGlyphIndicesW(hdc, &context_char, 1, &newGlyph, 0) != GDI_ERROR && newGlyph != 0x0000)
1047                     pwOutGlyphs[i] = newGlyph;
1048             }
1049             i++;
1050         }
1051     }
1052
1053     HeapFree(GetProcessHeap(),0,context_shape);
1054     HeapFree(GetProcessHeap(),0,context_type);
1055 }
1056
1057 /*
1058  * ContextualShape_Syriac
1059  */
1060
1061 #define ALAPH 0x710
1062 #define DALATH 0x715
1063 #define RISH 0x72A
1064
1065 static void ContextualShape_Syriac(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1066 {
1067     CHAR *context_type;
1068     INT *context_shape;
1069     INT dirR, dirL;
1070     int i;
1071
1072     if (*pcGlyphs != cChars)
1073     {
1074         ERR("Number of Glyphs and Chars need to match at the beginning\n");
1075         return;
1076     }
1077
1078     if (!psa->fLogicalOrder && psa->fRTL)
1079     {
1080         dirR = 1;
1081         dirL = -1;
1082     }
1083     else
1084     {
1085         dirR = -1;
1086         dirL = 1;
1087     }
1088
1089     if (!psc->GSUB_Table)
1090         psc->GSUB_Table = load_gsub_table(hdc);
1091
1092     if (!psc->GSUB_Table)
1093         return;
1094
1095     context_type = HeapAlloc(GetProcessHeap(),0,cChars);
1096     context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1097
1098     for (i = 0; i < cChars; i++)
1099         context_type[i] = wine_shaping_table[wine_shaping_table[pwcChars[i] >> 8] + (pwcChars[i] & 0xff)];
1100
1101     for (i = 0; i < cChars; i++)
1102     {
1103         if (pwcChars[i] == ALAPH)
1104         {
1105             WCHAR rchar = neighbour_char(i,dirR,pwcChars,cChars);
1106
1107             if (left_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)) && word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1108             context_shape[i] = Afj;
1109             else if ( rchar != DALATH && rchar != RISH &&
1110 !left_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)) &&
1111 word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1112             context_shape[i] = Afn;
1113             else if ( (rchar == DALATH || rchar == RISH) && word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1114             context_shape[i] = Afx;
1115         }
1116         else if (context_type[i] == jtR &&
1117 right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1118             context_shape[i] = Xr;
1119         else if (context_type[i] == jtL && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1120             context_shape[i] = Xl;
1121         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)) && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1122             context_shape[i] = Xm;
1123         else if (context_type[i] == jtD && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1124             context_shape[i] = Xr;
1125         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1126             context_shape[i] = Xl;
1127         else
1128             context_shape[i] = Xn;
1129     }
1130
1131     /* Contextual Shaping */
1132     i = 0;
1133     while(i < *pcGlyphs)
1134     {
1135         INT nextIndex;
1136         INT prevCount = *pcGlyphs;
1137         nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1138         if (nextIndex > GSUB_E_NOGLYPH)
1139         {
1140             UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1141             i = nextIndex;
1142         }
1143     }
1144
1145     HeapFree(GetProcessHeap(),0,context_shape);
1146     HeapFree(GetProcessHeap(),0,context_type);
1147 }
1148
1149 void SHAPE_ContextualShaping(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1150 {
1151     if (ShapingData[psa->eScript].contextProc)
1152         ShapingData[psa->eScript].contextProc(hdc, psc, psa, pwcChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
1153 }
1154
1155 void SHAPE_ApplyOpenTypeFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, INT cChars, const TEXTRANGE_PROPERTIES *rpRangeProperties, WORD *pwLogClust)
1156 {
1157     int i;
1158     INT dirL;
1159
1160     if (!rpRangeProperties)
1161         return;
1162
1163     if (!psc->GSUB_Table)
1164         psc->GSUB_Table = load_gsub_table(hdc);
1165
1166     if (!psc->GSUB_Table)
1167         return;
1168
1169     if (!psa->fLogicalOrder && psa->fRTL)
1170         dirL = -1;
1171     else
1172         dirL = 1;
1173
1174     for (i = 0; i < rpRangeProperties->cotfRecords; i++)
1175     {
1176         if (rpRangeProperties->potfRecords[i].lParameter > 0)
1177         apply_GSUB_feature(hdc, psa, psc, pwOutGlyphs, dirL, pcGlyphs, cChars, (const char*)&rpRangeProperties->potfRecords[i].tagFeature, pwLogClust);
1178     }
1179 }
1180
1181 void SHAPE_ApplyDefaultOpentypeFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, INT cChars, WORD *pwLogClust)
1182 {
1183 const TEXTRANGE_PROPERTIES *rpRangeProperties;
1184 rpRangeProperties = &ShapingData[psa->eScript].defaultTextRange;
1185
1186     SHAPE_ApplyOpenTypeFeatures(hdc, psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, rpRangeProperties, pwLogClust);
1187 }