windowscodecs: Create Image Descriptor metadata block for a GIF frame.
[wine] / 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 *)(((LPBYTE)ccsf1)+sizeof(GSUB_ChainContextSubstFormat3_1) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_1->BacktrackGlyphCount)-1)));
937
938             indexGlyphs = GET_BE_WORD(ccsf3_2->InputGlyphCount);
939             for (k = 0; k < indexGlyphs; k++)
940             {
941                 offset = GET_BE_WORD(ccsf3_2->Coverage[k]);
942                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
943                     break;
944             }
945             if (k != indexGlyphs)
946                 continue;
947             TRACE("Matched IndexGlyphs\n");
948
949             ccsf3_3 = (const GSUB_ChainContextSubstFormat3_3 *)(((LPBYTE)ccsf3_2)+sizeof(GSUB_ChainContextSubstFormat3_2) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_2->InputGlyphCount)-1)));
950
951             for (k = 0; k < GET_BE_WORD(ccsf3_3->LookaheadGlyphCount); k++)
952             {
953                 offset = GET_BE_WORD(ccsf3_3->Coverage[k]);
954                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
955                     break;
956             }
957             if (k != GET_BE_WORD(ccsf3_3->LookaheadGlyphCount))
958                 continue;
959             TRACE("Matched LookAhead\n");
960
961             ccsf3_4 = (const GSUB_ChainContextSubstFormat3_4 *)(((LPBYTE)ccsf3_3)+sizeof(GSUB_ChainContextSubstFormat3_3) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_3->LookaheadGlyphCount)-1)));
962
963             if (GET_BE_WORD(ccsf3_4->SubstCount))
964             {
965                 for (k = 0; k < GET_BE_WORD(ccsf3_4->SubstCount); k++)
966                 {
967                     int lookupIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].LookupListIndex);
968                     int SequenceIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].SequenceIndex) * write_dir;
969
970                     TRACE("SUBST: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
971                     newIndex = GSUB_apply_lookup(lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count);
972                     if (newIndex == -1)
973                     {
974                         ERR("Chain failed to generate a glyph\n");
975                         continue;
976                     }
977                 }
978                 return newIndex;
979             }
980             else return GSUB_E_NOGLYPH;
981         }
982     }
983     return -1;
984 }
985
986 static INT GSUB_apply_lookup(const OT_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
987 {
988     int offset;
989     const OT_LookupTable *look;
990
991     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
992     look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
993     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
994     switch(GET_BE_WORD(look->LookupType))
995     {
996         case 1:
997             return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
998         case 2:
999             return GSUB_apply_MultipleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1000         case 3:
1001             return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1002         case 4:
1003             return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1004         case 6:
1005             return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
1006         default:
1007             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
1008     }
1009     return GSUB_E_NOGLYPH;
1010 }
1011
1012 INT OpenType_apply_GSUB_lookup(LPCVOID table, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
1013 {
1014     const GSUB_Header *header = (const GSUB_Header *)table;
1015     const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1016
1017     return GSUB_apply_lookup(lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count);
1018 }
1019
1020 /**********
1021  * GPOS
1022  **********/
1023 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);
1024
1025 static INT GPOS_get_device_table_value(const OT_DeviceTable *DeviceTable, WORD ppem)
1026 {
1027     static const WORD mask[3] = {3,0xf,0xff};
1028     if (DeviceTable && ppem >= GET_BE_WORD(DeviceTable->StartSize) && ppem  <= GET_BE_WORD(DeviceTable->EndSize))
1029     {
1030         int format = GET_BE_WORD(DeviceTable->DeltaFormat);
1031         int index = ppem - GET_BE_WORD(DeviceTable->StartSize);
1032         int value;
1033         TRACE("device table, format %i, index %i\n",format, index);
1034         index = index << format;
1035         value = (DeviceTable->DeltaValue[index/sizeof(WORD)] << (index%sizeof(WORD)))&mask[format-1];
1036         TRACE("offset %i, value %i\n",index, value);
1037         if (value > mask[format-1]/2)
1038             value = -1 * ((mask[format-1]+1) - value);
1039         return value;
1040     }
1041     return 0;
1042 }
1043
1044 static VOID GPOS_get_anchor_values(LPCVOID table, LPPOINT pt, WORD ppem)
1045 {
1046     const GPOS_AnchorFormat1* anchor1 = (const GPOS_AnchorFormat1*)table;
1047
1048     switch (GET_BE_WORD(anchor1->AnchorFormat))
1049     {
1050         case 1:
1051         {
1052             TRACE("Anchor Format 1\n");
1053             pt->x = (short)GET_BE_WORD(anchor1->XCoordinate);
1054             pt->y = (short)GET_BE_WORD(anchor1->YCoordinate);
1055             break;
1056         }
1057         case 2:
1058         {
1059             const GPOS_AnchorFormat2* anchor2 = (const GPOS_AnchorFormat2*)table;
1060             TRACE("Anchor Format 2\n");
1061             pt->x = (short)GET_BE_WORD(anchor2->XCoordinate);
1062             pt->y = (short)GET_BE_WORD(anchor2->YCoordinate);
1063             break;
1064         }
1065         case 3:
1066         {
1067             int offset;
1068             const GPOS_AnchorFormat3* anchor3 = (const GPOS_AnchorFormat3*)table;
1069             TRACE("Anchor Format 3\n");
1070             pt->x = (short)GET_BE_WORD(anchor3->XCoordinate);
1071             pt->y = (short)GET_BE_WORD(anchor3->YCoordinate);
1072             offset = GET_BE_WORD(anchor3->XDeviceTable);
1073             TRACE("ppem %i\n",ppem);
1074             if (offset)
1075             {
1076                 const OT_DeviceTable* DeviceTableX = NULL;
1077                 DeviceTableX = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
1078                 pt->x += GPOS_get_device_table_value(DeviceTableX, ppem);
1079             }
1080             offset = GET_BE_WORD(anchor3->YDeviceTable);
1081             if (offset)
1082             {
1083                 const OT_DeviceTable* DeviceTableY = NULL;
1084                 DeviceTableY = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
1085                 pt->y += GPOS_get_device_table_value(DeviceTableY, ppem);
1086             }
1087             break;
1088         }
1089         default:
1090             ERR("Unknown Anchor Format %i\n",GET_BE_WORD(anchor1->AnchorFormat));
1091             pt->x = 0;
1092             pt->y = 0;
1093     }
1094 }
1095
1096 static void GPOS_convert_design_units_to_device(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, int desX, int desY, double *devX, double *devY)
1097 {
1098     int emHeight = lpotm->otmTextMetrics.tmAscent + lpotm->otmTextMetrics.tmDescent - lpotm->otmTextMetrics.tmInternalLeading;
1099
1100     TRACE("emHeight %i lfWidth %i\n",emHeight, lplogfont->lfWidth);
1101     *devX = (desX * emHeight) / (double)lpotm->otmEMSquare;
1102     *devY = (desY * emHeight) / (double)lpotm->otmEMSquare;
1103     if (lplogfont->lfWidth)
1104         FIXME("Font with lfWidth set no handled properly\n");
1105 }
1106
1107 static INT GPOS_get_value_record(WORD ValueFormat, const WORD data[], GPOS_ValueRecord *record)
1108 {
1109     INT offset = 0;
1110     if (ValueFormat & 0x0001) record->XPlacement = GET_BE_WORD(data[offset++]);
1111     if (ValueFormat & 0x0002) record->YPlacement = GET_BE_WORD(data[offset++]);
1112     if (ValueFormat & 0x0004) record->XAdvance = GET_BE_WORD(data[offset++]);
1113     if (ValueFormat & 0x0008) record->YAdvance = GET_BE_WORD(data[offset++]);
1114     if (ValueFormat & 0x0010) record->XPlaDevice = GET_BE_WORD(data[offset++]);
1115     if (ValueFormat & 0x0020) record->YPlaDevice = GET_BE_WORD(data[offset++]);
1116     if (ValueFormat & 0x0040) record->XAdvDevice = GET_BE_WORD(data[offset++]);
1117     if (ValueFormat & 0x0080) record->YAdvDevice = GET_BE_WORD(data[offset++]);
1118     return offset;
1119 }
1120
1121 static VOID GPOS_get_value_record_offsets(const BYTE* head, GPOS_ValueRecord *ValueRecord,  WORD ValueFormat, INT ppem, LPPOINT ptPlacement, LPPOINT ptAdvance)
1122 {
1123     if (ValueFormat & 0x0001) ptPlacement->x += (short)ValueRecord->XPlacement;
1124     if (ValueFormat & 0x0002) ptPlacement->y += (short)ValueRecord->YPlacement;
1125     if (ValueFormat & 0x0004) ptAdvance->x += (short)ValueRecord->XAdvance;
1126     if (ValueFormat & 0x0008) ptAdvance->y += (short)ValueRecord->YAdvance;
1127     if (ValueFormat & 0x0010) ptPlacement->x += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->XPlaDevice), ppem);
1128     if (ValueFormat & 0x0020) ptPlacement->y += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->YPlaDevice), ppem);
1129     if (ValueFormat & 0x0040) ptAdvance->x += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->XAdvDevice), ppem);
1130     if (ValueFormat & 0x0080) ptAdvance->y += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->YAdvDevice), ppem);
1131     if (ValueFormat & 0xFF00) FIXME("Unhandled Value Format %x\n",ValueFormat&0xFF00);
1132 }
1133
1134 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)
1135 {
1136     int j;
1137
1138     TRACE("Single Adjustment Positioning Subtable\n");
1139
1140     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1141     {
1142         const GPOS_SinglePosFormat1 *spf1;
1143         WORD offset = GET_BE_WORD(look->SubTable[j]);
1144         spf1 = (const GPOS_SinglePosFormat1*)((const BYTE*)look+offset);
1145         if (GET_BE_WORD(spf1->PosFormat) == 1)
1146         {
1147             offset = GET_BE_WORD(spf1->Coverage);
1148             if (GSUB_is_glyph_covered((const BYTE*)spf1+offset, glyphs[glyph_index]) != -1)
1149             {
1150                 GPOS_ValueRecord ValueRecord = {0,0,0,0,0,0,0,0};
1151                 WORD ValueFormat = GET_BE_WORD(spf1->ValueFormat);
1152                 GPOS_get_value_record(ValueFormat, spf1->Value, &ValueRecord);
1153                 GPOS_get_value_record_offsets((const BYTE*)spf1, &ValueRecord,  ValueFormat, ppem, ptAdjust, ptAdvance);
1154                 TRACE("Glyph Adjusted by %i,%i\n",ValueRecord.XPlacement,ValueRecord.YPlacement);
1155             }
1156         }
1157         else if (GET_BE_WORD(spf1->PosFormat) == 2)
1158         {
1159             int index;
1160             const GPOS_SinglePosFormat2 *spf2;
1161             spf2 = (const GPOS_SinglePosFormat2*)spf1;
1162             offset = GET_BE_WORD(spf2->Coverage);
1163             index  = GSUB_is_glyph_covered((const BYTE*)spf2+offset, glyphs[glyph_index]);
1164             if (index != -1)
1165             {
1166                 int size;
1167                 GPOS_ValueRecord ValueRecord = {0,0,0,0,0,0,0,0};
1168                 WORD ValueFormat = GET_BE_WORD(spf2->ValueFormat);
1169                 size = GPOS_get_value_record(ValueFormat, spf2->Value, &ValueRecord);
1170                 if (index > 0)
1171                 {
1172                     offset = size * index;
1173                     GPOS_get_value_record(ValueFormat, &spf2->Value[offset], &ValueRecord);
1174                 }
1175                 GPOS_get_value_record_offsets((const BYTE*)spf2, &ValueRecord,  ValueFormat, ppem, ptAdjust, ptAdvance);
1176                 TRACE("Glyph Adjusted by %i,%i\n",ValueRecord.XPlacement,ValueRecord.YPlacement);
1177             }
1178         }
1179         else
1180             FIXME("Single Adjustment Positioning: Format %i Unhandled\n",GET_BE_WORD(spf1->PosFormat));
1181     }
1182 }
1183
1184 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)
1185 {
1186     int j;
1187
1188     TRACE("Pair Adjustment Positioning Subtable\n");
1189
1190     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1191     {
1192         const GPOS_PairPosFormat1 *ppf1;
1193         WORD offset = GET_BE_WORD(look->SubTable[j]);
1194         ppf1 = (const GPOS_PairPosFormat1*)((const BYTE*)look+offset);
1195         if (GET_BE_WORD(ppf1->PosFormat) == 1)
1196         {
1197             int index;
1198             offset = GET_BE_WORD(ppf1->Coverage);
1199             index = GSUB_is_glyph_covered((const BYTE*)ppf1+offset, glyphs[glyph_index]);
1200             if (index != -1 && index < GET_BE_WORD(ppf1->PairSetCount))
1201             {
1202                 int k;
1203                 int pair_count;
1204                 const GPOS_PairSet *ps;
1205                 offset = GET_BE_WORD(ppf1->PairSetOffset[index]);
1206                 ps = (const GPOS_PairSet*)((const BYTE*)ppf1+offset);
1207                 pair_count = GET_BE_WORD(ps->PairValueCount);
1208                 for (k = 0; k < pair_count; k++)
1209                 {
1210                     WORD second_glyph = GET_BE_WORD(ps->PairValueRecord[k].SecondGlyph);
1211                     if (glyphs[glyph_index+write_dir] == second_glyph)
1212                     {
1213                         int next = 1;
1214                         GPOS_ValueRecord ValueRecord1 = {0,0,0,0,0,0,0,0};
1215                         GPOS_ValueRecord ValueRecord2 = {0,0,0,0,0,0,0,0};
1216                         WORD ValueFormat1 = GET_BE_WORD(ppf1->ValueFormat1);
1217                         WORD ValueFormat2 = GET_BE_WORD(ppf1->ValueFormat2);
1218
1219                         TRACE("Format 1: Found Pair %x,%x\n",glyphs[glyph_index],glyphs[glyph_index+write_dir]);
1220
1221                         offset = GPOS_get_value_record(ValueFormat1, ps->PairValueRecord[k].Value1, &ValueRecord1);
1222                         GPOS_get_value_record(ValueFormat2, (WORD*)((const BYTE*)(ps->PairValueRecord[k].Value2)+offset), &ValueRecord2);
1223                         if (ValueFormat1)
1224                         {
1225                             GPOS_get_value_record_offsets((const BYTE*)ppf1, &ValueRecord1,  ValueFormat1, ppem, &ptAdjust[0], &ptAdvance[0]);
1226                             TRACE("Glyph 1 resulting cumulative offset is %i,%i design units\n",ptAdjust[0].x,ptAdjust[0].y);
1227                             TRACE("Glyph 1 resulting cumulative advance is %i,%i design units\n",ptAdvance[0].x,ptAdvance[0].y);
1228                         }
1229                         if (ValueFormat2)
1230                         {
1231                             GPOS_get_value_record_offsets((const BYTE*)ppf1, &ValueRecord2,  ValueFormat2, ppem, &ptAdjust[1], &ptAdvance[1]);
1232                             TRACE("Glyph 2 resulting cumulative offset is %i,%i design units\n",ptAdjust[1].x,ptAdjust[1].y);
1233                             TRACE("Glyph 2 resulting cumulative advance is %i,%i design units\n",ptAdvance[1].x,ptAdvance[1].y);
1234                             next++;
1235                         }
1236                         if (next)
1237                             return glyph_index + next;
1238                     }
1239                 }
1240             }
1241         }
1242         else
1243             FIXME("Pair Adjustment Positioning: Format %i Unhandled\n",GET_BE_WORD(ppf1->PosFormat));
1244     }
1245     return glyph_index+1;
1246 }
1247
1248 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)
1249 {
1250     int j;
1251
1252     TRACE("MarkToBase Attachment Positioning Subtable\n");
1253
1254     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1255     {
1256         int offset;
1257         const GPOS_MarkBasePosFormat1 *mbpf1;
1258         offset = GET_BE_WORD(look->SubTable[j]);
1259         mbpf1 = (const GPOS_MarkBasePosFormat1*)((const BYTE*)look+offset);
1260         if (GET_BE_WORD(mbpf1->PosFormat) == 1)
1261         {
1262             int offset = GET_BE_WORD(mbpf1->MarkCoverage);
1263             int mark_index;
1264             mark_index = GSUB_is_glyph_covered((const BYTE*)mbpf1+offset, glyphs[glyph_index]);
1265             if (mark_index != -1)
1266             {
1267                 int base_index;
1268                 offset = GET_BE_WORD(mbpf1->BaseCoverage);
1269                 base_index = GSUB_is_glyph_covered((const BYTE*)mbpf1+offset, glyphs[glyph_index - write_dir]);
1270                 if (base_index != -1)
1271                 {
1272                     const GPOS_MarkArray *ma;
1273                     const GPOS_MarkRecord *mr;
1274                     const GPOS_BaseArray *ba;
1275                     const GPOS_BaseRecord *br;
1276                     int mark_class;
1277                     int class_count = GET_BE_WORD(mbpf1->ClassCount);
1278                     int baserecord_size;
1279                     POINT base_pt;
1280                     POINT mark_pt;
1281                     TRACE("Mark %x(%i) and base %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[glyph_index - write_dir], base_index);
1282                     offset = GET_BE_WORD(mbpf1->MarkArray);
1283                     ma = (const GPOS_MarkArray*)((const BYTE*)mbpf1 + offset);
1284                     if (mark_index > GET_BE_WORD(ma->MarkCount))
1285                     {
1286                         ERR("Mark index exeeded mark count\n");
1287                         return;
1288                     }
1289                     mr = &ma->MarkRecord[mark_index];
1290                     mark_class = GET_BE_WORD(mr->Class);
1291                     TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
1292                     offset = GET_BE_WORD(mbpf1->BaseArray);
1293                     ba = (const GPOS_BaseArray*)((const BYTE*)mbpf1 + offset);
1294                     baserecord_size = class_count * sizeof(WORD);
1295                     br = (const GPOS_BaseRecord*)((const BYTE*)ba + sizeof(WORD) + (baserecord_size * base_index));
1296                     offset = GET_BE_WORD(br->BaseAnchor[mark_class]);
1297                     GPOS_get_anchor_values((const BYTE*)ba + offset, &base_pt, ppem);
1298                     offset = GET_BE_WORD(mr->MarkAnchor);
1299                     GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
1300                     TRACE("Offset on base is %i,%i design units\n",base_pt.x,base_pt.y);
1301                     TRACE("Offset on mark is %i,%i design units\n",mark_pt.x, mark_pt.y);
1302                     pt->x += base_pt.x - mark_pt.x;
1303                     pt->y += base_pt.y - mark_pt.y;
1304                     TRACE("Resulting cumulative offset is %i,%i design units\n",pt->x,pt->y);
1305                 }
1306             }
1307         }
1308         else
1309             FIXME("Unhandled Mark To Base Format %i\n",GET_BE_WORD(mbpf1->PosFormat));
1310     }
1311 }
1312
1313 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)
1314 {
1315     int j;
1316
1317     TRACE("MarkToMark Attachment Positioning Subtable\n");
1318
1319     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1320     {
1321         int offset;
1322         const GPOS_MarkMarkPosFormat1 *mmpf1;
1323         offset = GET_BE_WORD(look->SubTable[j]);
1324         mmpf1 = (const GPOS_MarkMarkPosFormat1*)((const BYTE*)look+offset);
1325         if (GET_BE_WORD(mmpf1->PosFormat) == 1)
1326         {
1327             int offset = GET_BE_WORD(mmpf1->Mark1Coverage);
1328             int mark_index;
1329             mark_index = GSUB_is_glyph_covered((const BYTE*)mmpf1+offset, glyphs[glyph_index]);
1330             if (mark_index != -1)
1331             {
1332                 int mark2_index;
1333                 offset = GET_BE_WORD(mmpf1->Mark2Coverage);
1334                 mark2_index = GSUB_is_glyph_covered((const BYTE*)mmpf1+offset, glyphs[glyph_index - write_dir]);
1335                 if (mark2_index != -1)
1336                 {
1337                     const GPOS_MarkArray *ma;
1338                     const GPOS_MarkRecord *mr;
1339                     const GPOS_Mark2Array *m2a;
1340                     const GPOS_Mark2Record *m2r;
1341                     int mark_class;
1342                     int class_count = GET_BE_WORD(mmpf1->ClassCount);
1343                     int mark2record_size;
1344                     POINT mark2_pt;
1345                     POINT mark_pt;
1346                     TRACE("Mark %x(%i) and Mark2 %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[glyph_index - write_dir], mark2_index);
1347                     offset = GET_BE_WORD(mmpf1->Mark1Array);
1348                     ma = (const GPOS_MarkArray*)((const BYTE*)mmpf1 + offset);
1349                     if (mark_index > GET_BE_WORD(ma->MarkCount))
1350                     {
1351                         ERR("Mark index exeeded mark count\n");
1352                         return;
1353                     }
1354                     mr = &ma->MarkRecord[mark_index];
1355                     mark_class = GET_BE_WORD(mr->Class);
1356                     TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
1357                     offset = GET_BE_WORD(mmpf1->Mark2Array);
1358                     m2a = (const GPOS_Mark2Array*)((const BYTE*)mmpf1 + offset);
1359                     mark2record_size = class_count * sizeof(WORD);
1360                     m2r = (const GPOS_Mark2Record*)((const BYTE*)m2a + sizeof(WORD) + (mark2record_size * mark2_index));
1361                     offset = GET_BE_WORD(m2r->Mark2Anchor[mark_class]);
1362                     GPOS_get_anchor_values((const BYTE*)m2a + offset, &mark2_pt, ppem);
1363                     offset = GET_BE_WORD(mr->MarkAnchor);
1364                     GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
1365                     TRACE("Offset on mark2 is %i,%i design units\n",mark2_pt.x,mark2_pt.y);
1366                     TRACE("Offset on mark is %i,%i design units\n",mark_pt.x, mark_pt.y);
1367                     pt->x += mark2_pt.x - mark_pt.x;
1368                     pt->y += mark2_pt.y - mark_pt.y;
1369                     TRACE("Resulting cumulative offset is %i,%i design units\n",pt->x,pt->y);
1370                 }
1371             }
1372         }
1373         else
1374             FIXME("Unhandled Mark To Mark Format %i\n",GET_BE_WORD(mmpf1->PosFormat));
1375     }
1376 }
1377
1378 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)
1379 {
1380     int j;
1381
1382     TRACE("Chaining Contextual Positioning Subtable\n");
1383
1384     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1385     {
1386         int offset;
1387         const GPOS_ChainContextPosFormat3_1 *ccpf3;
1388         int dirLookahead = write_dir;
1389         int dirBacktrack = -1 * write_dir;
1390
1391         offset = GET_BE_WORD(look->SubTable[j]);
1392         ccpf3 = (const GPOS_ChainContextPosFormat3_1*)((const BYTE*)look+offset);
1393
1394         if (GET_BE_WORD(ccpf3->PosFormat) == 1)
1395         {
1396             FIXME("  TODO: subtype 1 (Simple Chaining Context Glyph Positioning)\n");
1397             continue;
1398         }
1399         else if (GET_BE_WORD(ccpf3->PosFormat) == 2)
1400         {
1401             FIXME("  TODO: subtype 2 (Class-based Chaining Context Glyph Positioning)\n");
1402             continue;
1403         }
1404         else if (GET_BE_WORD(ccpf3->PosFormat) == 3)
1405         {
1406             int k;
1407             int indexGlyphs;
1408             const GPOS_ChainContextPosFormat3_2 *ccpf3_2;
1409             const GPOS_ChainContextPosFormat3_3 *ccpf3_3;
1410             const GPOS_ChainContextPosFormat3_4 *ccpf3_4;
1411
1412             TRACE("  subtype 3 (Coverage-based Chaining Context Glyph Positioning)\n");
1413
1414             for (k = 0; k < GET_BE_WORD(ccpf3->BacktrackGlyphCount); k++)
1415             {
1416                 offset = GET_BE_WORD(ccpf3->Coverage[k]);
1417                 if (GSUB_is_glyph_covered((const BYTE*)ccpf3+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
1418                     break;
1419             }
1420             if (k != GET_BE_WORD(ccpf3->BacktrackGlyphCount))
1421                 continue;
1422             TRACE("Matched Backtrack\n");
1423
1424             ccpf3_2 = (const GPOS_ChainContextPosFormat3_2*)(((LPBYTE)ccpf3)+sizeof(GPOS_ChainContextPosFormat3_1) + (sizeof(WORD) * (GET_BE_WORD(ccpf3->BacktrackGlyphCount)-1)));
1425
1426             indexGlyphs = GET_BE_WORD(ccpf3_2->InputGlyphCount);
1427             for (k = 0; k < indexGlyphs; k++)
1428             {
1429                 offset = GET_BE_WORD(ccpf3_2->Coverage[k]);
1430                 if (GSUB_is_glyph_covered((const BYTE*)ccpf3+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
1431                     break;
1432             }
1433             if (k != indexGlyphs)
1434                 continue;
1435             TRACE("Matched IndexGlyphs\n");
1436
1437             ccpf3_3 = (const GPOS_ChainContextPosFormat3_3*)(((LPBYTE)ccpf3_2)+sizeof(GPOS_ChainContextPosFormat3_2) + (sizeof(WORD) * (GET_BE_WORD(ccpf3_2->InputGlyphCount)-1)));
1438
1439             for (k = 0; k < GET_BE_WORD(ccpf3_3->LookaheadGlyphCount); k++)
1440             {
1441                 offset = GET_BE_WORD(ccpf3_3->Coverage[k]);
1442                 if (GSUB_is_glyph_covered((const BYTE*)ccpf3+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
1443                     break;
1444             }
1445             if (k != GET_BE_WORD(ccpf3_3->LookaheadGlyphCount))
1446                 continue;
1447             TRACE("Matched LookAhead\n");
1448
1449             ccpf3_4 = (const GPOS_ChainContextPosFormat3_4*)(((LPBYTE)ccpf3_3)+sizeof(GPOS_ChainContextPosFormat3_3) + (sizeof(WORD) * (GET_BE_WORD(ccpf3_3->LookaheadGlyphCount)-1)));
1450
1451             if (GET_BE_WORD(ccpf3_4->PosCount))
1452             {
1453                 for (k = 0; k < GET_BE_WORD(ccpf3_4->PosCount); k++)
1454                 {
1455                     int lookupIndex = GET_BE_WORD(ccpf3_4->PosLookupRecord[k].LookupListIndex);
1456                     int SequenceIndex = GET_BE_WORD(ccpf3_4->PosLookupRecord[k].SequenceIndex) * write_dir;
1457
1458                     TRACE("Position: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
1459                     GPOS_apply_lookup(lpotm, lplogfont, piAdvance, lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count, pGoffset);
1460                 }
1461                 return glyph_index + indexGlyphs + GET_BE_WORD(ccpf3_3->LookaheadGlyphCount);
1462             }
1463             else return glyph_index + 1;
1464         }
1465         else
1466             FIXME("Unhandled Chaining Contextual Positioning Format %i\n",GET_BE_WORD(ccpf3->PosFormat));
1467     }
1468     return glyph_index + 1;
1469 }
1470
1471 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)
1472 {
1473     int offset;
1474     const OT_LookupTable *look;
1475     int ppem = lpotm->otmTextMetrics.tmAscent + lpotm->otmTextMetrics.tmDescent - lpotm->otmTextMetrics.tmInternalLeading;
1476
1477     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
1478     look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
1479     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
1480     switch(GET_BE_WORD(look->LookupType))
1481     {
1482         case 1:
1483         {
1484             double devX, devY;
1485             POINT adjust = {0,0};
1486             POINT advance = {0,0};
1487             GPOS_apply_SingleAdjustment(look, glyphs, glyph_index, write_dir, glyph_count, ppem, &adjust, &advance);
1488             if (adjust.x || adjust.y)
1489             {
1490                 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust.x, adjust.y, &devX, &devY);
1491                 pGoffset[glyph_index].du += round(devX);
1492                 pGoffset[glyph_index].dv += round(devY);
1493             }
1494             if (advance.x || advance.y)
1495             {
1496                 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance.x, advance.y, &devX, &devY);
1497                 piAdvance[glyph_index] += round(devX);
1498                 if (advance.y)
1499                     FIXME("Unhandled adjustment to Y advancement\n");
1500             }
1501         }
1502         case 2:
1503         {
1504             POINT advance[2]= {{0,0},{0,0}};
1505             POINT adjust[2]= {{0,0},{0,0}};
1506             double devX, devY;
1507             int index;
1508             index = GPOS_apply_PairAdjustment(look, glyphs, glyph_index, write_dir, glyph_count, ppem, adjust, advance);
1509             if (adjust[0].x || adjust[0].y)
1510             {
1511                 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust[0].x, adjust[0].y, &devX, &devY);
1512                 pGoffset[glyph_index].du += round(devX);
1513                 pGoffset[glyph_index].dv += round(devY);
1514             }
1515             if (advance[0].x || advance[0].y)
1516             {
1517                 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance[0].x, advance[0].y, &devX, &devY);
1518                 piAdvance[glyph_index] += round(devX);
1519             }
1520             if (adjust[1].x || adjust[1].y)
1521             {
1522                 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust[1].x, adjust[1].y, &devX, &devY);
1523                 pGoffset[glyph_index + write_dir].du += round(devX);
1524                 pGoffset[glyph_index + write_dir].dv += round(devY);
1525             }
1526             if (advance[1].x || advance[1].y)
1527             {
1528                 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance[1].x, advance[1].y, &devX, &devY);
1529                 piAdvance[glyph_index + write_dir] += round(devX);
1530             }
1531             return index;
1532         }
1533         case 4:
1534         {
1535             double devX, devY;
1536             POINT desU = {0,0};
1537             GPOS_apply_MarkToBase(look, glyphs, glyph_index, write_dir, glyph_count, ppem, &desU);
1538             if (desU.x || desU.y)
1539             {
1540                 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
1541                 pGoffset[glyph_index].du += (round(devX) - piAdvance[glyph_index-1]);
1542                 pGoffset[glyph_index].dv += round(devY);
1543             }
1544             break;
1545         }
1546         case 6:
1547         {
1548             double devX, devY;
1549             POINT desU = {0,0};
1550             GPOS_apply_MarkToMark(look, glyphs, glyph_index, write_dir, glyph_count, ppem, &desU);
1551             if (desU.x || desU.y)
1552             {
1553                 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
1554                 pGoffset[glyph_index].du += round(devX) + pGoffset[glyph_index-1].du;
1555                 pGoffset[glyph_index].dv += round(devY) + pGoffset[glyph_index-1].dv;
1556             }
1557             break;
1558         }
1559         case 8:
1560         {
1561             return GPOS_apply_ChainContextPos(lpotm, lplogfont, piAdvance, lookup, look, glyphs, glyph_index, write_dir, glyph_count, ppem, pGoffset);
1562         }
1563         default:
1564             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
1565     }
1566     return glyph_index+1;
1567 }
1568
1569 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)
1570 {
1571     const GPOS_Header *header = (const GPOS_Header *)table;
1572     const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1573
1574     return GPOS_apply_lookup(lpotm, lplogfont, piAdvance, lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count, pGoffset);
1575 }
1576
1577 static void GSUB_initialize_script_cache(ScriptCache *psc)
1578 {
1579     int i;
1580
1581     if (psc->GSUB_Table)
1582     {
1583         const OT_ScriptList *script;
1584         const GSUB_Header* header = (const GSUB_Header*)psc->GSUB_Table;
1585         script = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
1586         psc->script_count = GET_BE_WORD(script->ScriptCount);
1587         TRACE("initializing %i scripts in this font\n",psc->script_count);
1588         if (psc->script_count)
1589         {
1590             psc->scripts = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(LoadedScript) * psc->script_count);
1591             for (i = 0; i < psc->script_count; i++)
1592             {
1593                 int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1594                 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]);
1595                 psc->scripts[i].gsub_table = ((const BYTE*)script + offset);
1596             }
1597         }
1598     }
1599 }
1600
1601 static void GPOS_expand_script_cache(ScriptCache *psc)
1602 {
1603     int i, count;
1604     const OT_ScriptList *script;
1605     const GPOS_Header* header = (const GPOS_Header*)psc->GPOS_Table;
1606
1607     if (!header)
1608         return;
1609
1610     script = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
1611     count = GET_BE_WORD(script->ScriptCount);
1612
1613     if (!psc->script_count)
1614     {
1615         psc->script_count = count;
1616         TRACE("initializing %i scripts in this font\n",psc->script_count);
1617         if (psc->script_count)
1618         {
1619             psc->scripts = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(LoadedScript) * psc->script_count);
1620             for (i = 0; i < psc->script_count; i++)
1621             {
1622                 int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1623                 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]);
1624                 psc->scripts[i].gpos_table = ((const BYTE*)script + offset);
1625             }
1626         }
1627     }
1628     else
1629     {
1630         for (i = 0; i < count; i++)
1631         {
1632             int j;
1633             int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1634             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]);
1635             for (j = 0; j < psc->script_count; j++)
1636             {
1637                 if (psc->scripts[j].tag == tag)
1638                 {
1639                     psc->scripts[j].gpos_table = ((const BYTE*)script + offset);
1640                     break;
1641                 }
1642             }
1643             if (j == psc->script_count)
1644             {
1645                 psc->script_count++;
1646                 psc->scripts = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,psc->scripts, sizeof(LoadedScript) * psc->script_count);
1647                 psc->scripts[j].tag = tag;
1648                 psc->scripts[j].gpos_table = ((const BYTE*)script + offset);
1649             }
1650         }
1651     }
1652 }
1653
1654 static void _initialize_script_cache(ScriptCache *psc)
1655 {
1656     if (!psc->script_count)
1657     {
1658         GSUB_initialize_script_cache(psc);
1659         GPOS_expand_script_cache(psc);
1660     }
1661 }
1662
1663 HRESULT OpenType_GetFontScriptTags(ScriptCache *psc, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
1664 {
1665     int i;
1666     HRESULT rc = S_OK;
1667
1668     _initialize_script_cache(psc);
1669
1670     *pcTags = psc->script_count;
1671
1672     if (!searchingFor && cMaxTags < *pcTags)
1673         rc = E_OUTOFMEMORY;
1674     else if (searchingFor)
1675         rc = USP_E_SCRIPT_NOT_IN_FONT;
1676
1677     for (i = 0; i < psc->script_count; i++)
1678     {
1679         if (i < cMaxTags)
1680             pScriptTags[i] = psc->scripts[i].tag;
1681
1682         if (searchingFor)
1683         {
1684             if (searchingFor == psc->scripts[i].tag)
1685             {
1686                 pScriptTags[0] = psc->scripts[i].tag;
1687                 *pcTags = 1;
1688                 rc = S_OK;
1689                 break;
1690             }
1691         }
1692     }
1693     return rc;
1694 }
1695
1696 static void GSUB_initialize_language_cache(LoadedScript *script)
1697 {
1698     int i;
1699
1700     if (script->gsub_table)
1701     {
1702         DWORD offset;
1703         const OT_Script* table = script->gsub_table;
1704         script->language_count = GET_BE_WORD(table->LangSysCount);
1705         offset = GET_BE_WORD(table->DefaultLangSys);
1706         if (offset)
1707         {
1708             script->default_language.tag = MS_MAKE_TAG('d','f','l','t');
1709             script->default_language.gsub_table = (const BYTE*)table + offset;
1710         }
1711
1712         if (script->language_count)
1713         {
1714             TRACE("Deflang %p, LangCount %i\n",script->default_language.gsub_table, script->language_count);
1715
1716             script->languages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LoadedLanguage) * script->language_count);
1717
1718             for (i = 0; i < script->language_count; i++)
1719             {
1720                 int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1721                 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]);
1722                 script->languages[i].gsub_table = ((const BYTE*)table + offset);
1723             }
1724         }
1725     }
1726 }
1727
1728 static void GPOS_expand_language_cache(LoadedScript *script)
1729 {
1730     int count;
1731     const OT_Script* table = script->gpos_table;
1732     DWORD offset;
1733
1734     if (!table)
1735         return;
1736
1737     offset = GET_BE_WORD(table->DefaultLangSys);
1738     if (offset)
1739         script->default_language.gpos_table = (const BYTE*)table + offset;
1740
1741     count = GET_BE_WORD(table->LangSysCount);
1742
1743     TRACE("Deflang %p, LangCount %i\n",script->default_language.gpos_table, count);
1744     if (!script->language_count)
1745     {
1746         int i;
1747         script->language_count = count;
1748
1749         script->languages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LoadedLanguage) * script->language_count);
1750
1751         for (i = 0; i < script->language_count; i++)
1752         {
1753             int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1754             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]);
1755             script->languages[i].gpos_table = ((const BYTE*)table + offset);
1756         }
1757     }
1758     else if (count)
1759     {
1760         int i,j;
1761         for (i = 0; i < count; i++)
1762         {
1763             int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1764             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]);
1765
1766             for (j = 0; j < script->language_count; j++)
1767             {
1768                 if (script->languages[j].tag == tag)
1769                 {
1770                     script->languages[j].gpos_table = ((const BYTE*)table + offset);
1771                     break;
1772                 }
1773             }
1774             if (j == script->language_count)
1775             {
1776                 script->language_count++;
1777                 script->languages = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,script->languages, sizeof(LoadedLanguage) * script->language_count);
1778                 script->languages[j].tag = tag;
1779                 script->languages[j].gpos_table = ((const BYTE*)table + offset);
1780             }
1781         }
1782     }
1783 }
1784
1785 static void _initialize_language_cache(LoadedScript *script)
1786 {
1787     if (!script->language_count)
1788     {
1789         GSUB_initialize_language_cache(script);
1790         GPOS_expand_language_cache(script);
1791     }
1792 }
1793
1794 HRESULT OpenType_GetFontLanguageTags(ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pLanguageTags, int *pcTags)
1795 {
1796     int i;
1797     HRESULT rc = S_OK;
1798     LoadedScript *script = NULL;
1799
1800     _initialize_script_cache(psc);
1801
1802     for (i = 0; i < psc->script_count; i++)
1803     {
1804          if (psc->scripts[i].tag == script_tag)
1805          {
1806             script = &psc->scripts[i];
1807             break;
1808          }
1809     }
1810
1811     if (!script)
1812         return E_INVALIDARG;
1813
1814     _initialize_language_cache(script);
1815
1816     if (!searchingFor && cMaxTags < script->language_count)
1817         rc = E_OUTOFMEMORY;
1818     else if (searchingFor)
1819         rc = E_INVALIDARG;
1820
1821     *pcTags = script->language_count;
1822
1823     for (i = 0; i < script->language_count; i++)
1824     {
1825         if (i < cMaxTags)
1826             pLanguageTags[i] = script->languages[i].tag;
1827
1828         if (searchingFor)
1829         {
1830             if (searchingFor == script->languages[i].tag)
1831             {
1832                 pLanguageTags[0] = script->languages[i].tag;
1833                 *pcTags = 1;
1834                 rc = S_OK;
1835                 break;
1836             }
1837         }
1838     }
1839
1840     if (script->default_language.gsub_table)
1841     {
1842         if (i < cMaxTags)
1843             pLanguageTags[i] = script->default_language.tag;
1844
1845         if (searchingFor  && FAILED(rc))
1846         {
1847             pLanguageTags[0] = script->default_language.tag;
1848         }
1849         i++;
1850         *pcTags = (*pcTags) + 1;
1851     }
1852
1853     return rc;
1854 }
1855
1856
1857 static void GSUB_initialize_feature_cache(LPCVOID table, LoadedLanguage *language)
1858 {
1859     int i;
1860
1861     if (language->gsub_table)
1862     {
1863         const OT_LangSys *lang = language->gsub_table;
1864         const GSUB_Header *header = (const GSUB_Header *)table;
1865         const OT_FeatureList *feature_list;
1866
1867         language->feature_count = GET_BE_WORD(lang->FeatureCount);
1868         TRACE("%i features\n",language->feature_count);
1869
1870         if (language->feature_count)
1871         {
1872             language->features = HeapAlloc(GetProcessHeap(),0,sizeof(LoadedFeature)*language->feature_count);
1873
1874             feature_list = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
1875
1876             for (i = 0; i < language->feature_count; i++)
1877             {
1878                 const OT_Feature *feature;
1879                 int j;
1880                 int index = GET_BE_WORD(lang->FeatureIndex[i]);
1881
1882                 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]);
1883                 language->features[i].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1884                 feature = (const OT_Feature*)language->features[i].feature;
1885                 language->features[i].lookup_count = GET_BE_WORD(feature->LookupCount);
1886                 language->features[i].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[i].lookup_count);
1887                 for (j = 0; j < language->features[i].lookup_count; j++)
1888                     language->features[i].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1889             }
1890         }
1891     }
1892 }
1893
1894 static void GPOS_expand_feature_cache(LPCVOID table, LoadedLanguage *language)
1895 {
1896     int i, count;
1897     const OT_LangSys *lang = language->gpos_table;
1898     const GPOS_Header *header = (const GPOS_Header *)table;
1899     const OT_FeatureList *feature_list;
1900
1901     if (!lang)
1902         return;
1903
1904     count = GET_BE_WORD(lang->FeatureCount);
1905     feature_list = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
1906
1907     TRACE("%i features\n",count);
1908     if (!language->feature_count)
1909     {
1910         language->feature_count = count;
1911
1912         if (language->feature_count)
1913         {
1914             language->features = HeapAlloc(GetProcessHeap(),0,sizeof(LoadedFeature)*language->feature_count);
1915
1916             for (i = 0; i < language->feature_count; i++)
1917             {
1918                 const OT_Feature *feature;
1919                 int j;
1920                 int index = GET_BE_WORD(lang->FeatureIndex[i]);
1921
1922                 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]);
1923                 language->features[i].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1924                 feature = (const OT_Feature*)language->features[i].feature;
1925                 language->features[i].lookup_count = GET_BE_WORD(feature->LookupCount);
1926                 language->features[i].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[i].lookup_count);
1927                 for (j = 0; j < language->features[i].lookup_count; j++)
1928                     language->features[i].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1929             }
1930         }
1931     }
1932     else if (count)
1933     {
1934         language->features = HeapReAlloc(GetProcessHeap(),0,language->features, sizeof(LoadedFeature)*(language->feature_count + count));
1935
1936         for (i = 0; i < count; i++)
1937         {
1938             const OT_Feature *feature;
1939             int j;
1940             int index = GET_BE_WORD(lang->FeatureIndex[i]);
1941             int idx = language->feature_count + i;
1942
1943             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]);
1944             language->features[idx].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1945             feature = (const OT_Feature*)language->features[idx].feature;
1946             language->features[idx].lookup_count = GET_BE_WORD(feature->LookupCount);
1947             language->features[idx].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[idx].lookup_count);
1948             for (j = 0; j < language->features[idx].lookup_count; j++)
1949                 language->features[idx].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1950         }
1951         language->feature_count += count;
1952     }
1953 }
1954
1955 static void _initialize_feature_cache(ScriptCache *psc, LoadedLanguage *language)
1956 {
1957     if (!language->feature_count)
1958     {
1959         GSUB_initialize_feature_cache(psc->GSUB_Table, language);
1960         GPOS_expand_feature_cache(psc->GPOS_Table, language);
1961     }
1962 }
1963
1964 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)
1965 {
1966     int i;
1967     HRESULT rc = S_OK;
1968     LoadedScript *script = NULL;
1969     LoadedLanguage *language = NULL;
1970
1971     _initialize_script_cache(psc);
1972
1973     for (i = 0; i < psc->script_count; i++)
1974     {
1975         if (psc->scripts[i].tag == script_tag)
1976         {
1977             script = &psc->scripts[i];
1978             break;
1979         }
1980     }
1981
1982     if (!script)
1983     {
1984         *pcTags = 0;
1985         if (!filtered)
1986             return S_OK;
1987         else
1988             return E_INVALIDARG;
1989     }
1990
1991     _initialize_language_cache(script);
1992
1993     if ((script->default_language.gsub_table || script->default_language.gpos_table) && script->default_language.tag == language_tag)
1994         language = &script->default_language;
1995     else
1996     {
1997         for (i = 0; i < script->language_count; i++)
1998         {
1999             if (script->languages[i].tag == language_tag)
2000             {
2001                 language = &script->languages[i];
2002                 break;
2003             }
2004         }
2005     }
2006
2007     if (!language)
2008     {
2009         *pcTags = 0;
2010         return S_OK;
2011     }
2012
2013     _initialize_feature_cache(psc, language);
2014
2015     *pcTags = language->feature_count;
2016
2017     if (!searchingFor && cMaxTags < *pcTags)
2018         rc = E_OUTOFMEMORY;
2019     else if (searchingFor)
2020         rc = E_INVALIDARG;
2021
2022     for (i = 0; i < language->feature_count; i++)
2023     {
2024         if (i < cMaxTags)
2025             pFeatureTags[i] = language->features[i].tag;
2026
2027         if (searchingFor)
2028         {
2029             if (searchingFor == language->features[i].tag)
2030             {
2031                 pFeatureTags[0] = language->features[i].tag;
2032                 *pcTags = 1;
2033                 if (feature)
2034                     *feature = &language->features[i];
2035                 rc = S_OK;
2036                 break;
2037             }
2038         }
2039     }
2040     return rc;
2041 }