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

   1 /*
   2  * Opentype font interfaces for the Uniscribe Script Processor (usp10.dll)
   3  *
   4  * Copyright 2012 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 #include <stdlib.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winnls.h"
  29 #include "usp10.h"
  30 #include "winternl.h"
  31
  32 #include "usp10_internal.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  37
  38 #ifdef WORDS_BIGENDIAN
  39 #define GET_BE_WORD(x) (x)
  40 #define GET_BE_DWORD(x) (x)
  41 #else
  42 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
  43 #define GET_BE_DWORD(x) RtlUlongByteSwap(x)
  44 #endif
  45
  46 #define round(x) (((x) < 0) ? (int)((x) - 0.5) : (int)((x) + 0.5))
  47
  48 /* These are all structures needed for the cmap format 12 table */
  49 #define CMAP_TAG MS_MAKE_TAG('c', 'm', 'a', 'p')
  50
  51 typedef struct {
  52     WORD platformID;
  53     WORD encodingID;
  54     DWORD offset;
  55 } CMAP_EncodingRecord;
  56
  57 typedef struct {
  58     WORD version;
  59     WORD numTables;
  60     CMAP_EncodingRecord tables[1];
  61 } CMAP_Header;
  62
  63 typedef struct {
  64     DWORD startCharCode;
  65     DWORD endCharCode;
  66     DWORD startGlyphID;
  67 } CMAP_SegmentedCoverage_group;
  68
  69 typedef struct {
  70     WORD format;
  71     WORD reserved;
  72     DWORD length;
  73     DWORD language;
  74     DWORD nGroups;
  75     CMAP_SegmentedCoverage_group groups[1];
  76 } CMAP_SegmentedCoverage;
  77
  78 /* These are all structures needed for the GDEF table */
  79 #define GDEF_TAG MS_MAKE_TAG('G', 'D', 'E', 'F')
  80
  81 enum {BaseGlyph=1, LigatureGlyph, MarkGlyph, ComponentGlyph};
  82
  83 typedef struct {
  84     DWORD Version;
  85     WORD GlyphClassDef;
  86     WORD AttachList;
  87     WORD LigCaretList;
  88     WORD MarkAttachClassDef;
  89 } GDEF_Header;
  90
  91 typedef struct {
  92     WORD ClassFormat;
  93     WORD StartGlyph;
  94     WORD GlyphCount;
  95     WORD ClassValueArray[1];
  96 } GDEF_ClassDefFormat1;
  97
  98 typedef struct {
  99     WORD Start;
 100     WORD End;
 101     WORD Class;
 102 } GDEF_ClassRangeRecord;
 103
 104 typedef struct {
 105     WORD ClassFormat;
 106     WORD ClassRangeCount;
 107     GDEF_ClassRangeRecord ClassRangeRecord[1];
 108 } GDEF_ClassDefFormat2;
 109
 110 /* These are all structures needed for the GSUB table */
 111
 112 typedef struct {
 113     DWORD version;
 114     WORD ScriptList;
 115     WORD FeatureList;
 116     WORD LookupList;
 117 } GSUB_Header;
 118
 119 typedef struct {
 120     CHAR ScriptTag[4];
 121     WORD Script;
 122 } OT_ScriptRecord;
 123
 124 typedef struct {
 125     WORD ScriptCount;
 126     OT_ScriptRecord ScriptRecord[1];
 127 } OT_ScriptList;
 128
 129 typedef struct {
 130     CHAR LangSysTag[4];
 131     WORD LangSys;
 132 } OT_LangSysRecord;
 133
 134 typedef struct {
 135     WORD DefaultLangSys;
 136     WORD LangSysCount;
 137     OT_LangSysRecord LangSysRecord[1];
 138 } OT_Script;
 139
 140 typedef struct {
 141     WORD LookupOrder; /* Reserved */
 142     WORD ReqFeatureIndex;
 143     WORD FeatureCount;
 144     WORD FeatureIndex[1];
 145 } OT_LangSys;
 146
 147 typedef struct {
 148     CHAR FeatureTag[4];
 149     WORD Feature;
 150 } OT_FeatureRecord;
 151
 152 typedef struct {
 153     WORD FeatureCount;
 154     OT_FeatureRecord FeatureRecord[1];
 155 } OT_FeatureList;
 156
 157 typedef struct {
 158     WORD FeatureParams; /* Reserved */
 159     WORD LookupCount;
 160     WORD LookupListIndex[1];
 161 } OT_Feature;
 162
 163 typedef struct {
 164     WORD LookupCount;
 165     WORD Lookup[1];
 166 } OT_LookupList;
 167
 168 typedef struct {
 169     WORD LookupType;
 170     WORD LookupFlag;
 171     WORD SubTableCount;
 172     WORD SubTable[1];
 173 } OT_LookupTable;
 174
 175 typedef struct {
 176     WORD CoverageFormat;
 177     WORD GlyphCount;
 178     WORD GlyphArray[1];
 179 } OT_CoverageFormat1;
 180
 181 typedef struct {
 182     WORD Start;
 183     WORD End;
 184     WORD StartCoverageIndex;
 185 } OT_RangeRecord;
 186
 187 typedef struct {
 188     WORD CoverageFormat;
 189     WORD RangeCount;
 190     OT_RangeRecord RangeRecord[1];
 191 } OT_CoverageFormat2;
 192
 193 typedef struct {
 194     WORD SubstFormat; /* = 1 */
 195     WORD Coverage;
 196     WORD DeltaGlyphID;
 197 } GSUB_SingleSubstFormat1;
 198
 199 typedef struct {
 200     WORD SubstFormat; /* = 2 */
 201     WORD Coverage;
 202     WORD GlyphCount;
 203     WORD Substitute[1];
 204 }GSUB_SingleSubstFormat2;
 205
 206 typedef struct {
 207     WORD SubstFormat; /* = 1 */
 208     WORD Coverage;
 209     WORD SequenceCount;
 210     WORD Sequence[1];
 211 }GSUB_MultipleSubstFormat1;
 212
 213 typedef struct {
 214     WORD GlyphCount;
 215     WORD Substitute[1];
 216 }GSUB_Sequence;
 217
 218 typedef struct {
 219     WORD SubstFormat; /* = 1 */
 220     WORD Coverage;
 221     WORD LigSetCount;
 222     WORD LigatureSet[1];
 223 }GSUB_LigatureSubstFormat1;
 224
 225 typedef struct {
 226     WORD LigatureCount;
 227     WORD Ligature[1];
 228 }GSUB_LigatureSet;
 229
 230 typedef struct{
 231     WORD LigGlyph;
 232     WORD CompCount;
 233     WORD Component[1];
 234 }GSUB_Ligature;
 235
 236 typedef struct{
 237     WORD SequenceIndex;
 238     WORD LookupListIndex;
 239
 240 }GSUB_SubstLookupRecord;
 241
 242 typedef struct{
 243     WORD SubstFormat; /* = 1 */
 244     WORD Coverage;
 245     WORD ChainSubRuleSetCount;
 246     WORD ChainSubRuleSet[1];
 247 }GSUB_ChainContextSubstFormat1;
 248
 249 typedef struct {
 250     WORD SubstFormat; /* = 3 */
 251     WORD BacktrackGlyphCount;
 252     WORD Coverage[1];
 253 }GSUB_ChainContextSubstFormat3_1;
 254
 255 typedef struct{
 256     WORD InputGlyphCount;
 257     WORD Coverage[1];
 258 }GSUB_ChainContextSubstFormat3_2;
 259
 260 typedef struct{
 261     WORD LookaheadGlyphCount;
 262     WORD Coverage[1];
 263 }GSUB_ChainContextSubstFormat3_3;
 264
 265 typedef struct{
 266     WORD SubstCount;
 267     GSUB_SubstLookupRecord SubstLookupRecord[1];
 268 }GSUB_ChainContextSubstFormat3_4;
 269
 270 typedef struct {
 271     WORD SubstFormat; /* = 1 */
 272     WORD Coverage;
 273     WORD AlternateSetCount;
 274     WORD AlternateSet[1];
 275 } GSUB_AlternateSubstFormat1;
 276
 277 typedef struct{
 278     WORD GlyphCount;
 279     WORD Alternate[1];
 280 } GSUB_AlternateSet;
 281
 282 /* These are all structures needed for the GPOS table */
 283
 284 typedef struct {
 285     DWORD version;
 286     WORD ScriptList;
 287     WORD FeatureList;
 288     WORD LookupList;
 289 } GPOS_Header;
 290
 291 typedef struct {
 292     WORD StartSize;
 293     WORD EndSize;
 294     WORD DeltaFormat;
 295     WORD DeltaValue[1];
 296 } OT_DeviceTable;
 297
 298 typedef struct {
 299     WORD AnchorFormat;
 300     WORD XCoordinate;
 301     WORD YCoordinate;
 302 } GPOS_AnchorFormat1;
 303
 304 typedef struct {
 305     WORD AnchorFormat;
 306     WORD XCoordinate;
 307     WORD YCoordinate;
 308     WORD AnchorPoint;
 309 } GPOS_AnchorFormat2;
 310
 311 typedef struct {
 312     WORD AnchorFormat;
 313     WORD XCoordinate;
 314     WORD YCoordinate;
 315     WORD XDeviceTable;
 316     WORD YDeviceTable;
 317 } GPOS_AnchorFormat3;
 318
 319 typedef struct {
 320     WORD XPlacement;
 321     WORD YPlacement;
 322     WORD XAdvance;
 323     WORD YAdvance;
 324     WORD XPlaDevice;
 325     WORD YPlaDevice;
 326     WORD XAdvDevice;
 327     WORD YAdvDevice;
 328 } GPOS_ValueRecord;
 329
 330 typedef struct {
 331     WORD PosFormat;
 332     WORD Coverage;
 333     WORD ValueFormat;
 334     WORD Value[1];
 335 } GPOS_SinglePosFormat1;
 336
 337 typedef struct {
 338     WORD PosFormat;
 339     WORD Coverage;
 340     WORD ValueFormat;
 341     WORD ValueCount;
 342     WORD Value[1];
 343 } GPOS_SinglePosFormat2;
 344
 345 typedef struct {
 346     WORD PosFormat;
 347     WORD Coverage;
 348     WORD ValueFormat1;
 349     WORD ValueFormat2;
 350     WORD PairSetCount;
 351     WORD PairSetOffset[1];
 352 } GPOS_PairPosFormat1;
 353
 354 typedef struct {
 355     WORD SecondGlyph;
 356     WORD Value1[1];
 357     WORD Value2[1];
 358 } GPOS_PairValueRecord;
 359
 360 typedef struct {
 361     WORD PairValueCount;
 362     GPOS_PairValueRecord PairValueRecord[1];
 363 } GPOS_PairSet;
 364
 365 typedef struct {
 366     WORD PosFormat;
 367     WORD MarkCoverage;
 368     WORD BaseCoverage;
 369     WORD ClassCount;
 370     WORD MarkArray;
 371     WORD BaseArray;
 372 } GPOS_MarkBasePosFormat1;
 373
 374 typedef struct {
 375     WORD BaseAnchor[1];
 376 } GPOS_BaseRecord;
 377
 378 typedef struct {
 379     WORD BaseCount;
 380     GPOS_BaseRecord BaseRecord[1];
 381 } GPOS_BaseArray;
 382
 383 typedef struct {
 384     WORD Class;
 385     WORD MarkAnchor;
 386 } GPOS_MarkRecord;
 387
 388 typedef struct {
 389     WORD MarkCount;
 390     GPOS_MarkRecord MarkRecord[1];
 391 } GPOS_MarkArray;
 392
 393 typedef struct {
 394     WORD PosFormat;
 395     WORD Mark1Coverage;
 396     WORD Mark2Coverage;
 397     WORD ClassCount;
 398     WORD Mark1Array;
 399     WORD Mark2Array;
 400 } GPOS_MarkMarkPosFormat1;
 401
 402 typedef struct {
 403     WORD Mark2Anchor[1];
 404 } GPOS_Mark2Record;
 405
 406 typedef struct {
 407     WORD Mark2Count;
 408     GPOS_Mark2Record Mark2Record[1];
 409 } GPOS_Mark2Array;
 410
 411 typedef struct {
 412     WORD SequenceIndex;
 413     WORD LookupListIndex;
 414 } GPOS_PosLookupRecord;
 415
 416 typedef struct {
 417     WORD PosFormat;
 418     WORD BacktrackGlyphCount;
 419     WORD Coverage[1];
 420 } GPOS_ChainContextPosFormat3_1;
 421
 422 typedef struct {
 423     WORD InputGlyphCount;
 424     WORD Coverage[1];
 425 } GPOS_ChainContextPosFormat3_2;
 426
 427 typedef struct {
 428     WORD LookaheadGlyphCount;
 429     WORD Coverage[1];
 430 } GPOS_ChainContextPosFormat3_3;
 431
 432 typedef struct {
 433     WORD PosCount;
 434     GPOS_PosLookupRecord PosLookupRecord[1];
 435 } GPOS_ChainContextPosFormat3_4;
 436
 437 /**********
 438  * CMAP
 439  **********/
 440
 441 static VOID *load_CMAP_format12_table(HDC hdc, ScriptCache *psc)
 442 {
 443     CMAP_Header *CMAP_Table = NULL;
 444     int length;
 445     int i;
 446
 447     if (!psc->CMAP_Table)
 448     {
 449         length = GetFontData(hdc, CMAP_TAG , 0, NULL, 0);
 450         if (length != GDI_ERROR)
 451         {
 452             psc->CMAP_Table = HeapAlloc(GetProcessHeap(),0,length);
 453             GetFontData(hdc, CMAP_TAG , 0, psc->CMAP_Table, length);
 454             TRACE("Loaded cmap table of %i bytes\n",length);
 455         }
 456         else
 457             return NULL;
 458     }
 459
 460     CMAP_Table = psc->CMAP_Table;
 461
 462     for (i = 0; i < GET_BE_WORD(CMAP_Table->numTables); i++)
 463     {
 464         if ( (GET_BE_WORD(CMAP_Table->tables[i].platformID) == 3) &&
 465              (GET_BE_WORD(CMAP_Table->tables[i].encodingID) == 10) )
 466         {
 467             CMAP_SegmentedCoverage *format = (CMAP_SegmentedCoverage*)(((BYTE*)CMAP_Table) + GET_BE_DWORD(CMAP_Table->tables[i].offset));
 468             if (GET_BE_WORD(format->format) == 12)
 469                 return format;
 470         }
 471     }
 472     return NULL;
 473 }
 474
 475 static int compare_group(const void *a, const void* b)
 476 {
 477     const DWORD *chr = a;
 478     const CMAP_SegmentedCoverage_group *group = b;
 479
 480     if (*chr < GET_BE_DWORD(group->startCharCode))
 481         return -1;
 482     if (*chr > GET_BE_DWORD(group->endCharCode))
 483         return 1;
 484     return 0;
 485 }
 486
 487 DWORD OpenType_CMAP_GetGlyphIndex(HDC hdc, ScriptCache *psc, DWORD utf32c, LPWORD pgi, DWORD flags)
 488 {
 489     /* BMP: use gdi32 for ease */
 490     if (utf32c < 0x10000)
 491     {
 492         WCHAR ch = utf32c;
 493         return GetGlyphIndicesW(hdc,&ch, 1, pgi, flags);
 494     }
 495
 496     if (!psc->CMAP_format12_Table)
 497         psc->CMAP_format12_Table = load_CMAP_format12_table(hdc, psc);
 498
 499     if (flags & GGI_MARK_NONEXISTING_GLYPHS)
 500         *pgi = 0xffff;
 501     else
 502         *pgi = 0;
 503
 504     if (psc->CMAP_format12_Table)
 505     {
 506         CMAP_SegmentedCoverage *format = NULL;
 507         CMAP_SegmentedCoverage_group *group = NULL;
 508
 509         format = (CMAP_SegmentedCoverage *)psc->CMAP_format12_Table;
 510
 511         group = bsearch(&utf32c, format->groups, GET_BE_DWORD(format->nGroups),
 512                         sizeof(CMAP_SegmentedCoverage_group), compare_group);
 513
 514         if (group)
 515         {
 516             DWORD offset = utf32c - GET_BE_DWORD(group->startCharCode);
 517             *pgi = GET_BE_DWORD(group->startGlyphID) + offset;
 518             return 0;
 519         }
 520     }
 521     return 0;
 522 }
 523
 524 /**********
 525  * GDEF
 526  **********/
 527
 528 static WORD GDEF_get_glyph_class(const GDEF_Header *header, WORD glyph)
 529 {
 530     int offset;
 531     WORD class = 0;
 532     const GDEF_ClassDefFormat1 *cf1;
 533
 534     if (!header)
 535         return 0;
 536
 537     offset = GET_BE_WORD(header->GlyphClassDef);
 538     if (!offset)
 539         return 0;
 540
 541     cf1 = (GDEF_ClassDefFormat1*)(((BYTE*)header)+offset);
 542     if (GET_BE_WORD(cf1->ClassFormat) == 1)
 543     {
 544         if (glyph >= GET_BE_WORD(cf1->StartGlyph))
 545         {
 546             int index = glyph - GET_BE_WORD(cf1->StartGlyph);
 547             if (index < GET_BE_WORD(cf1->GlyphCount))
 548                 class = GET_BE_WORD(cf1->ClassValueArray[index]);
 549         }
 550     }
 551     else if (GET_BE_WORD(cf1->ClassFormat) == 2)
 552     {
 553         const GDEF_ClassDefFormat2 *cf2 = (GDEF_ClassDefFormat2*)cf1;
 554         int i, top;
 555         top = GET_BE_WORD(cf2->ClassRangeCount);
 556         for (i = 0; i < top; i++)
 557         {
 558             if (glyph >= GET_BE_WORD(cf2->ClassRangeRecord[i].Start) &&
 559                 glyph <= GET_BE_WORD(cf2->ClassRangeRecord[i].End))
 560             {
 561                 class = GET_BE_WORD(cf2->ClassRangeRecord[i].Class);
 562                 break;
 563             }
 564         }
 565     }
 566     else
 567         ERR("Unknown Class Format %i\n",GET_BE_WORD(cf1->ClassFormat));
 568
 569     return class;
 570 }
 571
 572 static VOID *load_gdef_table(HDC hdc)
 573 {
 574     VOID* GDEF_Table = NULL;
 575     int length = GetFontData(hdc, GDEF_TAG , 0, NULL, 0);
 576     if (length != GDI_ERROR)
 577     {
 578         GDEF_Table = HeapAlloc(GetProcessHeap(),0,length);
 579         GetFontData(hdc, GDEF_TAG , 0, GDEF_Table, length);
 580         TRACE("Loaded GDEF table of %i bytes\n",length);
 581     }
 582     return GDEF_Table;
 583 }
 584
 585 void OpenType_GDEF_UpdateGlyphProps(HDC hdc, ScriptCache *psc, const WORD *pwGlyphs, const WORD cGlyphs, WORD* pwLogClust, const WORD cChars, SCRIPT_GLYPHPROP *pGlyphProp)
 586 {
 587     int i;
 588
 589     if (!psc->GDEF_Table)
 590         psc->GDEF_Table = load_gdef_table(hdc);
 591
 592     for (i = 0; i < cGlyphs; i++)
 593     {
 594         WORD class;
 595         int char_count = 0;
 596         int k;
 597
 598         k = USP10_FindGlyphInLogClust(pwLogClust, cChars, i);
 599         if (k >= 0)
 600         {
 601             for (; k < cChars && pwLogClust[k] == i; k++)
 602                 char_count++;
 603         }
 604
 605         class = GDEF_get_glyph_class(psc->GDEF_Table, pwGlyphs[i]);
 606
 607         switch (class)
 608         {
 609             case 0:
 610             case BaseGlyph:
 611                 pGlyphProp[i].sva.fClusterStart = 1;
 612                 pGlyphProp[i].sva.fDiacritic = 0;
 613                 pGlyphProp[i].sva.fZeroWidth = 0;
 614                 break;
 615             case LigatureGlyph:
 616                 pGlyphProp[i].sva.fClusterStart = 1;
 617                 pGlyphProp[i].sva.fDiacritic = 0;
 618                 pGlyphProp[i].sva.fZeroWidth = 0;
 619                 break;
 620             case MarkGlyph:
 621                 pGlyphProp[i].sva.fClusterStart = 0;
 622                 pGlyphProp[i].sva.fDiacritic = 1;
 623                 pGlyphProp[i].sva.fZeroWidth = 1;
 624                 break;
 625             case ComponentGlyph:
 626                 pGlyphProp[i].sva.fClusterStart = 0;
 627                 pGlyphProp[i].sva.fDiacritic = 0;
 628                 pGlyphProp[i].sva.fZeroWidth = 0;
 629                 break;
 630             default:
 631                 ERR("Unknown glyph class %i\n",class);
 632                 pGlyphProp[i].sva.fClusterStart = 1;
 633                 pGlyphProp[i].sva.fDiacritic = 0;
 634                 pGlyphProp[i].sva.fZeroWidth = 0;
 635         }
 636
 637         if (char_count == 0)
 638             pGlyphProp[i].sva.fClusterStart = 0;
 639     }
 640 }
 641
 642 /**********
 643  * GSUB
 644  **********/
 645 static INT GSUB_apply_lookup(const OT_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count);
 646
 647 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
 648 {
 649     const OT_CoverageFormat1* cf1;
 650
 651     cf1 = table;
 652
 653     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
 654     {
 655         int count = GET_BE_WORD(cf1->GlyphCount);
 656         int i;
 657         TRACE("Coverage Format 1, %i glyphs\n",count);
 658         for (i = 0; i < count; i++)
 659             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
 660                 return i;
 661         return -1;
 662     }
 663     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
 664     {
 665         const OT_CoverageFormat2* cf2;
 666         int i;
 667         int count;
 668         cf2 = (const OT_CoverageFormat2*)cf1;
 669
 670         count = GET_BE_WORD(cf2->RangeCount);
 671         TRACE("Coverage Format 2, %i ranges\n",count);
 672         for (i = 0; i < count; i++)
 673         {
 674             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
 675                 return -1;
 676             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
 677                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
 678             {
 679                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
 680                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
 681             }
 682         }
 683         return -1;
 684     }
 685     else
 686         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
 687
 688     return -1;
 689 }
 690
 691 static INT GSUB_apply_SingleSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 692 {
 693     int j;
 694     TRACE("Single Substitution Subtable\n");
 695
 696     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 697     {
 698         int offset;
 699         const GSUB_SingleSubstFormat1 *ssf1;
 700         offset = GET_BE_WORD(look->SubTable[j]);
 701         ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
 702         if (GET_BE_WORD(ssf1->SubstFormat) == 1)
 703         {
 704             int offset = GET_BE_WORD(ssf1->Coverage);
 705             TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
 706             if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyphs[glyph_index]) != -1)
 707             {
 708                 TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 709                 glyphs[glyph_index] = glyphs[glyph_index] + GET_BE_WORD(ssf1->DeltaGlyphID);
 710                 TRACE(" 0x%x\n",glyphs[glyph_index]);
 711                 return glyph_index + write_dir;
 712             }
 713         }
 714         else
 715         {
 716             const GSUB_SingleSubstFormat2 *ssf2;
 717             INT index;
 718             INT offset;
 719
 720             ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
 721             offset = GET_BE_WORD(ssf1->Coverage);
 722             TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
 723             index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyphs[glyph_index]);
 724             TRACE("  Coverage index %i\n",index);
 725             if (index != -1)
 726             {
 727                 if (glyphs[glyph_index] == GET_BE_WORD(ssf2->Substitute[index]))
 728                     return GSUB_E_NOGLYPH;
 729
 730                 TRACE("    Glyph is 0x%x ->",glyphs[glyph_index]);
 731                 glyphs[glyph_index] = GET_BE_WORD(ssf2->Substitute[index]);
 732                 TRACE("0x%x\n",glyphs[glyph_index]);
 733                 return glyph_index + write_dir;
 734             }
 735         }
 736     }
 737     return GSUB_E_NOGLYPH;
 738 }
 739
 740 static INT GSUB_apply_MultipleSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 741 {
 742     int j;
 743     TRACE("Multiple Substitution Subtable\n");
 744
 745     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 746     {
 747         int offset, index;
 748         const GSUB_MultipleSubstFormat1 *msf1;
 749         offset = GET_BE_WORD(look->SubTable[j]);
 750         msf1 = (const GSUB_MultipleSubstFormat1*)((const BYTE*)look+offset);
 751
 752         offset = GET_BE_WORD(msf1->Coverage);
 753         index = GSUB_is_glyph_covered((const BYTE*)msf1+offset, glyphs[glyph_index]);
 754         if (index != -1)
 755         {
 756             const GSUB_Sequence *seq;
 757             int sub_count;
 758             int j;
 759             offset = GET_BE_WORD(msf1->Sequence[index]);
 760             seq = (const GSUB_Sequence*)((const BYTE*)msf1+offset);
 761             sub_count = GET_BE_WORD(seq->GlyphCount);
 762             TRACE("  Glyph 0x%x (+%i)->",glyphs[glyph_index],(sub_count-1));
 763
 764             for (j = (*glyph_count)+(sub_count-1); j > glyph_index; j--)
 765                     glyphs[j] =glyphs[j-(sub_count-1)];
 766
 767             for (j = 0; j < sub_count; j++)
 768                     if (write_dir < 0)
 769                         glyphs[glyph_index + (sub_count-1) - j] = GET_BE_WORD(seq->Substitute[j]);
 770                     else
 771                         glyphs[glyph_index + j] = GET_BE_WORD(seq->Substitute[j]);
 772
 773             *glyph_count = *glyph_count + (sub_count - 1);
 774
 775             if (TRACE_ON(uniscribe))
 776             {
 777                 for (j = 0; j < sub_count; j++)
 778                     TRACE(" 0x%x",glyphs[glyph_index+j]);
 779                 TRACE("\n");
 780             }
 781
 782             return glyph_index + (sub_count * write_dir);
 783         }
 784     }
 785     return GSUB_E_NOGLYPH;
 786 }
 787
 788 static INT GSUB_apply_AlternateSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 789 {
 790     int j;
 791     TRACE("Alternate Substitution Subtable\n");
 792
 793     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 794     {
 795         int offset;
 796         const GSUB_AlternateSubstFormat1 *asf1;
 797         INT index;
 798
 799         offset = GET_BE_WORD(look->SubTable[j]);
 800         asf1 = (const GSUB_AlternateSubstFormat1*)((const BYTE*)look+offset);
 801         offset = GET_BE_WORD(asf1->Coverage);
 802
 803         index = GSUB_is_glyph_covered((const BYTE*)asf1+offset, glyphs[glyph_index]);
 804         if (index != -1)
 805         {
 806             const GSUB_AlternateSet *as;
 807             offset =  GET_BE_WORD(asf1->AlternateSet[index]);
 808             as = (const GSUB_AlternateSet*)((const BYTE*)asf1+offset);
 809             FIXME("%i alternates, picking index 0\n",GET_BE_WORD(as->GlyphCount));
 810             if (glyphs[glyph_index] == GET_BE_WORD(as->Alternate[0]))
 811                 return GSUB_E_NOGLYPH;
 812
 813             TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 814             glyphs[glyph_index] = GET_BE_WORD(as->Alternate[0]);
 815             TRACE(" 0x%x\n",glyphs[glyph_index]);
 816             return glyph_index + write_dir;
 817         }
 818     }
 819     return GSUB_E_NOGLYPH;
 820 }
 821
 822 static INT GSUB_apply_LigatureSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 823 {
 824     int j;
 825
 826     TRACE("Ligature Substitution Subtable\n");
 827     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 828     {
 829         const GSUB_LigatureSubstFormat1 *lsf1;
 830         int offset,index;
 831
 832         offset = GET_BE_WORD(look->SubTable[j]);
 833         lsf1 = (const GSUB_LigatureSubstFormat1*)((const BYTE*)look+offset);
 834         offset = GET_BE_WORD(lsf1->Coverage);
 835         index = GSUB_is_glyph_covered((const BYTE*)lsf1+offset, glyphs[glyph_index]);
 836         TRACE("  Coverage index %i\n",index);
 837         if (index != -1)
 838         {
 839             const GSUB_LigatureSet *ls;
 840             int k, count;
 841
 842             offset = GET_BE_WORD(lsf1->LigatureSet[index]);
 843             ls = (const GSUB_LigatureSet*)((const BYTE*)lsf1+offset);
 844             count = GET_BE_WORD(ls->LigatureCount);
 845             TRACE("  LigatureSet has %i members\n",count);
 846             for (k = 0; k < count; k++)
 847             {
 848                 const GSUB_Ligature *lig;
 849                 int CompCount,l,CompIndex;
 850
 851                 offset = GET_BE_WORD(ls->Ligature[k]);
 852                 lig = (const GSUB_Ligature*)((const BYTE*)ls+offset);
 853                 CompCount = GET_BE_WORD(lig->CompCount) - 1;
 854                 CompIndex = glyph_index+write_dir;
 855                 for (l = 0; l < CompCount && CompIndex >= 0 && CompIndex < *glyph_count; l++)
 856                 {
 857                     int CompGlyph;
 858                     CompGlyph = GET_BE_WORD(lig->Component[l]);
 859                     if (CompGlyph != glyphs[CompIndex])
 860                         break;
 861                     CompIndex += write_dir;
 862                 }
 863                 if (l == CompCount)
 864                 {
 865                     int replaceIdx = glyph_index;
 866                     if (write_dir < 0)
 867                         replaceIdx = glyph_index - CompCount;
 868
 869                     TRACE("    Glyph is 0x%x (+%i) ->",glyphs[glyph_index],CompCount);
 870                     glyphs[replaceIdx] = GET_BE_WORD(lig->LigGlyph);
 871                     TRACE("0x%x\n",glyphs[replaceIdx]);
 872                     if (CompCount > 0)
 873                     {
 874                         int j;
 875                         for (j = replaceIdx + 1; j < *glyph_count; j++)
 876                             glyphs[j] =glyphs[j+CompCount];
 877                         *glyph_count = *glyph_count - CompCount;
 878                     }
 879                     return replaceIdx + write_dir;
 880                 }
 881             }
 882         }
 883     }
 884     return GSUB_E_NOGLYPH;
 885 }
 886
 887 static INT GSUB_apply_ChainContextSubst(const OT_LookupList* lookup, const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 888 {
 889     int j;
 890     BOOL done = FALSE;
 891
 892     TRACE("Chaining Contextual Substitution Subtable\n");
 893     for (j = 0; j < GET_BE_WORD(look->SubTableCount) && !done; j++)
 894     {
 895         const GSUB_ChainContextSubstFormat1 *ccsf1;
 896         int offset;
 897         int dirLookahead = write_dir;
 898         int dirBacktrack = -1 * write_dir;
 899
 900         offset = GET_BE_WORD(look->SubTable[j]);
 901         ccsf1 = (const GSUB_ChainContextSubstFormat1*)((const BYTE*)look+offset);
 902         if (GET_BE_WORD(ccsf1->SubstFormat) == 1)
 903         {
 904             FIXME("  TODO: subtype 1 (Simple context glyph substitution)\n");
 905             continue;
 906         }
 907         else if (GET_BE_WORD(ccsf1->SubstFormat) == 2)
 908         {
 909             FIXME("  TODO: subtype 2 (Class-based Chaining Context Glyph Substitution)\n");
 910             continue;
 911         }
 912         else if (GET_BE_WORD(ccsf1->SubstFormat) == 3)
 913         {
 914             int k;
 915             int indexGlyphs;
 916             const GSUB_ChainContextSubstFormat3_1 *ccsf3_1;
 917             const GSUB_ChainContextSubstFormat3_2 *ccsf3_2;
 918             const GSUB_ChainContextSubstFormat3_3 *ccsf3_3;
 919             const GSUB_ChainContextSubstFormat3_4 *ccsf3_4;
 920             int newIndex = glyph_index;
 921
 922             ccsf3_1 = (const GSUB_ChainContextSubstFormat3_1 *)ccsf1;
 923
 924             TRACE("  subtype 3 (Coverage-based Chaining Context Glyph Substitution)\n");
 925
 926             for (k = 0; k < GET_BE_WORD(ccsf3_1->BacktrackGlyphCount); k++)
 927             {
 928                 offset = GET_BE_WORD(ccsf3_1->Coverage[k]);
 929                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
 930                     break;
 931             }
 932             if (k != GET_BE_WORD(ccsf3_1->BacktrackGlyphCount))
 933                 continue;
 934             TRACE("Matched Backtrack\n");
 935
 936             ccsf3_2 = (const GSUB_ChainContextSubstFormat3_2 *)((BYTE *)ccsf1 +
 937                     FIELD_OFFSET(GSUB_ChainContextSubstFormat3_1, Coverage[GET_BE_WORD(ccsf3_1->BacktrackGlyphCount)]));
 938
 939             indexGlyphs = GET_BE_WORD(ccsf3_2->InputGlyphCount);
 940             for (k = 0; k < indexGlyphs; k++)
 941             {
 942                 offset = GET_BE_WORD(ccsf3_2->Coverage[k]);
 943                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
 944                     break;
 945             }
 946             if (k != indexGlyphs)
 947                 continue;
 948             TRACE("Matched IndexGlyphs\n");
 949
 950             ccsf3_3 = (const GSUB_ChainContextSubstFormat3_3 *)((BYTE *)ccsf3_2 +
 951                     FIELD_OFFSET(GSUB_ChainContextSubstFormat3_2, Coverage[GET_BE_WORD(ccsf3_2->InputGlyphCount)]));
 952
 953             for (k = 0; k < GET_BE_WORD(ccsf3_3->LookaheadGlyphCount); k++)
 954             {
 955                 offset = GET_BE_WORD(ccsf3_3->Coverage[k]);
 956                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
 957                     break;
 958             }
 959             if (k != GET_BE_WORD(ccsf3_3->LookaheadGlyphCount))
 960                 continue;
 961             TRACE("Matched LookAhead\n");
 962
 963             ccsf3_4 = (const GSUB_ChainContextSubstFormat3_4 *)((BYTE *)ccsf3_3 +
 964                     FIELD_OFFSET(GSUB_ChainContextSubstFormat3_3, Coverage[GET_BE_WORD(ccsf3_3->LookaheadGlyphCount)]));
 965
 966             if (GET_BE_WORD(ccsf3_4->SubstCount))
 967             {
 968                 for (k = 0; k < GET_BE_WORD(ccsf3_4->SubstCount); k++)
 969                 {
 970                     int lookupIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].LookupListIndex);
 971                     int SequenceIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].SequenceIndex) * write_dir;
 972
 973                     TRACE("SUBST: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
 974                     newIndex = GSUB_apply_lookup(lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count);
 975                     if (newIndex == -1)
 976                     {
 977                         ERR("Chain failed to generate a glyph\n");
 978                         continue;
 979                     }
 980                 }
 981                 return newIndex;
 982             }
 983             else return GSUB_E_NOGLYPH;
 984         }
 985     }
 986     return -1;
 987 }
 988
 989 static INT GSUB_apply_lookup(const OT_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 990 {
 991     int offset;
 992     const OT_LookupTable *look;
 993
 994     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
 995     look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
 996     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
 997     switch(GET_BE_WORD(look->LookupType))
 998     {
 999         case 1:
1000             return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1001         case 2:
1002             return GSUB_apply_MultipleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1003         case 3:
1004             return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1005         case 4:
1006             return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1007         case 6:
1008             return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
1009         default:
1010             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
1011     }
1012     return GSUB_E_NOGLYPH;
1013 }
1014
1015 INT OpenType_apply_GSUB_lookup(LPCVOID table, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
1016 {
1017     const GSUB_Header *header = (const GSUB_Header *)table;
1018     const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1019
1020     return GSUB_apply_lookup(lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count);
1021 }
1022
1023 /**********
1024  * GPOS
1025  **********/
1026 static INT GPOS_apply_lookup(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, INT* piAdvance, const OT_LookupList* lookup, INT lookup_index, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, GOFFSET *pGoffset);
1027
1028 static INT GPOS_get_device_table_value(const OT_DeviceTable *DeviceTable, WORD ppem)
1029 {
1030     static const WORD mask[3] = {3,0xf,0xff};
1031     if (DeviceTable && ppem >= GET_BE_WORD(DeviceTable->StartSize) && ppem  <= GET_BE_WORD(DeviceTable->EndSize))
1032     {
1033         int format = GET_BE_WORD(DeviceTable->DeltaFormat);
1034         int index = ppem - GET_BE_WORD(DeviceTable->StartSize);
1035         int value;
1036         TRACE("device table, format %i, index %i\n",format, index);
1037         index = index << format;
1038         value = (DeviceTable->DeltaValue[index/sizeof(WORD)] << (index%sizeof(WORD)))&mask[format-1];
1039         TRACE("offset %i, value %i\n",index, value);
1040         if (value > mask[format-1]/2)
1041             value = -1 * ((mask[format-1]+1) - value);
1042         return value;
1043     }
1044     return 0;
1045 }
1046
1047 static VOID GPOS_get_anchor_values(LPCVOID table, LPPOINT pt, WORD ppem)
1048 {
1049     const GPOS_AnchorFormat1* anchor1 = (const GPOS_AnchorFormat1*)table;
1050
1051     switch (GET_BE_WORD(anchor1->AnchorFormat))
1052     {
1053         case 1:
1054         {
1055             TRACE("Anchor Format 1\n");
1056             pt->x = (short)GET_BE_WORD(anchor1->XCoordinate);
1057             pt->y = (short)GET_BE_WORD(anchor1->YCoordinate);
1058             break;
1059         }
1060         case 2:
1061         {
1062             const GPOS_AnchorFormat2* anchor2 = (const GPOS_AnchorFormat2*)table;
1063             TRACE("Anchor Format 2\n");
1064             pt->x = (short)GET_BE_WORD(anchor2->XCoordinate);
1065             pt->y = (short)GET_BE_WORD(anchor2->YCoordinate);
1066             break;
1067         }
1068         case 3:
1069         {
1070             int offset;
1071             const GPOS_AnchorFormat3* anchor3 = (const GPOS_AnchorFormat3*)table;
1072             TRACE("Anchor Format 3\n");
1073             pt->x = (short)GET_BE_WORD(anchor3->XCoordinate);
1074             pt->y = (short)GET_BE_WORD(anchor3->YCoordinate);
1075             offset = GET_BE_WORD(anchor3->XDeviceTable);
1076             TRACE("ppem %i\n",ppem);
1077             if (offset)
1078             {
1079                 const OT_DeviceTable* DeviceTableX = NULL;
1080                 DeviceTableX = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
1081                 pt->x += GPOS_get_device_table_value(DeviceTableX, ppem);
1082             }
1083             offset = GET_BE_WORD(anchor3->YDeviceTable);
1084             if (offset)
1085             {
1086                 const OT_DeviceTable* DeviceTableY = NULL;
1087                 DeviceTableY = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
1088                 pt->y += GPOS_get_device_table_value(DeviceTableY, ppem);
1089             }
1090             break;
1091         }
1092         default:
1093             ERR("Unknown Anchor Format %i\n",GET_BE_WORD(anchor1->AnchorFormat));
1094             pt->x = 0;
1095             pt->y = 0;
1096     }
1097 }
1098
1099 static void GPOS_convert_design_units_to_device(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, int desX, int desY, double *devX, double *devY)
1100 {
1101     int emHeight = lpotm->otmTextMetrics.tmAscent + lpotm->otmTextMetrics.tmDescent - lpotm->otmTextMetrics.tmInternalLeading;
1102
1103     TRACE("emHeight %i lfWidth %i\n",emHeight, lplogfont->lfWidth);
1104     *devX = (desX * emHeight) / (double)lpotm->otmEMSquare;
1105     *devY = (desY * emHeight) / (double)lpotm->otmEMSquare;
1106     if (lplogfont->lfWidth)
1107         FIXME("Font with lfWidth set no handled properly\n");
1108 }
1109
1110 static INT GPOS_get_value_record(WORD ValueFormat, const WORD data[], GPOS_ValueRecord *record)
1111 {
1112     INT offset = 0;
1113     if (ValueFormat & 0x0001) record->XPlacement = GET_BE_WORD(data[offset++]);
1114     if (ValueFormat & 0x0002) record->YPlacement = GET_BE_WORD(data[offset++]);
1115     if (ValueFormat & 0x0004) record->XAdvance = GET_BE_WORD(data[offset++]);
1116     if (ValueFormat & 0x0008) record->YAdvance = GET_BE_WORD(data[offset++]);
1117     if (ValueFormat & 0x0010) record->XPlaDevice = GET_BE_WORD(data[offset++]);
1118     if (ValueFormat & 0x0020) record->YPlaDevice = GET_BE_WORD(data[offset++]);
1119     if (ValueFormat & 0x0040) record->XAdvDevice = GET_BE_WORD(data[offset++]);
1120     if (ValueFormat & 0x0080) record->YAdvDevice = GET_BE_WORD(data[offset++]);
1121     return offset;
1122 }
1123
1124 static VOID GPOS_get_value_record_offsets(const BYTE* head, GPOS_ValueRecord *ValueRecord,  WORD ValueFormat, INT ppem, LPPOINT ptPlacement, LPPOINT ptAdvance)
1125 {
1126     if (ValueFormat & 0x0001) ptPlacement->x += (short)ValueRecord->XPlacement;
1127     if (ValueFormat & 0x0002) ptPlacement->y += (short)ValueRecord->YPlacement;
1128     if (ValueFormat & 0x0004) ptAdvance->x += (short)ValueRecord->XAdvance;
1129     if (ValueFormat & 0x0008) ptAdvance->y += (short)ValueRecord->YAdvance;
1130     if (ValueFormat & 0x0010) ptPlacement->x += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->XPlaDevice), ppem);
1131     if (ValueFormat & 0x0020) ptPlacement->y += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->YPlaDevice), ppem);
1132     if (ValueFormat & 0x0040) ptAdvance->x += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->XAdvDevice), ppem);
1133     if (ValueFormat & 0x0080) ptAdvance->y += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->YAdvDevice), ppem);
1134     if (ValueFormat & 0xFF00) FIXME("Unhandled Value Format %x\n",ValueFormat&0xFF00);
1135 }
1136
1137 static VOID GPOS_apply_SingleAdjustment(const OT_LookupTable *look, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, INT ppem, LPPOINT ptAdjust, LPPOINT ptAdvance)
1138 {
1139     int j;
1140
1141     TRACE("Single Adjustment Positioning Subtable\n");
1142
1143     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1144     {
1145         const GPOS_SinglePosFormat1 *spf1;
1146         WORD offset = GET_BE_WORD(look->SubTable[j]);
1147         spf1 = (const GPOS_SinglePosFormat1*)((const BYTE*)look+offset);
1148         if (GET_BE_WORD(spf1->PosFormat) == 1)
1149         {
1150             offset = GET_BE_WORD(spf1->Coverage);
1151             if (GSUB_is_glyph_covered((const BYTE*)spf1+offset, glyphs[glyph_index]) != -1)
1152             {
1153                 GPOS_ValueRecord ValueRecord = {0,0,0,0,0,0,0,0};
1154                 WORD ValueFormat = GET_BE_WORD(spf1->ValueFormat);
1155                 GPOS_get_value_record(ValueFormat, spf1->Value, &ValueRecord);
1156                 GPOS_get_value_record_offsets((const BYTE*)spf1, &ValueRecord,  ValueFormat, ppem, ptAdjust, ptAdvance);
1157                 TRACE("Glyph Adjusted by %i,%i\n",ValueRecord.XPlacement,ValueRecord.YPlacement);
1158             }
1159         }
1160         else if (GET_BE_WORD(spf1->PosFormat) == 2)
1161         {
1162             int index;
1163             const GPOS_SinglePosFormat2 *spf2;
1164             spf2 = (const GPOS_SinglePosFormat2*)spf1;
1165             offset = GET_BE_WORD(spf2->Coverage);
1166             index  = GSUB_is_glyph_covered((const BYTE*)spf2+offset, glyphs[glyph_index]);
1167             if (index != -1)
1168             {
1169                 int size;
1170                 GPOS_ValueRecord ValueRecord = {0,0,0,0,0,0,0,0};
1171                 WORD ValueFormat = GET_BE_WORD(spf2->ValueFormat);
1172                 size = GPOS_get_value_record(ValueFormat, spf2->Value, &ValueRecord);
1173                 if (index > 0)
1174                 {
1175                     offset = size * index;
1176                     GPOS_get_value_record(ValueFormat, &spf2->Value[offset], &ValueRecord);
1177                 }
1178                 GPOS_get_value_record_offsets((const BYTE*)spf2, &ValueRecord,  ValueFormat, ppem, ptAdjust, ptAdvance);
1179                 TRACE("Glyph Adjusted by %i,%i\n",ValueRecord.XPlacement,ValueRecord.YPlacement);
1180             }
1181         }
1182         else
1183             FIXME("Single Adjustment Positioning: Format %i Unhandled\n",GET_BE_WORD(spf1->PosFormat));
1184     }
1185 }
1186
1187 static INT GPOS_apply_PairAdjustment(const OT_LookupTable *look, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, INT ppem, LPPOINT ptAdjust, LPPOINT ptAdvance)
1188 {
1189     int j;
1190
1191     TRACE("Pair Adjustment Positioning Subtable\n");
1192
1193     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1194     {
1195         const GPOS_PairPosFormat1 *ppf1;
1196         WORD offset = GET_BE_WORD(look->SubTable[j]);
1197         ppf1 = (const GPOS_PairPosFormat1*)((const BYTE*)look+offset);
1198         if (GET_BE_WORD(ppf1->PosFormat) == 1)
1199         {
1200             int index;
1201             offset = GET_BE_WORD(ppf1->Coverage);
1202             index = GSUB_is_glyph_covered((const BYTE*)ppf1+offset, glyphs[glyph_index]);
1203             if (index != -1 && index < GET_BE_WORD(ppf1->PairSetCount))
1204             {
1205                 int k;
1206                 int pair_count;
1207                 const GPOS_PairSet *ps;
1208                 offset = GET_BE_WORD(ppf1->PairSetOffset[index]);
1209                 ps = (const GPOS_PairSet*)((const BYTE*)ppf1+offset);
1210                 pair_count = GET_BE_WORD(ps->PairValueCount);
1211                 for (k = 0; k < pair_count; k++)
1212                 {
1213                     WORD second_glyph = GET_BE_WORD(ps->PairValueRecord[k].SecondGlyph);
1214                     if (glyphs[glyph_index+write_dir] == second_glyph)
1215                     {
1216                         int next = 1;
1217                         GPOS_ValueRecord ValueRecord1 = {0,0,0,0,0,0,0,0};
1218                         GPOS_ValueRecord ValueRecord2 = {0,0,0,0,0,0,0,0};
1219                         WORD ValueFormat1 = GET_BE_WORD(ppf1->ValueFormat1);
1220                         WORD ValueFormat2 = GET_BE_WORD(ppf1->ValueFormat2);
1221
1222                         TRACE("Format 1: Found Pair %x,%x\n",glyphs[glyph_index],glyphs[glyph_index+write_dir]);
1223
1224                         offset = GPOS_get_value_record(ValueFormat1, ps->PairValueRecord[k].Value1, &ValueRecord1);
1225                         GPOS_get_value_record(ValueFormat2, (WORD*)((const BYTE*)(ps->PairValueRecord[k].Value2)+offset), &ValueRecord2);
1226                         if (ValueFormat1)
1227                         {
1228                             GPOS_get_value_record_offsets((const BYTE*)ppf1, &ValueRecord1,  ValueFormat1, ppem, &ptAdjust[0], &ptAdvance[0]);
1229                             TRACE("Glyph 1 resulting cumulative offset is %i,%i design units\n",ptAdjust[0].x,ptAdjust[0].y);
1230                             TRACE("Glyph 1 resulting cumulative advance is %i,%i design units\n",ptAdvance[0].x,ptAdvance[0].y);
1231                         }
1232                         if (ValueFormat2)
1233                         {
1234                             GPOS_get_value_record_offsets((const BYTE*)ppf1, &ValueRecord2,  ValueFormat2, ppem, &ptAdjust[1], &ptAdvance[1]);
1235                             TRACE("Glyph 2 resulting cumulative offset is %i,%i design units\n",ptAdjust[1].x,ptAdjust[1].y);
1236                             TRACE("Glyph 2 resulting cumulative advance is %i,%i design units\n",ptAdvance[1].x,ptAdvance[1].y);
1237                             next++;
1238                         }
1239                         if (next)
1240                             return glyph_index + next;
1241                     }
1242                 }
1243             }
1244         }
1245         else
1246             FIXME("Pair Adjustment Positioning: Format %i Unhandled\n",GET_BE_WORD(ppf1->PosFormat));
1247     }
1248     return glyph_index+1;
1249 }
1250
1251 static VOID GPOS_apply_MarkToBase(const OT_LookupTable *look, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, INT ppem, LPPOINT pt)
1252 {
1253     int j;
1254
1255     TRACE("MarkToBase Attachment Positioning Subtable\n");
1256
1257     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1258     {
1259         int offset;
1260         const GPOS_MarkBasePosFormat1 *mbpf1;
1261         offset = GET_BE_WORD(look->SubTable[j]);
1262         mbpf1 = (const GPOS_MarkBasePosFormat1*)((const BYTE*)look+offset);
1263         if (GET_BE_WORD(mbpf1->PosFormat) == 1)
1264         {
1265             int offset = GET_BE_WORD(mbpf1->MarkCoverage);
1266             int mark_index;
1267             mark_index = GSUB_is_glyph_covered((const BYTE*)mbpf1+offset, glyphs[glyph_index]);
1268             if (mark_index != -1)
1269             {
1270                 int base_index;
1271                 offset = GET_BE_WORD(mbpf1->BaseCoverage);
1272                 base_index = GSUB_is_glyph_covered((const BYTE*)mbpf1+offset, glyphs[glyph_index - write_dir]);
1273                 if (base_index != -1)
1274                 {
1275                     const GPOS_MarkArray *ma;
1276                     const GPOS_MarkRecord *mr;
1277                     const GPOS_BaseArray *ba;
1278                     const GPOS_BaseRecord *br;
1279                     int mark_class;
1280                     int class_count = GET_BE_WORD(mbpf1->ClassCount);
1281                     int baserecord_size;
1282                     POINT base_pt;
1283                     POINT mark_pt;
1284                     TRACE("Mark %x(%i) and base %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[glyph_index - write_dir], base_index);
1285                     offset = GET_BE_WORD(mbpf1->MarkArray);
1286                     ma = (const GPOS_MarkArray*)((const BYTE*)mbpf1 + offset);
1287                     if (mark_index > GET_BE_WORD(ma->MarkCount))
1288                     {
1289                         ERR("Mark index exeeded mark count\n");
1290                         return;
1291                     }
1292                     mr = &ma->MarkRecord[mark_index];
1293                     mark_class = GET_BE_WORD(mr->Class);
1294                     TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
1295                     offset = GET_BE_WORD(mbpf1->BaseArray);
1296                     ba = (const GPOS_BaseArray*)((const BYTE*)mbpf1 + offset);
1297                     baserecord_size = class_count * sizeof(WORD);
1298                     br = (const GPOS_BaseRecord*)((const BYTE*)ba + sizeof(WORD) + (baserecord_size * base_index));
1299                     offset = GET_BE_WORD(br->BaseAnchor[mark_class]);
1300                     GPOS_get_anchor_values((const BYTE*)ba + offset, &base_pt, ppem);
1301                     offset = GET_BE_WORD(mr->MarkAnchor);
1302                     GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
1303                     TRACE("Offset on base is %i,%i design units\n",base_pt.x,base_pt.y);
1304                     TRACE("Offset on mark is %i,%i design units\n",mark_pt.x, mark_pt.y);
1305                     pt->x += base_pt.x - mark_pt.x;
1306                     pt->y += base_pt.y - mark_pt.y;
1307                     TRACE("Resulting cumulative offset is %i,%i design units\n",pt->x,pt->y);
1308                 }
1309             }
1310         }
1311         else
1312             FIXME("Unhandled Mark To Base Format %i\n",GET_BE_WORD(mbpf1->PosFormat));
1313     }
1314 }
1315
1316 static VOID GPOS_apply_MarkToMark(const OT_LookupTable *look, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, INT ppem, LPPOINT pt)
1317 {
1318     int j;
1319
1320     TRACE("MarkToMark Attachment Positioning Subtable\n");
1321
1322     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1323     {
1324         int offset;
1325         const GPOS_MarkMarkPosFormat1 *mmpf1;
1326         offset = GET_BE_WORD(look->SubTable[j]);
1327         mmpf1 = (const GPOS_MarkMarkPosFormat1*)((const BYTE*)look+offset);
1328         if (GET_BE_WORD(mmpf1->PosFormat) == 1)
1329         {
1330             int offset = GET_BE_WORD(mmpf1->Mark1Coverage);
1331             int mark_index;
1332             mark_index = GSUB_is_glyph_covered((const BYTE*)mmpf1+offset, glyphs[glyph_index]);
1333             if (mark_index != -1)
1334             {
1335                 int mark2_index;
1336                 offset = GET_BE_WORD(mmpf1->Mark2Coverage);
1337                 mark2_index = GSUB_is_glyph_covered((const BYTE*)mmpf1+offset, glyphs[glyph_index - write_dir]);
1338                 if (mark2_index != -1)
1339                 {
1340                     const GPOS_MarkArray *ma;
1341                     const GPOS_MarkRecord *mr;
1342                     const GPOS_Mark2Array *m2a;
1343                     const GPOS_Mark2Record *m2r;
1344                     int mark_class;
1345                     int class_count = GET_BE_WORD(mmpf1->ClassCount);
1346                     int mark2record_size;
1347                     POINT mark2_pt;
1348                     POINT mark_pt;
1349                     TRACE("Mark %x(%i) and Mark2 %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[glyph_index - write_dir], mark2_index);
1350                     offset = GET_BE_WORD(mmpf1->Mark1Array);
1351                     ma = (const GPOS_MarkArray*)((const BYTE*)mmpf1 + offset);
1352                     if (mark_index > GET_BE_WORD(ma->MarkCount))
1353                     {
1354                         ERR("Mark index exeeded mark count\n");
1355                         return;
1356                     }
1357                     mr = &ma->MarkRecord[mark_index];
1358                     mark_class = GET_BE_WORD(mr->Class);
1359                     TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
1360                     offset = GET_BE_WORD(mmpf1->Mark2Array);
1361                     m2a = (const GPOS_Mark2Array*)((const BYTE*)mmpf1 + offset);
1362                     mark2record_size = class_count * sizeof(WORD);
1363                     m2r = (const GPOS_Mark2Record*)((const BYTE*)m2a + sizeof(WORD) + (mark2record_size * mark2_index));
1364                     offset = GET_BE_WORD(m2r->Mark2Anchor[mark_class]);
1365                     GPOS_get_anchor_values((const BYTE*)m2a + offset, &mark2_pt, ppem);
1366                     offset = GET_BE_WORD(mr->MarkAnchor);
1367                     GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
1368                     TRACE("Offset on mark2 is %i,%i design units\n",mark2_pt.x,mark2_pt.y);
1369                     TRACE("Offset on mark is %i,%i design units\n",mark_pt.x, mark_pt.y);
1370                     pt->x += mark2_pt.x - mark_pt.x;
1371                     pt->y += mark2_pt.y - mark_pt.y;
1372                     TRACE("Resulting cumulative offset is %i,%i design units\n",pt->x,pt->y);
1373                 }
1374             }
1375         }
1376         else
1377             FIXME("Unhandled Mark To Mark Format %i\n",GET_BE_WORD(mmpf1->PosFormat));
1378     }
1379 }
1380
1381 static INT GPOS_apply_ChainContextPos(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, INT* piAdvance, const OT_LookupList *lookup, const OT_LookupTable *look, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, INT ppem, GOFFSET *pGoffset)
1382 {
1383     int j;
1384
1385     TRACE("Chaining Contextual Positioning Subtable\n");
1386
1387     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1388     {
1389         int offset;
1390         const GPOS_ChainContextPosFormat3_1 *ccpf3;
1391         int dirLookahead = write_dir;
1392         int dirBacktrack = -1 * write_dir;
1393
1394         offset = GET_BE_WORD(look->SubTable[j]);
1395         ccpf3 = (const GPOS_ChainContextPosFormat3_1*)((const BYTE*)look+offset);
1396
1397         if (GET_BE_WORD(ccpf3->PosFormat) == 1)
1398         {
1399             FIXME("  TODO: subtype 1 (Simple Chaining Context Glyph Positioning)\n");
1400             continue;
1401         }
1402         else if (GET_BE_WORD(ccpf3->PosFormat) == 2)
1403         {
1404             FIXME("  TODO: subtype 2 (Class-based Chaining Context Glyph Positioning)\n");
1405             continue;
1406         }
1407         else if (GET_BE_WORD(ccpf3->PosFormat) == 3)
1408         {
1409             int k;
1410             int indexGlyphs;
1411             const GPOS_ChainContextPosFormat3_2 *ccpf3_2;
1412             const GPOS_ChainContextPosFormat3_3 *ccpf3_3;
1413             const GPOS_ChainContextPosFormat3_4 *ccpf3_4;
1414
1415             TRACE("  subtype 3 (Coverage-based Chaining Context Glyph Positioning)\n");
1416
1417             for (k = 0; k < GET_BE_WORD(ccpf3->BacktrackGlyphCount); k++)
1418             {
1419                 offset = GET_BE_WORD(ccpf3->Coverage[k]);
1420                 if (GSUB_is_glyph_covered((const BYTE*)ccpf3+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
1421                     break;
1422             }
1423             if (k != GET_BE_WORD(ccpf3->BacktrackGlyphCount))
1424                 continue;
1425             TRACE("Matched Backtrack\n");
1426
1427             ccpf3_2 = (const GPOS_ChainContextPosFormat3_2*)((BYTE *)ccpf3 +
1428                     FIELD_OFFSET(GPOS_ChainContextPosFormat3_1, Coverage[GET_BE_WORD(ccpf3->BacktrackGlyphCount)]));
1429
1430             indexGlyphs = GET_BE_WORD(ccpf3_2->InputGlyphCount);
1431             for (k = 0; k < indexGlyphs; k++)
1432             {
1433                 offset = GET_BE_WORD(ccpf3_2->Coverage[k]);
1434                 if (GSUB_is_glyph_covered((const BYTE*)ccpf3+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
1435                     break;
1436             }
1437             if (k != indexGlyphs)
1438                 continue;
1439             TRACE("Matched IndexGlyphs\n");
1440
1441             ccpf3_3 = (const GPOS_ChainContextPosFormat3_3*)((BYTE *)ccpf3_2 +
1442                     FIELD_OFFSET(GPOS_ChainContextPosFormat3_2, Coverage[GET_BE_WORD(ccpf3_2->InputGlyphCount)]));
1443
1444             for (k = 0; k < GET_BE_WORD(ccpf3_3->LookaheadGlyphCount); k++)
1445             {
1446                 offset = GET_BE_WORD(ccpf3_3->Coverage[k]);
1447                 if (GSUB_is_glyph_covered((const BYTE*)ccpf3+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
1448                     break;
1449             }
1450             if (k != GET_BE_WORD(ccpf3_3->LookaheadGlyphCount))
1451                 continue;
1452             TRACE("Matched LookAhead\n");
1453
1454             ccpf3_4 = (const GPOS_ChainContextPosFormat3_4*)((BYTE *)ccpf3_3 +
1455                     FIELD_OFFSET(GPOS_ChainContextPosFormat3_3, Coverage[GET_BE_WORD(ccpf3_3->LookaheadGlyphCount)]));
1456
1457             if (GET_BE_WORD(ccpf3_4->PosCount))
1458             {
1459                 for (k = 0; k < GET_BE_WORD(ccpf3_4->PosCount); k++)
1460                 {
1461                     int lookupIndex = GET_BE_WORD(ccpf3_4->PosLookupRecord[k].LookupListIndex);
1462                     int SequenceIndex = GET_BE_WORD(ccpf3_4->PosLookupRecord[k].SequenceIndex) * write_dir;
1463
1464                     TRACE("Position: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
1465                     GPOS_apply_lookup(lpotm, lplogfont, piAdvance, lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count, pGoffset);
1466                 }
1467                 return glyph_index + indexGlyphs + GET_BE_WORD(ccpf3_3->LookaheadGlyphCount);
1468             }
1469             else return glyph_index + 1;
1470         }
1471         else
1472             FIXME("Unhandled Chaining Contextual Positioning Format %i\n",GET_BE_WORD(ccpf3->PosFormat));
1473     }
1474     return glyph_index + 1;
1475 }
1476
1477 static INT GPOS_apply_lookup(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, INT* piAdvance, const OT_LookupList* lookup, INT lookup_index, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, GOFFSET *pGoffset)
1478 {
1479     int offset;
1480     const OT_LookupTable *look;
1481     int ppem = lpotm->otmTextMetrics.tmAscent + lpotm->otmTextMetrics.tmDescent - lpotm->otmTextMetrics.tmInternalLeading;
1482
1483     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
1484     look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
1485     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
1486     switch(GET_BE_WORD(look->LookupType))
1487     {
1488         case 1:
1489         {
1490             double devX, devY;
1491             POINT adjust = {0,0};
1492             POINT advance = {0,0};
1493             GPOS_apply_SingleAdjustment(look, glyphs, glyph_index, write_dir, glyph_count, ppem, &adjust, &advance);
1494             if (adjust.x || adjust.y)
1495             {
1496                 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust.x, adjust.y, &devX, &devY);
1497                 pGoffset[glyph_index].du += round(devX);
1498                 pGoffset[glyph_index].dv += round(devY);
1499             }
1500             if (advance.x || advance.y)
1501             {
1502                 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance.x, advance.y, &devX, &devY);
1503                 piAdvance[glyph_index] += round(devX);
1504                 if (advance.y)
1505                     FIXME("Unhandled adjustment to Y advancement\n");
1506             }
1507             break;
1508         }
1509         case 2:
1510         {
1511             POINT advance[2]= {{0,0},{0,0}};
1512             POINT adjust[2]= {{0,0},{0,0}};
1513             double devX, devY;
1514             int index;
1515             index = GPOS_apply_PairAdjustment(look, glyphs, glyph_index, write_dir, glyph_count, ppem, adjust, advance);
1516             if (adjust[0].x || adjust[0].y)
1517             {
1518                 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust[0].x, adjust[0].y, &devX, &devY);
1519                 pGoffset[glyph_index].du += round(devX);
1520                 pGoffset[glyph_index].dv += round(devY);
1521             }
1522             if (advance[0].x || advance[0].y)
1523             {
1524                 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance[0].x, advance[0].y, &devX, &devY);
1525                 piAdvance[glyph_index] += round(devX);
1526             }
1527             if (adjust[1].x || adjust[1].y)
1528             {
1529                 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust[1].x, adjust[1].y, &devX, &devY);
1530                 pGoffset[glyph_index + write_dir].du += round(devX);
1531                 pGoffset[glyph_index + write_dir].dv += round(devY);
1532             }
1533             if (advance[1].x || advance[1].y)
1534             {
1535                 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance[1].x, advance[1].y, &devX, &devY);
1536                 piAdvance[glyph_index + write_dir] += round(devX);
1537             }
1538             return index;
1539         }
1540         case 4:
1541         {
1542             double devX, devY;
1543             POINT desU = {0,0};
1544             GPOS_apply_MarkToBase(look, glyphs, glyph_index, write_dir, glyph_count, ppem, &desU);
1545             if (desU.x || desU.y)
1546             {
1547                 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
1548                 pGoffset[glyph_index].du += (round(devX) - piAdvance[glyph_index-1]);
1549                 pGoffset[glyph_index].dv += round(devY);
1550             }
1551             break;
1552         }
1553         case 6:
1554         {
1555             double devX, devY;
1556             POINT desU = {0,0};
1557             GPOS_apply_MarkToMark(look, glyphs, glyph_index, write_dir, glyph_count, ppem, &desU);
1558             if (desU.x || desU.y)
1559             {
1560                 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
1561                 pGoffset[glyph_index].du += round(devX) + pGoffset[glyph_index-1].du;
1562                 pGoffset[glyph_index].dv += round(devY) + pGoffset[glyph_index-1].dv;
1563             }
1564             break;
1565         }
1566         case 8:
1567         {
1568             return GPOS_apply_ChainContextPos(lpotm, lplogfont, piAdvance, lookup, look, glyphs, glyph_index, write_dir, glyph_count, ppem, pGoffset);
1569         }
1570         default:
1571             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
1572     }
1573     return glyph_index+1;
1574 }
1575
1576 INT OpenType_apply_GPOS_lookup(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, INT* piAdvance, LPCVOID table, INT lookup_index, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, GOFFSET *pGoffset)
1577 {
1578     const GPOS_Header *header = (const GPOS_Header *)table;
1579     const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1580
1581     return GPOS_apply_lookup(lpotm, lplogfont, piAdvance, lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count, pGoffset);
1582 }
1583
1584 static void GSUB_initialize_script_cache(ScriptCache *psc)
1585 {
1586     int i;
1587
1588     if (psc->GSUB_Table)
1589     {
1590         const OT_ScriptList *script;
1591         const GSUB_Header* header = (const GSUB_Header*)psc->GSUB_Table;
1592         script = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
1593         psc->script_count = GET_BE_WORD(script->ScriptCount);
1594         TRACE("initializing %i scripts in this font\n",psc->script_count);
1595         if (psc->script_count)
1596         {
1597             psc->scripts = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(LoadedScript) * psc->script_count);
1598             for (i = 0; i < psc->script_count; i++)
1599             {
1600                 int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1601                 psc->scripts[i].tag = MS_MAKE_TAG(script->ScriptRecord[i].ScriptTag[0], script->ScriptRecord[i].ScriptTag[1], script->ScriptRecord[i].ScriptTag[2], script->ScriptRecord[i].ScriptTag[3]);
1602                 psc->scripts[i].gsub_table = ((const BYTE*)script + offset);
1603             }
1604         }
1605     }
1606 }
1607
1608 static void GPOS_expand_script_cache(ScriptCache *psc)
1609 {
1610     int i, count;
1611     const OT_ScriptList *script;
1612     const GPOS_Header* header = (const GPOS_Header*)psc->GPOS_Table;
1613
1614     if (!header)
1615         return;
1616
1617     script = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
1618     count = GET_BE_WORD(script->ScriptCount);
1619
1620     if (!psc->script_count)
1621     {
1622         psc->script_count = count;
1623         TRACE("initializing %i scripts in this font\n",psc->script_count);
1624         if (psc->script_count)
1625         {
1626             psc->scripts = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(LoadedScript) * psc->script_count);
1627             for (i = 0; i < psc->script_count; i++)
1628             {
1629                 int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1630                 psc->scripts[i].tag = MS_MAKE_TAG(script->ScriptRecord[i].ScriptTag[0], script->ScriptRecord[i].ScriptTag[1], script->ScriptRecord[i].ScriptTag[2], script->ScriptRecord[i].ScriptTag[3]);
1631                 psc->scripts[i].gpos_table = ((const BYTE*)script + offset);
1632             }
1633         }
1634     }
1635     else
1636     {
1637         for (i = 0; i < count; i++)
1638         {
1639             int j;
1640             int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1641             OPENTYPE_TAG tag = MS_MAKE_TAG(script->ScriptRecord[i].ScriptTag[0], script->ScriptRecord[i].ScriptTag[1], script->ScriptRecord[i].ScriptTag[2], script->ScriptRecord[i].ScriptTag[3]);
1642             for (j = 0; j < psc->script_count; j++)
1643             {
1644                 if (psc->scripts[j].tag == tag)
1645                 {
1646                     psc->scripts[j].gpos_table = ((const BYTE*)script + offset);
1647                     break;
1648                 }
1649             }
1650             if (j == psc->script_count)
1651             {
1652                 psc->script_count++;
1653                 psc->scripts = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,psc->scripts, sizeof(LoadedScript) * psc->script_count);
1654                 psc->scripts[j].tag = tag;
1655                 psc->scripts[j].gpos_table = ((const BYTE*)script + offset);
1656             }
1657         }
1658     }
1659 }
1660
1661 static void _initialize_script_cache(ScriptCache *psc)
1662 {
1663     if (!psc->script_count)
1664     {
1665         GSUB_initialize_script_cache(psc);
1666         GPOS_expand_script_cache(psc);
1667     }
1668 }
1669
1670 HRESULT OpenType_GetFontScriptTags(ScriptCache *psc, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
1671 {
1672     int i;
1673     HRESULT rc = S_OK;
1674
1675     _initialize_script_cache(psc);
1676
1677     *pcTags = psc->script_count;
1678
1679     if (!searchingFor && cMaxTags < *pcTags)
1680         rc = E_OUTOFMEMORY;
1681     else if (searchingFor)
1682         rc = USP_E_SCRIPT_NOT_IN_FONT;
1683
1684     for (i = 0; i < psc->script_count; i++)
1685     {
1686         if (i < cMaxTags)
1687             pScriptTags[i] = psc->scripts[i].tag;
1688
1689         if (searchingFor)
1690         {
1691             if (searchingFor == psc->scripts[i].tag)
1692             {
1693                 pScriptTags[0] = psc->scripts[i].tag;
1694                 *pcTags = 1;
1695                 rc = S_OK;
1696                 break;
1697             }
1698         }
1699     }
1700     return rc;
1701 }
1702
1703 static void GSUB_initialize_language_cache(LoadedScript *script)
1704 {
1705     int i;
1706
1707     if (script->gsub_table)
1708     {
1709         DWORD offset;
1710         const OT_Script* table = script->gsub_table;
1711         script->language_count = GET_BE_WORD(table->LangSysCount);
1712         offset = GET_BE_WORD(table->DefaultLangSys);
1713         if (offset)
1714         {
1715             script->default_language.tag = MS_MAKE_TAG('d','f','l','t');
1716             script->default_language.gsub_table = (const BYTE*)table + offset;
1717         }
1718
1719         if (script->language_count)
1720         {
1721             TRACE("Deflang %p, LangCount %i\n",script->default_language.gsub_table, script->language_count);
1722
1723             script->languages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LoadedLanguage) * script->language_count);
1724
1725             for (i = 0; i < script->language_count; i++)
1726             {
1727                 int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1728                 script->languages[i].tag = MS_MAKE_TAG(table->LangSysRecord[i].LangSysTag[0], table->LangSysRecord[i].LangSysTag[1], table->LangSysRecord[i].LangSysTag[2], table->LangSysRecord[i].LangSysTag[3]);
1729                 script->languages[i].gsub_table = ((const BYTE*)table + offset);
1730             }
1731         }
1732     }
1733 }
1734
1735 static void GPOS_expand_language_cache(LoadedScript *script)
1736 {
1737     int count;
1738     const OT_Script* table = script->gpos_table;
1739     DWORD offset;
1740
1741     if (!table)
1742         return;
1743
1744     offset = GET_BE_WORD(table->DefaultLangSys);
1745     if (offset)
1746         script->default_language.gpos_table = (const BYTE*)table + offset;
1747
1748     count = GET_BE_WORD(table->LangSysCount);
1749
1750     TRACE("Deflang %p, LangCount %i\n",script->default_language.gpos_table, count);
1751     if (!script->language_count)
1752     {
1753         int i;
1754         script->language_count = count;
1755
1756         script->languages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LoadedLanguage) * script->language_count);
1757
1758         for (i = 0; i < script->language_count; i++)
1759         {
1760             int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1761             script->languages[i].tag = MS_MAKE_TAG(table->LangSysRecord[i].LangSysTag[0], table->LangSysRecord[i].LangSysTag[1], table->LangSysRecord[i].LangSysTag[2], table->LangSysRecord[i].LangSysTag[3]);
1762             script->languages[i].gpos_table = ((const BYTE*)table + offset);
1763         }
1764     }
1765     else if (count)
1766     {
1767         int i,j;
1768         for (i = 0; i < count; i++)
1769         {
1770             int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1771             OPENTYPE_TAG tag = MS_MAKE_TAG(table->LangSysRecord[i].LangSysTag[0], table->LangSysRecord[i].LangSysTag[1], table->LangSysRecord[i].LangSysTag[2], table->LangSysRecord[i].LangSysTag[3]);
1772
1773             for (j = 0; j < script->language_count; j++)
1774             {
1775                 if (script->languages[j].tag == tag)
1776                 {
1777                     script->languages[j].gpos_table = ((const BYTE*)table + offset);
1778                     break;
1779                 }
1780             }
1781             if (j == script->language_count)
1782             {
1783                 script->language_count++;
1784                 script->languages = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,script->languages, sizeof(LoadedLanguage) * script->language_count);
1785                 script->languages[j].tag = tag;
1786                 script->languages[j].gpos_table = ((const BYTE*)table + offset);
1787             }
1788         }
1789     }
1790 }
1791
1792 static void _initialize_language_cache(LoadedScript *script)
1793 {
1794     if (!script->language_count)
1795     {
1796         GSUB_initialize_language_cache(script);
1797         GPOS_expand_language_cache(script);
1798     }
1799 }
1800
1801 HRESULT OpenType_GetFontLanguageTags(ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pLanguageTags, int *pcTags)
1802 {
1803     int i;
1804     HRESULT rc = S_OK;
1805     LoadedScript *script = NULL;
1806
1807     _initialize_script_cache(psc);
1808
1809     for (i = 0; i < psc->script_count; i++)
1810     {
1811          if (psc->scripts[i].tag == script_tag)
1812          {
1813             script = &psc->scripts[i];
1814             break;
1815          }
1816     }
1817
1818     if (!script)
1819         return E_INVALIDARG;
1820
1821     _initialize_language_cache(script);
1822
1823     if (!searchingFor && cMaxTags < script->language_count)
1824         rc = E_OUTOFMEMORY;
1825     else if (searchingFor)
1826         rc = E_INVALIDARG;
1827
1828     *pcTags = script->language_count;
1829
1830     for (i = 0; i < script->language_count; i++)
1831     {
1832         if (i < cMaxTags)
1833             pLanguageTags[i] = script->languages[i].tag;
1834
1835         if (searchingFor)
1836         {
1837             if (searchingFor == script->languages[i].tag)
1838             {
1839                 pLanguageTags[0] = script->languages[i].tag;
1840                 *pcTags = 1;
1841                 rc = S_OK;
1842                 break;
1843             }
1844         }
1845     }
1846
1847     if (script->default_language.gsub_table)
1848     {
1849         if (i < cMaxTags)
1850             pLanguageTags[i] = script->default_language.tag;
1851
1852         if (searchingFor  && FAILED(rc))
1853         {
1854             pLanguageTags[0] = script->default_language.tag;
1855         }
1856         i++;
1857         *pcTags = (*pcTags) + 1;
1858     }
1859
1860     return rc;
1861 }
1862
1863
1864 static void GSUB_initialize_feature_cache(LPCVOID table, LoadedLanguage *language)
1865 {
1866     int i;
1867
1868     if (language->gsub_table)
1869     {
1870         const OT_LangSys *lang = language->gsub_table;
1871         const GSUB_Header *header = (const GSUB_Header *)table;
1872         const OT_FeatureList *feature_list;
1873
1874         language->feature_count = GET_BE_WORD(lang->FeatureCount);
1875         TRACE("%i features\n",language->feature_count);
1876
1877         if (language->feature_count)
1878         {
1879             language->features = HeapAlloc(GetProcessHeap(),0,sizeof(LoadedFeature)*language->feature_count);
1880
1881             feature_list = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
1882
1883             for (i = 0; i < language->feature_count; i++)
1884             {
1885                 const OT_Feature *feature;
1886                 int j;
1887                 int index = GET_BE_WORD(lang->FeatureIndex[i]);
1888
1889                 language->features[i].tag = MS_MAKE_TAG(feature_list->FeatureRecord[index].FeatureTag[0], feature_list->FeatureRecord[index].FeatureTag[1], feature_list->FeatureRecord[index].FeatureTag[2], feature_list->FeatureRecord[index].FeatureTag[3]);
1890                 language->features[i].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1891                 feature = (const OT_Feature*)language->features[i].feature;
1892                 language->features[i].lookup_count = GET_BE_WORD(feature->LookupCount);
1893                 language->features[i].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[i].lookup_count);
1894                 for (j = 0; j < language->features[i].lookup_count; j++)
1895                     language->features[i].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1896             }
1897         }
1898     }
1899 }
1900
1901 static void GPOS_expand_feature_cache(LPCVOID table, LoadedLanguage *language)
1902 {
1903     int i, count;
1904     const OT_LangSys *lang = language->gpos_table;
1905     const GPOS_Header *header = (const GPOS_Header *)table;
1906     const OT_FeatureList *feature_list;
1907
1908     if (!lang)
1909         return;
1910
1911     count = GET_BE_WORD(lang->FeatureCount);
1912     feature_list = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
1913
1914     TRACE("%i features\n",count);
1915     if (!language->feature_count)
1916     {
1917         language->feature_count = count;
1918
1919         if (language->feature_count)
1920         {
1921             language->features = HeapAlloc(GetProcessHeap(),0,sizeof(LoadedFeature)*language->feature_count);
1922
1923             for (i = 0; i < language->feature_count; i++)
1924             {
1925                 const OT_Feature *feature;
1926                 int j;
1927                 int index = GET_BE_WORD(lang->FeatureIndex[i]);
1928
1929                 language->features[i].tag = MS_MAKE_TAG(feature_list->FeatureRecord[index].FeatureTag[0], feature_list->FeatureRecord[index].FeatureTag[1], feature_list->FeatureRecord[index].FeatureTag[2], feature_list->FeatureRecord[index].FeatureTag[3]);
1930                 language->features[i].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1931                 feature = (const OT_Feature*)language->features[i].feature;
1932                 language->features[i].lookup_count = GET_BE_WORD(feature->LookupCount);
1933                 language->features[i].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[i].lookup_count);
1934                 for (j = 0; j < language->features[i].lookup_count; j++)
1935                     language->features[i].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1936             }
1937         }
1938     }
1939     else if (count)
1940     {
1941         language->features = HeapReAlloc(GetProcessHeap(),0,language->features, sizeof(LoadedFeature)*(language->feature_count + count));
1942
1943         for (i = 0; i < count; i++)
1944         {
1945             const OT_Feature *feature;
1946             int j;
1947             int index = GET_BE_WORD(lang->FeatureIndex[i]);
1948             int idx = language->feature_count + i;
1949
1950             language->features[idx].tag = MS_MAKE_TAG(feature_list->FeatureRecord[index].FeatureTag[0], feature_list->FeatureRecord[index].FeatureTag[1], feature_list->FeatureRecord[index].FeatureTag[2], feature_list->FeatureRecord[index].FeatureTag[3]);
1951             language->features[idx].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1952             feature = (const OT_Feature*)language->features[idx].feature;
1953             language->features[idx].lookup_count = GET_BE_WORD(feature->LookupCount);
1954             language->features[idx].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[idx].lookup_count);
1955             for (j = 0; j < language->features[idx].lookup_count; j++)
1956                 language->features[idx].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1957         }
1958         language->feature_count += count;
1959     }
1960 }
1961
1962 static void _initialize_feature_cache(ScriptCache *psc, LoadedLanguage *language)
1963 {
1964     if (!language->feature_count)
1965     {
1966         GSUB_initialize_feature_cache(psc->GSUB_Table, language);
1967         GPOS_expand_feature_cache(psc->GPOS_Table, language);
1968     }
1969 }
1970
1971 HRESULT OpenType_GetFontFeatureTags(ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG language_tag, BOOL filtered, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pFeatureTags, int *pcTags, LoadedFeature** feature)
1972 {
1973     int i;
1974     HRESULT rc = S_OK;
1975     LoadedScript *script = NULL;
1976     LoadedLanguage *language = NULL;
1977
1978     _initialize_script_cache(psc);
1979
1980     for (i = 0; i < psc->script_count; i++)
1981     {
1982         if (psc->scripts[i].tag == script_tag)
1983         {
1984             script = &psc->scripts[i];
1985             break;
1986         }
1987     }
1988
1989     if (!script)
1990     {
1991         *pcTags = 0;
1992         if (!filtered)
1993             return S_OK;
1994         else
1995             return E_INVALIDARG;
1996     }
1997
1998     _initialize_language_cache(script);
1999
2000     if ((script->default_language.gsub_table || script->default_language.gpos_table) && script->default_language.tag == language_tag)
2001         language = &script->default_language;
2002     else
2003     {
2004         for (i = 0; i < script->language_count; i++)
2005         {
2006             if (script->languages[i].tag == language_tag)
2007             {
2008                 language = &script->languages[i];
2009                 break;
2010             }
2011         }
2012     }
2013
2014     if (!language)
2015     {
2016         *pcTags = 0;
2017         return S_OK;
2018     }
2019
2020     _initialize_feature_cache(psc, language);
2021
2022     *pcTags = language->feature_count;
2023
2024     if (!searchingFor && cMaxTags < *pcTags)
2025         rc = E_OUTOFMEMORY;
2026     else if (searchingFor)
2027         rc = E_INVALIDARG;
2028
2029     for (i = 0; i < language->feature_count; i++)
2030     {
2031         if (i < cMaxTags)
2032             pFeatureTags[i] = language->features[i].tag;
2033
2034         if (searchingFor)
2035         {
2036             if (searchingFor == language->features[i].tag)
2037             {
2038                 pFeatureTags[0] = language->features[i].tag;
2039                 *pcTags = 1;
2040                 if (feature)
2041                     *feature = &language->features[i];
2042                 rc = S_OK;
2043                 break;
2044             }
2045         }
2046     }
2047     return rc;
2048 }