ReactOS 0.4.16-dev-1520-gb558596
Classes | Macros | Enumerations | Functions
opentype.c File Reference
#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "usp10.h"
#include "winternl.h"
#include "usp10_internal.h"
#include "wine/debug.h"
#include "wine/heap.h"
Include dependency graph for opentype.c:

Go to the source code of this file.

Classes

struct  CMAP_EncodingRecord
 
struct  CMAP_Header
 
struct  CMAP_SegmentedCoverage_group
 
struct  CMAP_SegmentedCoverage
 
struct  GDEF_Header
 
struct  OT_ClassDefFormat1
 
struct  OT_ClassRangeRecord
 
struct  OT_ClassDefFormat2
 
struct  GSUB_Header
 
struct  OT_ScriptRecord
 
struct  OT_ScriptList
 
struct  OT_LangSysRecord
 
struct  OT_Script
 
struct  OT_LangSys
 
struct  OT_FeatureRecord
 
struct  OT_FeatureList
 
struct  OT_Feature
 
struct  OT_LookupList
 
struct  OT_LookupTable
 
struct  OT_CoverageFormat1
 
struct  OT_RangeRecord
 
struct  OT_CoverageFormat2
 
struct  GSUB_SingleSubstFormat1
 
struct  GSUB_SingleSubstFormat2
 
struct  GSUB_MultipleSubstFormat1
 
struct  GSUB_Sequence
 
struct  GSUB_LigatureSubstFormat1
 
struct  GSUB_LigatureSet
 
struct  GSUB_Ligature
 
struct  GSUB_SubstLookupRecord
 
struct  GSUB_ContextSubstFormat1
 
struct  GSUB_SubRuleSet
 
struct  GSUB_SubRule_1
 
struct  GSUB_SubRule_2
 
struct  GSUB_ContextSubstFormat2
 
struct  GSUB_SubClassSet
 
struct  GSUB_SubClassRule_1
 
struct  GSUB_SubClassRule_2
 
struct  GSUB_ChainContextSubstFormat1
 
struct  GSUB_ChainContextSubstFormat2
 
struct  GSUB_ChainSubClassSet
 
struct  GSUB_ChainSubClassRule_1
 
struct  GSUB_ChainSubClassRule_2
 
struct  GSUB_ChainSubClassRule_3
 
struct  GSUB_ChainSubClassRule_4
 
struct  GSUB_ChainContextSubstFormat3_1
 
struct  GSUB_ChainContextSubstFormat3_2
 
struct  GSUB_ChainContextSubstFormat3_3
 
struct  GSUB_ChainContextSubstFormat3_4
 
struct  GSUB_AlternateSubstFormat1
 
struct  GSUB_AlternateSet
 
struct  GSUB_ExtensionPosFormat1
 
struct  GPOS_Header
 
struct  OT_DeviceTable
 
struct  GPOS_AnchorFormat1
 
struct  GPOS_AnchorFormat2
 
struct  GPOS_AnchorFormat3
 
struct  GPOS_ValueRecord
 
struct  GPOS_SinglePosFormat1
 
struct  GPOS_SinglePosFormat2
 
struct  GPOS_PairPosFormat1
 
struct  GPOS_PairPosFormat2
 
struct  GPOS_PairValueRecord
 
struct  GPOS_PairSet
 
struct  GPOS_EntryExitRecord
 
struct  GPOS_CursivePosFormat1
 
struct  GPOS_MarkBasePosFormat1
 
struct  GPOS_BaseRecord
 
struct  GPOS_BaseArray
 
struct  GPOS_MarkRecord
 
struct  GPOS_MarkArray
 
struct  GPOS_MarkLigPosFormat1
 
struct  GPOS_LigatureArray
 
struct  GPOS_ComponentRecord
 
struct  GPOS_LigatureAttach
 
struct  GPOS_MarkMarkPosFormat1
 
struct  GPOS_Mark2Record
 
struct  GPOS_Mark2Array
 
struct  GPOS_PosLookupRecord
 
struct  GPOS_ContextPosFormat2
 
struct  GPOS_PosClassSet
 
struct  GPOS_PosClassRule_1
 
struct  GPOS_PosClassRule_2
 
struct  GPOS_ChainContextPosFormat3_1
 
struct  GPOS_ChainContextPosFormat3_2
 
struct  GPOS_ChainContextPosFormat3_3
 
struct  GPOS_ChainContextPosFormat3_4
 
struct  GPOS_ExtensionPosFormat1
 

Macros

#define GET_BE_WORD(x)   RtlUshortByteSwap(x)
 
#define GET_BE_DWORD(x)   RtlUlongByteSwap(x)
 
#define round(x)   (((x) < 0) ? (int)((x) - 0.5) : (int)((x) + 0.5))
 
#define CMAP_TAG   MS_MAKE_TAG('c', 'm', 'a', 'p')
 

Enumerations

enum  gpos_lookup_type {
  GPOS_LOOKUP_ADJUST_SINGLE = 0x1 , GPOS_LOOKUP_ADJUST_PAIR = 0x2 , GPOS_LOOKUP_ATTACH_CURSIVE = 0x3 , GPOS_LOOKUP_ATTACH_MARK_TO_BASE = 0x4 ,
  GPOS_LOOKUP_ATTACH_MARK_TO_LIGATURE = 0x5 , GPOS_LOOKUP_ATTACH_MARK_TO_MARK = 0x6 , GPOS_LOOKUP_POSITION_CONTEXT = 0x7 , GPOS_LOOKUP_POSITION_CONTEXT_CHAINED = 0x8 ,
  GPOS_LOOKUP_POSITION_EXTENSION = 0x9
}
 
enum  gsub_lookup_type {
  GSUB_LOOKUP_SINGLE = 0x1 , GSUB_LOOKUP_MULTIPLE = 0x2 , GSUB_LOOKUP_ALTERNATE = 0x3 , GSUB_LOOKUP_LIGATURE = 0x4 ,
  GSUB_LOOKUP_CONTEXT = 0x5 , GSUB_LOOKUP_CONTEXT_CHAINED = 0x6 , GSUB_LOOKUP_EXTENSION = 0x7 , GSUB_LOOKUP_CONTEXT_CHAINED_REVERSE = 0x8
}
 
enum  { BaseGlyph =1 , LigatureGlyph , MarkGlyph , ComponentGlyph }
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (uniscribe)
 
static VOID * load_CMAP_format12_table (HDC hdc, ScriptCache *psc)
 
static int __cdecl compare_group (const void *a, const void *b)
 
DWORD OpenType_CMAP_GetGlyphIndex (HDC hdc, ScriptCache *psc, DWORD utf32c, WORD *glyph_index, DWORD flags)
 
static WORD OT_get_glyph_class (const void *table, WORD glyph)
 
void OpenType_GDEF_UpdateGlyphProps (ScriptCache *psc, const WORD *pwGlyphs, const WORD cGlyphs, WORD *pwLogClust, const WORD cChars, SCRIPT_GLYPHPROP *pGlyphProp)
 
static INT GSUB_apply_lookup (const OT_LookupList *lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
static int GSUB_is_glyph_covered (const void *table, unsigned int glyph)
 
static const BYTE * GSUB_get_subtable (const OT_LookupTable *look, int index)
 
static INT GSUB_apply_SingleSubst (const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
static INT GSUB_apply_MultipleSubst (const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
static INT GSUB_apply_AlternateSubst (const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
static INT GSUB_apply_LigatureSubst (const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
static INT GSUB_apply_ContextSubst (const OT_LookupList *lookup, const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
static INT GSUB_apply_ChainContextSubst (const OT_LookupList *lookup, const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 
int OpenType_apply_GSUB_lookup (const void *table, unsigned int lookup_index, WORD *glyphs, unsigned int glyph_index, int write_dir, int *glyph_count)
 
static unsigned int GPOS_apply_lookup (const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, const OT_LookupList *lookup, unsigned int lookup_index, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
 
static INT GPOS_get_device_table_value (const OT_DeviceTable *DeviceTable, WORD ppem)
 
static void GPOS_get_anchor_values (const void *table, POINT *pt, WORD ppem)
 
static void GPOS_convert_design_units_to_device (const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, int desX, int desY, double *devX, double *devY)
 
static INT GPOS_get_value_record (WORD ValueFormat, const WORD data[], GPOS_ValueRecord *record)
 
static void GPOS_get_value_record_offsets (const BYTE *head, GPOS_ValueRecord *ValueRecord, WORD ValueFormat, unsigned int ppem, POINT *ptPlacement, POINT *ptAdvance)
 
static const BYTE * GPOS_get_subtable (const OT_LookupTable *look, int index)
 
static void GPOS_apply_SingleAdjustment (const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *adjust, POINT *advance)
 
static void apply_pair_value (const void *pos_table, WORD val_fmt1, WORD val_fmt2, const WORD *pair, INT ppem, POINT *adjust, POINT *advance)
 
static int GPOS_apply_PairAdjustment (const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *adjust, POINT *advance)
 
static void GPOS_apply_CursiveAttachment (const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
 
static int GPOS_apply_MarkToBase (const ScriptCache *script_cache, const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
 
static void GPOS_apply_MarkToLigature (const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
 
static BOOL GPOS_apply_MarkToMark (const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
 
static unsigned int GPOS_apply_ContextPos (const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, const OT_LookupList *lookup, const OT_LookupTable *look, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
 
static unsigned int GPOS_apply_ChainContextPos (const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, const OT_LookupList *lookup, const OT_LookupTable *look, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
 
unsigned int OpenType_apply_GPOS_lookup (const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, unsigned int lookup_index, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
 
static LoadedScript * usp10_script_cache_add_script (ScriptCache *script_cache, OPENTYPE_TAG tag)
 
static LoadedScript * usp10_script_cache_get_script (ScriptCache *script_cache, OPENTYPE_TAG tag)
 
static void usp10_script_cache_add_script_list (ScriptCache *script_cache, enum usp10_script_table table, const OT_ScriptList *list)
 
static void _initialize_script_cache (ScriptCache *script_cache)
 
HRESULT OpenType_GetFontScriptTags (ScriptCache *psc, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
 
static LoadedLanguage * usp10_script_add_language (LoadedScript *script, OPENTYPE_TAG tag)
 
static LoadedLanguage * usp10_script_get_language (LoadedScript *script, OPENTYPE_TAG tag)
 
static void usp10_script_add_language_list (LoadedScript *script, enum usp10_language_table table, const OT_Script *list)
 
static void _initialize_language_cache (LoadedScript *script)
 
HRESULT OpenType_GetFontLanguageTags (ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pLanguageTags, int *pcTags)
 
static void usp10_language_add_feature_list (LoadedLanguage *language, char table_type, const OT_LangSys *lang, const OT_FeatureList *feature_list)
 
static void _initialize_feature_cache (ScriptCache *psc, LoadedLanguage *language)
 
HRESULT OpenType_GetFontFeatureTags (ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG language_tag, BOOL filtered, OPENTYPE_TAG searchingFor, char tableType, int cMaxTags, OPENTYPE_TAG *pFeatureTags, int *pcTags, LoadedFeature **feature)
 

Macro Definition Documentation

◆ CMAP_TAG

#define CMAP_TAG   MS_MAKE_TAG('c', 'm', 'a', 'p')

Definition at line 50 of file opentype.c.

◆ GET_BE_DWORD

#define GET_BE_DWORD (   x)    RtlUlongByteSwap(x)

Definition at line 44 of file opentype.c.

◆ GET_BE_WORD

#define GET_BE_WORD (   x)    RtlUshortByteSwap(x)

Definition at line 43 of file opentype.c.

◆ round

#define round (   x)    (((x) < 0) ? (int)((x) - 0.5) : (int)((x) + 0.5))

Definition at line 47 of file opentype.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
BaseGlyph 
LigatureGlyph 
MarkGlyph 
ComponentGlyph 

Definition at line 105 of file opentype.c.

105{BaseGlyph=1, LigatureGlyph, MarkGlyph, ComponentGlyph};
LigatureGlyph
@ LigatureGlyph
Definition: opentype.c:105
ComponentGlyph
@ ComponentGlyph
Definition: opentype.c:105
BaseGlyph
@ BaseGlyph
Definition: opentype.c:105
MarkGlyph
@ MarkGlyph
Definition: opentype.c:105

◆ gpos_lookup_type

enum gpos_lookup_type
Enumerator
GPOS_LOOKUP_ADJUST_SINGLE 
GPOS_LOOKUP_ADJUST_PAIR 
GPOS_LOOKUP_ATTACH_CURSIVE 
GPOS_LOOKUP_ATTACH_MARK_TO_BASE 
GPOS_LOOKUP_ATTACH_MARK_TO_LIGATURE 
GPOS_LOOKUP_ATTACH_MARK_TO_MARK 
GPOS_LOOKUP_POSITION_CONTEXT 
GPOS_LOOKUP_POSITION_CONTEXT_CHAINED 
GPOS_LOOKUP_POSITION_EXTENSION 

Definition at line 52 of file opentype.c.

53{
54 GPOS_LOOKUP_ADJUST_SINGLE = 0x1,
55 GPOS_LOOKUP_ADJUST_PAIR = 0x2,
56 GPOS_LOOKUP_ATTACH_CURSIVE = 0x3,
57 GPOS_LOOKUP_ATTACH_MARK_TO_BASE = 0x4,
58 GPOS_LOOKUP_ATTACH_MARK_TO_LIGATURE = 0x5,
59 GPOS_LOOKUP_ATTACH_MARK_TO_MARK = 0x6,
60 GPOS_LOOKUP_POSITION_CONTEXT = 0x7,
61 GPOS_LOOKUP_POSITION_CONTEXT_CHAINED = 0x8,
62 GPOS_LOOKUP_POSITION_EXTENSION = 0x9,
63};
GPOS_LOOKUP_POSITION_CONTEXT_CHAINED
@ GPOS_LOOKUP_POSITION_CONTEXT_CHAINED
Definition: opentype.c:61
GPOS_LOOKUP_ATTACH_MARK_TO_LIGATURE
@ GPOS_LOOKUP_ATTACH_MARK_TO_LIGATURE
Definition: opentype.c:58
GPOS_LOOKUP_ADJUST_SINGLE
@ GPOS_LOOKUP_ADJUST_SINGLE
Definition: opentype.c:54
GPOS_LOOKUP_ADJUST_PAIR
@ GPOS_LOOKUP_ADJUST_PAIR
Definition: opentype.c:55
GPOS_LOOKUP_ATTACH_MARK_TO_BASE
@ GPOS_LOOKUP_ATTACH_MARK_TO_BASE
Definition: opentype.c:57
GPOS_LOOKUP_POSITION_EXTENSION
@ GPOS_LOOKUP_POSITION_EXTENSION
Definition: opentype.c:62
GPOS_LOOKUP_ATTACH_MARK_TO_MARK
@ GPOS_LOOKUP_ATTACH_MARK_TO_MARK
Definition: opentype.c:59
GPOS_LOOKUP_ATTACH_CURSIVE
@ GPOS_LOOKUP_ATTACH_CURSIVE
Definition: opentype.c:56
GPOS_LOOKUP_POSITION_CONTEXT
@ GPOS_LOOKUP_POSITION_CONTEXT
Definition: opentype.c:60

◆ gsub_lookup_type

enum gsub_lookup_type
Enumerator
GSUB_LOOKUP_SINGLE 
GSUB_LOOKUP_MULTIPLE 
GSUB_LOOKUP_ALTERNATE 
GSUB_LOOKUP_LIGATURE 
GSUB_LOOKUP_CONTEXT 
GSUB_LOOKUP_CONTEXT_CHAINED 
GSUB_LOOKUP_EXTENSION 
GSUB_LOOKUP_CONTEXT_CHAINED_REVERSE 

Definition at line 65 of file opentype.c.

66{
67 GSUB_LOOKUP_SINGLE = 0x1,
68 GSUB_LOOKUP_MULTIPLE = 0x2,
69 GSUB_LOOKUP_ALTERNATE = 0x3,
70 GSUB_LOOKUP_LIGATURE = 0x4,
71 GSUB_LOOKUP_CONTEXT = 0x5,
72 GSUB_LOOKUP_CONTEXT_CHAINED = 0x6,
73 GSUB_LOOKUP_EXTENSION = 0x7,
74 GSUB_LOOKUP_CONTEXT_CHAINED_REVERSE = 0x8,
75};
GSUB_LOOKUP_CONTEXT_CHAINED_REVERSE
@ GSUB_LOOKUP_CONTEXT_CHAINED_REVERSE
Definition: opentype.c:74
GSUB_LOOKUP_LIGATURE
@ GSUB_LOOKUP_LIGATURE
Definition: opentype.c:70
GSUB_LOOKUP_SINGLE
@ GSUB_LOOKUP_SINGLE
Definition: opentype.c:67
GSUB_LOOKUP_MULTIPLE
@ GSUB_LOOKUP_MULTIPLE
Definition: opentype.c:68
GSUB_LOOKUP_EXTENSION
@ GSUB_LOOKUP_EXTENSION
Definition: opentype.c:73
GSUB_LOOKUP_CONTEXT_CHAINED
@ GSUB_LOOKUP_CONTEXT_CHAINED
Definition: opentype.c:72
GSUB_LOOKUP_CONTEXT
@ GSUB_LOOKUP_CONTEXT
Definition: opentype.c:71
GSUB_LOOKUP_ALTERNATE
@ GSUB_LOOKUP_ALTERNATE
Definition: opentype.c:69

Function Documentation

◆ _initialize_feature_cache()

static void _initialize_feature_cache ( ScriptCache *  psc,
LoadedLanguage *  language 
)
static

Definition at line 2847 of file opentype.c.

2848{
2849 const GSUB_Header *gsub_header = psc->GSUB_Table;
2850 const GPOS_Header *gpos_header = psc->GPOS_Table;
2851 const OT_FeatureList *feature_list;
2852 const OT_LangSys *lang;
2853
2854 if (language->features_initialized)
2855 return;
2856
2857 if ((lang = language->table[USP10_LANGUAGE_TABLE_GSUB]))
2858 {
2859 feature_list = (const OT_FeatureList *)((const BYTE *)gsub_header + GET_BE_WORD(gsub_header->FeatureList));
2860 usp10_language_add_feature_list(language, FEATURE_GSUB_TABLE, lang, feature_list);
2861 }
2862
2863 if ((lang = language->table[USP10_LANGUAGE_TABLE_GPOS]))
2864 {
2865 feature_list = (const OT_FeatureList *)((const BYTE *)gpos_header + GET_BE_WORD(gpos_header->FeatureList));
2866 usp10_language_add_feature_list(language, FEATURE_GPOS_TABLE, lang, feature_list);
2867 }
2868
2869 language->features_initialized = TRUE;
2870}
TRUE
#define TRUE
Definition: types.h:120
psc
static SCRIPT_CACHE * psc
Definition: usp10.c:64
usp10_language_add_feature_list
static void usp10_language_add_feature_list(LoadedLanguage *language, char table_type, const OT_LangSys *lang, const OT_FeatureList *feature_list)
Definition: opentype.c:2813
GET_BE_WORD
#define GET_BE_WORD(x)
Definition: opentype.c:43
GPOS_Header
Definition: opentype.c:394
GPOS_Header::FeatureList
WORD FeatureList
Definition: opentype.c:397
GSUB_Header
Definition: opentype.c:136
GSUB_Header::FeatureList
WORD FeatureList
Definition: opentype.c:139
LoadedLanguage::table
const void * table[USP10_LANGUAGE_TABLE_COUNT]
Definition: usp10_internal.h:162
OT_FeatureList
Definition: opentype.c:176
OT_LangSys
Definition: opentype.c:164
FEATURE_GSUB_TABLE
#define FEATURE_GSUB_TABLE
Definition: usp10_internal.h:142
USP10_LANGUAGE_TABLE_GSUB
@ USP10_LANGUAGE_TABLE_GSUB
Definition: usp10_internal.h:155
USP10_LANGUAGE_TABLE_GPOS
@ USP10_LANGUAGE_TABLE_GPOS
Definition: usp10_internal.h:156
FEATURE_GPOS_TABLE
#define FEATURE_GPOS_TABLE
Definition: usp10_internal.h:143
lang
static const WCHAR lang[]
Definition: wbemdisp.c:287
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by OpenType_GetFontFeatureTags().

◆ _initialize_language_cache()

static void _initialize_language_cache ( LoadedScript *  script)
static

Definition at line 2746 of file opentype.c.

2747{
2748 const OT_Script *list;
2749
2750 if (script->languages_initialized)
2751 return;
2752
2753 if ((list = script->table[USP10_SCRIPT_TABLE_GSUB]))
2754 usp10_script_add_language_list(script, USP10_LANGUAGE_TABLE_GSUB, list);
2755 if ((list = script->table[USP10_SCRIPT_TABLE_GPOS]))
2756 usp10_script_add_language_list(script, USP10_LANGUAGE_TABLE_GPOS, list);
2757
2758 script->languages_initialized = TRUE;
2759}
list
Definition: list.h:37
script
script
Definition: msipriv.h:383
usp10_script_add_language_list
static void usp10_script_add_language_list(LoadedScript *script, enum usp10_language_table table, const OT_Script *list)
Definition: opentype.c:2708
list
#define list
Definition: rosglue.h:35
OT_Script
Definition: opentype.c:158
USP10_SCRIPT_TABLE_GSUB
@ USP10_SCRIPT_TABLE_GSUB
Definition: usp10_internal.h:171
USP10_SCRIPT_TABLE_GPOS
@ USP10_SCRIPT_TABLE_GPOS
Definition: usp10_internal.h:172

Referenced by OpenType_GetFontFeatureTags(), and OpenType_GetFontLanguageTags().

◆ _initialize_script_cache()

static void _initialize_script_cache ( ScriptCache *  script_cache)
static

Definition at line 2628 of file opentype.c.

2629{
2630 const GPOS_Header *gpos_header;
2631 const GSUB_Header *gsub_header;
2632
2633 if (script_cache->scripts_initialized)
2634 return;
2635
2636 if ((gsub_header = script_cache->GSUB_Table))
2637 usp10_script_cache_add_script_list(script_cache, USP10_SCRIPT_TABLE_GSUB,
2638 (const OT_ScriptList *)((const BYTE *)gsub_header + GET_BE_WORD(gsub_header->ScriptList)));
2639
2640 if ((gpos_header = script_cache->GPOS_Table))
2641 usp10_script_cache_add_script_list(script_cache, USP10_SCRIPT_TABLE_GPOS,
2642 (const OT_ScriptList *)((const BYTE *)gpos_header + GET_BE_WORD(gpos_header->ScriptList)));
2643
2644 script_cache->scripts_initialized = TRUE;
2645}
usp10_script_cache_add_script_list
static void usp10_script_cache_add_script_list(ScriptCache *script_cache, enum usp10_script_table table, const OT_ScriptList *list)
Definition: opentype.c:2598
GPOS_Header::ScriptList
WORD ScriptList
Definition: opentype.c:396
GSUB_Header::ScriptList
WORD ScriptList
Definition: opentype.c:138
OT_ScriptList
Definition: opentype.c:148
ScriptCache::GPOS_Table
void * GPOS_Table
Definition: usp10_internal.h:204
ScriptCache::scripts_initialized
BOOL scripts_initialized
Definition: usp10_internal.h:205
ScriptCache::GSUB_Table
void * GSUB_Table
Definition: usp10_internal.h:200

Referenced by OpenType_GetFontFeatureTags(), OpenType_GetFontLanguageTags(), and OpenType_GetFontScriptTags().

◆ apply_pair_value()

static void apply_pair_value ( const void *  pos_table,
WORD  val_fmt1,
WORD  val_fmt2,
const WORD *  pair,
INT  ppem,
POINT *  adjust,
POINT *  advance 
)
static

Definition at line 1746 of file opentype.c.

1748{
1749 GPOS_ValueRecord val_rec1 = {0,0,0,0,0,0,0,0};
1750 GPOS_ValueRecord val_rec2 = {0,0,0,0,0,0,0,0};
1751 INT size;
1752
1753 size = GPOS_get_value_record( val_fmt1, pair, &val_rec1 );
1754 GPOS_get_value_record( val_fmt2, pair + size, &val_rec2 );
1755
1756 if (val_fmt1)
1757 {
1758 GPOS_get_value_record_offsets( pos_table, &val_rec1, val_fmt1, ppem, adjust, advance );
1759 TRACE( "Glyph 1 resulting cumulative offset is %s design units\n", wine_dbgstr_point(&adjust[0]) );
1760 TRACE( "Glyph 1 resulting cumulative advance is %s design units\n", wine_dbgstr_point(&advance[0]) );
1761 }
1762 if (val_fmt2)
1763 {
1764 GPOS_get_value_record_offsets( pos_table, &val_rec2, val_fmt2, ppem, adjust + 1, advance + 1 );
1765 TRACE( "Glyph 2 resulting cumulative offset is %s design units\n", wine_dbgstr_point(&adjust[1]) );
1766 TRACE( "Glyph 2 resulting cumulative advance is %s design units\n", wine_dbgstr_point(&advance[1]) );
1767 }
1768}
advance
_STLP_MOVE_TO_STD_NAMESPACE void _STLP_CALL advance(_InputIterator &__i, _Distance __n)
Definition: _iterator_base.h:515
wine_dbgstr_point
static const char * wine_dbgstr_point(const POINT *ppt)
Definition: atltest.h:138
size
GLsizeiptr size
Definition: glext.h:5919
GPOS_get_value_record
static INT GPOS_get_value_record(WORD ValueFormat, const WORD data[], GPOS_ValueRecord *record)
Definition: opentype.c:1648
GPOS_get_value_record_offsets
static void GPOS_get_value_record_offsets(const BYTE *head, GPOS_ValueRecord *ValueRecord, WORD ValueFormat, unsigned int ppem, POINT *ptPlacement, POINT *ptAdvance)
Definition: opentype.c:1662
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
GPOS_ValueRecord
Definition: opentype.c:429
pair
Definition: _pair.h:47
INT
int32_t INT
Definition: typedefs.h:58

Referenced by GPOS_apply_PairAdjustment().

◆ compare_group()

static int __cdecl compare_group ( const void *  a,
const void *  b 
)
static

Definition at line 661 of file opentype.c.

662{
663 const DWORD *chr = a;
664 const CMAP_SegmentedCoverage_group *group = b;
665
666 if (*chr < GET_BE_DWORD(group->startCharCode))
667 return -1;
668 if (*chr > GET_BE_DWORD(group->endCharCode))
669 return 1;
670 return 0;
671}
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
group
GLboolean GLuint group
Definition: glext.h:11120
a
#define a
Definition: ke_i.h:78
b
#define b
Definition: ke_i.h:79
GET_BE_DWORD
#define GET_BE_DWORD(x)
Definition: opentype.c:44
CMAP_SegmentedCoverage_group
Definition: opentype.c:89

Referenced by OpenType_CMAP_GetGlyphIndex().

◆ GPOS_apply_ChainContextPos()

static unsigned int GPOS_apply_ChainContextPos ( const ScriptCache *  script_cache,
const OUTLINETEXTMETRICW *  otm,
const LOGFONTW *  logfont,
const SCRIPT_ANALYSIS *  analysis,
int *  advance,
const OT_LookupList *  lookup,
const OT_LookupTable *  look,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
GOFFSET *  goffset 
)
static

Definition at line 2261 of file opentype.c.

2265{
2266 int j;
2267 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
2268
2269 TRACE("Chaining Contextual Positioning Subtable\n");
2270
2271 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
2272 {
2273 int offset;
2274 const GPOS_ChainContextPosFormat3_1 *backtrack = (GPOS_ChainContextPosFormat3_1 *)GPOS_get_subtable(look, j);
2275 int dirLookahead = write_dir;
2276 int dirBacktrack = -1 * write_dir;
2277
2278 if (GET_BE_WORD(backtrack->PosFormat) == 1)
2279 {
2280 static int once;
2281 if (!once++)
2282 FIXME(" TODO: subtype 1 (Simple Chaining Context Glyph Positioning)\n");
2283 continue;
2284 }
2285 else if (GET_BE_WORD(backtrack->PosFormat) == 2)
2286 {
2287 static int once;
2288 if (!once++)
2289 FIXME(" TODO: subtype 2 (Class-based Chaining Context Glyph Positioning)\n");
2290 continue;
2291 }
2292 else if (GET_BE_WORD(backtrack->PosFormat) == 3)
2293 {
2294 WORD backtrack_count, input_count, lookahead_count, positioning_count;
2295 int k;
2296 const GPOS_ChainContextPosFormat3_2 *input;
2297 const GPOS_ChainContextPosFormat3_3 *lookahead;
2298 const GPOS_ChainContextPosFormat3_4 *positioning;
2299
2300 TRACE(" subtype 3 (Coverage-based Chaining Context Glyph Positioning)\n");
2301
2302 backtrack_count = GET_BE_WORD(backtrack->BacktrackGlyphCount);
2303 k = glyph_index + dirBacktrack * backtrack_count;
2304 if (k < 0 || k >= glyph_count)
2305 continue;
2306
2307 input = (const GPOS_ChainContextPosFormat3_2 *)&backtrack->Coverage[backtrack_count];
2308 input_count = GET_BE_WORD(input->InputGlyphCount);
2309 k = glyph_index + write_dir * (input_count - 1);
2310 if (k < 0 || k >= glyph_count)
2311 continue;
2312
2313 lookahead = (const GPOS_ChainContextPosFormat3_3 *)&input->Coverage[input_count];
2314 lookahead_count = GET_BE_WORD(lookahead->LookaheadGlyphCount);
2315 k = glyph_index + dirLookahead * (input_count + lookahead_count - 1);
2316 if (k < 0 || k >= glyph_count)
2317 continue;
2318
2319 positioning = (const GPOS_ChainContextPosFormat3_4 *)&lookahead->Coverage[lookahead_count];
2320
2321 for (k = 0; k < backtrack_count; ++k)
2322 {
2323 offset = GET_BE_WORD(backtrack->Coverage[k]);
2324 if (GSUB_is_glyph_covered((const BYTE *)backtrack + offset,
2325 glyphs[glyph_index + (dirBacktrack * (k + 1))]) == -1)
2326 break;
2327 }
2328 if (k != backtrack_count)
2329 continue;
2330 TRACE("Matched Backtrack\n");
2331
2332 for (k = 0; k < input_count; ++k)
2333 {
2334 offset = GET_BE_WORD(input->Coverage[k]);
2335 if (GSUB_is_glyph_covered((const BYTE *)backtrack + offset,
2336 glyphs[glyph_index + (write_dir * k)]) == -1)
2337 break;
2338 }
2339 if (k != input_count)
2340 continue;
2341 TRACE("Matched IndexGlyphs\n");
2342
2343 for (k = 0; k < lookahead_count; ++k)
2344 {
2345 offset = GET_BE_WORD(lookahead->Coverage[k]);
2346 if (GSUB_is_glyph_covered((const BYTE *)backtrack + offset,
2347 glyphs[glyph_index + (dirLookahead * (input_count + k))]) == -1)
2348 break;
2349 }
2350 if (k != lookahead_count)
2351 continue;
2352 TRACE("Matched LookAhead\n");
2353
2354 if (!(positioning_count = GET_BE_WORD(positioning->PosCount)))
2355 return 1;
2356
2357 for (k = 0; k < positioning_count; ++k)
2358 {
2359 unsigned int lookup_index = GET_BE_WORD(positioning->PosLookupRecord[k].LookupListIndex);
2360 unsigned int sequence_index = GET_BE_WORD(positioning->PosLookupRecord[k].SequenceIndex);
2361 unsigned int g = glyph_index + write_dir * sequence_index;
2362
2363 if (g >= glyph_count)
2364 {
2365 WARN("Skipping invalid sequence index %u (glyph index %u, write dir %d).\n",
2366 sequence_index, glyph_index, write_dir);
2367 continue;
2368 }
2369
2370 TRACE("Position: %u -> %u %u.\n", k, sequence_index, lookup_index);
2371 GPOS_apply_lookup(script_cache, otm, logfont, analysis, advance, lookup, lookup_index,
2372 glyphs, g, glyph_count, goffset);
2373 }
2374 return input_count + lookahead_count;
2375 }
2376 else
2377 FIXME("Unhandled Chaining Contextual Positioning Format %#x.\n", GET_BE_WORD(backtrack->PosFormat));
2378 }
2379 return 1;
2380}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
lookup
static ULONG lookup[16]
Definition: vga.c:48
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
offset
GLintptr offset
Definition: glext.h:5920
g
GLboolean GLboolean g
Definition: glext.h:6204
input
GLenum GLenum GLenum input
Definition: glext.h:9031
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
for
#define for
Definition: utility.h:88
glyphs
static UINT UINT LPWORD glyphs
Definition: font.c:44
k
int k
Definition: mpi.c:3369
GSUB_is_glyph_covered
static int GSUB_is_glyph_covered(const void *table, unsigned int glyph)
Definition: opentype.c:819
GPOS_apply_lookup
static unsigned int GPOS_apply_lookup(const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, const OT_LookupList *lookup, unsigned int lookup_index, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
Definition: opentype.c:2382
GPOS_get_subtable
static const BYTE * GPOS_get_subtable(const OT_LookupTable *look, int index)
Definition: opentype.c:1676
GPOS_ChainContextPosFormat3_1
Definition: opentype.c:596
GPOS_ChainContextPosFormat3_1::PosFormat
WORD PosFormat
Definition: opentype.c:597
GPOS_ChainContextPosFormat3_1::Coverage
WORD Coverage[1]
Definition: opentype.c:599
GPOS_ChainContextPosFormat3_1::BacktrackGlyphCount
WORD BacktrackGlyphCount
Definition: opentype.c:598
GPOS_ChainContextPosFormat3_2
Definition: opentype.c:602
GPOS_ChainContextPosFormat3_3
Definition: opentype.c:607
GPOS_ChainContextPosFormat3_3::Coverage
WORD Coverage[1]
Definition: opentype.c:609
GPOS_ChainContextPosFormat3_3::LookaheadGlyphCount
WORD LookaheadGlyphCount
Definition: opentype.c:608
GPOS_ChainContextPosFormat3_4
Definition: opentype.c:612
GPOS_ChainContextPosFormat3_4::PosCount
WORD PosCount
Definition: opentype.c:613
GPOS_ChainContextPosFormat3_4::PosLookupRecord
GPOS_PosLookupRecord PosLookupRecord[1]
Definition: opentype.c:614
GPOS_PosLookupRecord::LookupListIndex
WORD LookupListIndex
Definition: opentype.c:570
GPOS_PosLookupRecord::SequenceIndex
WORD SequenceIndex
Definition: opentype.c:569
OT_LookupTable::SubTableCount
WORD SubTableCount
Definition: opentype.c:195
tag_SCRIPT_ANALYSIS::fLogicalOrder
WORD fLogicalOrder
Definition: usp10.h:144
tag_SCRIPT_ANALYSIS::fRTL
WORD fRTL
Definition: usp10.h:140

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_ContextPos()

static unsigned int GPOS_apply_ContextPos ( const ScriptCache *  script_cache,
const OUTLINETEXTMETRICW *  otm,
const LOGFONTW *  logfont,
const SCRIPT_ANALYSIS *  analysis,
int *  advance,
const OT_LookupList *  lookup,
const OT_LookupTable *  look,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
GOFFSET *  goffset 
)
static

Definition at line 2142 of file opentype.c.

2146{
2147 int j;
2148 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
2149
2150 TRACE("Contextual Positioning Subtable\n");
2151
2152 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
2153 {
2154 const GPOS_ContextPosFormat2 *cpf2 = (GPOS_ContextPosFormat2*)GPOS_get_subtable(look, j);
2155
2156 if (GET_BE_WORD(cpf2->PosFormat) == 1)
2157 {
2158 static int once;
2159 if (!once++)
2160 FIXME(" TODO: subtype 1\n");
2161 continue;
2162 }
2163 else if (GET_BE_WORD(cpf2->PosFormat) == 2)
2164 {
2165 WORD offset = GET_BE_WORD(cpf2->Coverage);
2166 int index;
2167
2168 TRACE("Contextual Positioning Subtable: Format 2\n");
2169
2170 index = GSUB_is_glyph_covered((const BYTE*)cpf2+offset, glyphs[glyph_index]);
2171 TRACE("Coverage index %i\n",index);
2172 if (index != -1)
2173 {
2174 int k, count, class;
2175 const GPOS_PosClassSet *pcs;
2176 const void *glyph_class_table = NULL;
2177
2178 offset = GET_BE_WORD(cpf2->ClassDef);
2179 glyph_class_table = (const BYTE *)cpf2 + offset;
2180
2181 class = OT_get_glyph_class(glyph_class_table,glyphs[glyph_index]);
2182
2183 offset = GET_BE_WORD(cpf2->PosClassSet[class]);
2184 if (offset == 0)
2185 {
2186 TRACE("No class rule table for class %i\n",class);
2187 continue;
2188 }
2189 pcs = (const GPOS_PosClassSet*)((const BYTE*)cpf2+offset);
2190 count = GET_BE_WORD(pcs->PosClassRuleCnt);
2191 TRACE("PosClassSet has %i members\n",count);
2192 for (k = 0; k < count; k++)
2193 {
2194 const GPOS_PosClassRule_1 *pr;
2195 const GPOS_PosClassRule_2 *pr_2;
2196 unsigned int g;
2197 int g_count, l;
2198
2199 offset = GET_BE_WORD(pcs->PosClassRule[k]);
2200 pr = (const GPOS_PosClassRule_1*)((const BYTE*)pcs+offset);
2201 g_count = GET_BE_WORD(pr->GlyphCount);
2202 TRACE("PosClassRule has %i glyphs classes\n",g_count);
2203
2204 g = glyph_index + write_dir * (g_count - 1);
2205 if (g >= glyph_count)
2206 continue;
2207
2208 for (l = 0; l < g_count-1; l++)
2209 {
2210 int g_class = OT_get_glyph_class(glyph_class_table, glyphs[glyph_index + (write_dir * (l+1))]);
2211 if (g_class != GET_BE_WORD(pr->Class[l])) break;
2212 }
2213
2214 if (l < g_count-1)
2215 {
2216 TRACE("Rule does not match\n");
2217 continue;
2218 }
2219
2220 TRACE("Rule matches\n");
2221 pr_2 = (const GPOS_PosClassRule_2 *)&pr->Class[g_count - 1];
2222
2223 for (l = 0; l < GET_BE_WORD(pr->PosCount); l++)
2224 {
2225 unsigned int lookup_index = GET_BE_WORD(pr_2->PosLookupRecord[l].LookupListIndex);
2226 unsigned int sequence_index = GET_BE_WORD(pr_2->PosLookupRecord[l].SequenceIndex);
2227
2228 g = glyph_index + write_dir * sequence_index;
2229 if (g >= glyph_count)
2230 {
2231 WARN("Invalid sequence index %u (glyph index %u, write dir %d).\n",
2232 sequence_index, glyph_index, write_dir);
2233 continue;
2234 }
2235
2236 TRACE("Position: %u -> %u %u.\n", l, sequence_index, lookup_index);
2237
2238 GPOS_apply_lookup(script_cache, otm, logfont, analysis, advance,
2239 lookup, lookup_index, glyphs, g, glyph_count, goffset);
2240 }
2241 return 1;
2242 }
2243 }
2244
2245 TRACE("Not covered\n");
2246 continue;
2247 }
2248 else if (GET_BE_WORD(cpf2->PosFormat) == 3)
2249 {
2250 static int once;
2251 if (!once++)
2252 FIXME(" TODO: subtype 3\n");
2253 continue;
2254 }
2255 else
2256 FIXME("Unhandled Contextual Positioning Format %i\n",GET_BE_WORD(cpf2->PosFormat));
2257 }
2258 return 1;
2259}
index
#define index(s, c)
Definition: various.h:29
l
r l[0]
Definition: byte_order.h:168
NULL
#define NULL
Definition: types.h:112
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
index
GLuint index
Definition: glext.h:6031
OT_get_glyph_class
static WORD OT_get_glyph_class(const void *table, WORD glyph)
Definition: opentype.c:714
GPOS_ContextPosFormat2
Definition: opentype.c:573
GPOS_ContextPosFormat2::ClassDef
WORD ClassDef
Definition: opentype.c:576
GPOS_ContextPosFormat2::Coverage
WORD Coverage
Definition: opentype.c:575
GPOS_ContextPosFormat2::PosFormat
WORD PosFormat
Definition: opentype.c:574
GPOS_ContextPosFormat2::PosClassSet
WORD PosClassSet[1]
Definition: opentype.c:578
GPOS_PosClassRule_1
Definition: opentype.c:586
GPOS_PosClassRule_1::GlyphCount
WORD GlyphCount
Definition: opentype.c:587
GPOS_PosClassRule_1::PosCount
WORD PosCount
Definition: opentype.c:588
GPOS_PosClassRule_1::Class
WORD Class[1]
Definition: opentype.c:589
GPOS_PosClassRule_2
Definition: opentype.c:592
GPOS_PosClassRule_2::PosLookupRecord
GPOS_PosLookupRecord PosLookupRecord[1]
Definition: opentype.c:593
GPOS_PosClassSet
Definition: opentype.c:581
GPOS_PosClassSet::PosClassRuleCnt
WORD PosClassRuleCnt
Definition: opentype.c:582
GPOS_PosClassSet::PosClassRule
WORD PosClassRule[1]
Definition: opentype.c:583

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_CursiveAttachment()

static void GPOS_apply_CursiveAttachment ( const OT_LookupTable *  look,
const SCRIPT_ANALYSIS *  analysis,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
unsigned int  ppem,
POINT *  pt 
)
static

Definition at line 1858 of file opentype.c.

1860{
1861 int j;
1862 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
1863
1864 if (glyph_index + write_dir >= glyph_count)
1865 return;
1866
1867 TRACE("Cursive Attachment Positioning Subtable\n");
1868
1869 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1870 {
1871 const GPOS_CursivePosFormat1 *cpf1 = (const GPOS_CursivePosFormat1 *)GPOS_get_subtable(look, j);
1872 if (GET_BE_WORD(cpf1->PosFormat) == 1)
1873 {
1874 int index_exit, index_entry;
1875 WORD offset = GET_BE_WORD( cpf1->Coverage );
1876 index_exit = GSUB_is_glyph_covered((const BYTE*)cpf1+offset, glyphs[glyph_index]);
1877 if (index_exit != -1 && cpf1->EntryExitRecord[index_exit].ExitAnchor!= 0)
1878 {
1879 index_entry = GSUB_is_glyph_covered((const BYTE*)cpf1+offset, glyphs[glyph_index+write_dir]);
1880 if (index_entry != -1 && cpf1->EntryExitRecord[index_entry].EntryAnchor != 0)
1881 {
1882 POINT exit_pt, entry_pt;
1883 offset = GET_BE_WORD(cpf1->EntryExitRecord[index_exit].ExitAnchor);
1884 GPOS_get_anchor_values((const BYTE*)cpf1 + offset, &exit_pt, ppem);
1885 offset = GET_BE_WORD(cpf1->EntryExitRecord[index_entry].EntryAnchor);
1886 GPOS_get_anchor_values((const BYTE*)cpf1 + offset, &entry_pt, ppem);
1887 TRACE("Found linkage %x[%s] %x[%s]\n",glyphs[glyph_index], wine_dbgstr_point(&exit_pt), glyphs[glyph_index+write_dir], wine_dbgstr_point(&entry_pt));
1888 pt->x = entry_pt.x - exit_pt.x;
1889 pt->y = entry_pt.y - exit_pt.y;
1890 return;
1891 }
1892 }
1893 }
1894 else
1895 FIXME("Cursive Attachment Positioning: Format %i Unhandled\n",GET_BE_WORD(cpf1->PosFormat));
1896 }
1897 return;
1898}
pt
#define pt(x, y)
Definition: drawing.c:79
GPOS_get_anchor_values
static void GPOS_get_anchor_values(const void *table, POINT *pt, WORD ppem)
Definition: opentype.c:1584
GPOS_CursivePosFormat1
Definition: opentype.c:492
GPOS_CursivePosFormat1::Coverage
WORD Coverage
Definition: opentype.c:494
GPOS_CursivePosFormat1::PosFormat
WORD PosFormat
Definition: opentype.c:493
GPOS_CursivePosFormat1::EntryExitRecord
GPOS_EntryExitRecord EntryExitRecord[1]
Definition: opentype.c:496
GPOS_EntryExitRecord::ExitAnchor
WORD ExitAnchor
Definition: opentype.c:489
GPOS_EntryExitRecord::EntryAnchor
WORD EntryAnchor
Definition: opentype.c:488
tagPOINT::y
long y
Definition: polytest.cpp:48
tagPOINT::x
long x
Definition: polytest.cpp:48

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_lookup()

static unsigned int GPOS_apply_lookup ( const ScriptCache *  script_cache,
const OUTLINETEXTMETRICW *  otm,
const LOGFONTW *  logfont,
const SCRIPT_ANALYSIS *  analysis,
int *  advance,
const OT_LookupList *  lookup,
unsigned int  lookup_index,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
GOFFSET *  goffset 
)
static

Definition at line 2382 of file opentype.c.

2386{
2387 int offset;
2388 const OT_LookupTable *look;
2389 int ppem = lpotm->otmTextMetrics.tmAscent + lpotm->otmTextMetrics.tmDescent - lpotm->otmTextMetrics.tmInternalLeading;
2390 enum gpos_lookup_type type;
2391
2392 offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
2393 look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
2394 type = GET_BE_WORD(look->LookupType);
2395 TRACE("type %#x, flag %#x, subtables %u.\n", type,
2396 GET_BE_WORD(look->LookupFlag), GET_BE_WORD(look->SubTableCount));
2397
2398 if (type == GPOS_LOOKUP_POSITION_EXTENSION)
2399 {
2400 if (GET_BE_WORD(look->SubTableCount))
2401 {
2402 const GPOS_ExtensionPosFormat1 *ext = (const GPOS_ExtensionPosFormat1 *)((const BYTE *)look + GET_BE_WORD(look->SubTable[0]));
2403 if (GET_BE_WORD(ext->PosFormat) == 1)
2404 {
2405 type = GET_BE_WORD(ext->ExtensionLookupType);
2406 TRACE("extension type %i\n",type);
2407 }
2408 else
2409 {
2410 FIXME("Unhandled Extension Positioning Format %i\n",GET_BE_WORD(ext->PosFormat));
2411 }
2412 }
2413 else
2414 {
2415 WARN("lookup type is Extension Positioning but no extension subtable exists\n");
2416 }
2417 }
2418 switch (type)
2419 {
2420 case GPOS_LOOKUP_ADJUST_SINGLE:
2421 {
2422 double devX, devY;
2423 POINT adjust = {0,0};
2424 POINT advance = {0,0};
2425 GPOS_apply_SingleAdjustment(look, analysis, glyphs, glyph_index, glyph_count, ppem, &adjust, &advance);
2426 if (adjust.x || adjust.y)
2427 {
2428 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust.x, adjust.y, &devX, &devY);
2429 pGoffset[glyph_index].du += round(devX);
2430 pGoffset[glyph_index].dv += round(devY);
2431 }
2432 if (advance.x || advance.y)
2433 {
2434 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance.x, advance.y, &devX, &devY);
2435 piAdvance[glyph_index] += round(devX);
2436 if (advance.y)
2437 FIXME("Unhandled adjustment to Y advancement\n");
2438 }
2439 break;
2440 }
2441
2442 case GPOS_LOOKUP_ADJUST_PAIR:
2443 {
2444 POINT advance[2]= {{0,0},{0,0}};
2445 POINT adjust[2]= {{0,0},{0,0}};
2446 double devX, devY;
2447 int index_offset;
2448 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
2449 int offset_sign = (analysis->fRTL && analysis->fLogicalOrder) ? -1 : 1;
2450
2451 index_offset = GPOS_apply_PairAdjustment(look, analysis, glyphs,
2452 glyph_index, glyph_count, ppem, adjust, advance);
2453 if (adjust[0].x || adjust[0].y)
2454 {
2455 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust[0].x, adjust[0].y, &devX, &devY);
2456 pGoffset[glyph_index].du += round(devX) * offset_sign;
2457 pGoffset[glyph_index].dv += round(devY);
2458 }
2459 if (advance[0].x || advance[0].y)
2460 {
2461 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance[0].x, advance[0].y, &devX, &devY);
2462 piAdvance[glyph_index] += round(devX);
2463 }
2464 if (adjust[1].x || adjust[1].y)
2465 {
2466 GPOS_convert_design_units_to_device(lpotm, lplogfont, adjust[1].x, adjust[1].y, &devX, &devY);
2467 pGoffset[glyph_index + write_dir].du += round(devX) * offset_sign;
2468 pGoffset[glyph_index + write_dir].dv += round(devY);
2469 }
2470 if (advance[1].x || advance[1].y)
2471 {
2472 GPOS_convert_design_units_to_device(lpotm, lplogfont, advance[1].x, advance[1].y, &devX, &devY);
2473 piAdvance[glyph_index + write_dir] += round(devX);
2474 }
2475 return index_offset;
2476 }
2477
2478 case GPOS_LOOKUP_ATTACH_CURSIVE:
2479 {
2480 POINT desU = {0,0};
2481 double devX, devY;
2482 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
2483
2484 GPOS_apply_CursiveAttachment(look, analysis, glyphs, glyph_index, glyph_count, ppem, &desU);
2485 if (desU.x || desU.y)
2486 {
2487 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
2488 /* Windows does not appear to apply X offsets here */
2489 pGoffset[glyph_index].dv = round(devY) + pGoffset[glyph_index+write_dir].dv;
2490 }
2491 break;
2492 }
2493
2494 case GPOS_LOOKUP_ATTACH_MARK_TO_BASE:
2495 {
2496 double devX, devY;
2497 POINT desU = {0,0};
2498 int base_index = GPOS_apply_MarkToBase(script_cache, look, analysis,
2499 glyphs, glyph_index, glyph_count, ppem, &desU);
2500 if (base_index != -1)
2501 {
2502 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
2503 if (!analysis->fRTL) pGoffset[glyph_index].du = round(devX) - piAdvance[base_index];
2504 else
2505 {
2506 if (analysis->fLogicalOrder) devX *= -1;
2507 pGoffset[glyph_index].du = round(devX);
2508 }
2509 pGoffset[glyph_index].dv = round(devY);
2510 }
2511 break;
2512 }
2513
2514 case GPOS_LOOKUP_ATTACH_MARK_TO_LIGATURE:
2515 {
2516 double devX, devY;
2517 POINT desU = {0,0};
2518 GPOS_apply_MarkToLigature(look, analysis, glyphs, glyph_index, glyph_count, ppem, &desU);
2519 if (desU.x || desU.y)
2520 {
2521 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
2522 pGoffset[glyph_index].du = (round(devX) - piAdvance[glyph_index-1]);
2523 pGoffset[glyph_index].dv = round(devY);
2524 }
2525 break;
2526 }
2527
2528 case GPOS_LOOKUP_ATTACH_MARK_TO_MARK:
2529 {
2530 double devX, devY;
2531 POINT desU = {0,0};
2532 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
2533 if (GPOS_apply_MarkToMark(look, analysis, glyphs, glyph_index, glyph_count, ppem, &desU))
2534 {
2535 GPOS_convert_design_units_to_device(lpotm, lplogfont, desU.x, desU.y, &devX, &devY);
2536 if (analysis->fRTL && analysis->fLogicalOrder) devX *= -1;
2537 pGoffset[glyph_index].du = round(devX) + pGoffset[glyph_index - write_dir].du;
2538 pGoffset[glyph_index].dv = round(devY) + pGoffset[glyph_index - write_dir].dv;
2539 }
2540 break;
2541 }
2542
2543 case GPOS_LOOKUP_POSITION_CONTEXT:
2544 return GPOS_apply_ContextPos(script_cache, lpotm, lplogfont, analysis, piAdvance,
2545 lookup, look, glyphs, glyph_index, glyph_count, pGoffset);
2546
2547 case GPOS_LOOKUP_POSITION_CONTEXT_CHAINED:
2548 return GPOS_apply_ChainContextPos(script_cache, lpotm, lplogfont, analysis, piAdvance,
2549 lookup, look, glyphs, glyph_index, glyph_count, pGoffset);
2550
2551 default:
2552 FIXME("Unhandled GPOS lookup type %#x.\n", type);
2553 }
2554 return 1;
2555}
ext
static const WCHAR *const ext[]
Definition: module.c:53
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
y
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GPOS_apply_SingleAdjustment
static void GPOS_apply_SingleAdjustment(const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *adjust, POINT *advance)
Definition: opentype.c:1695
gpos_lookup_type
gpos_lookup_type
Definition: opentype.c:53
GPOS_apply_PairAdjustment
static int GPOS_apply_PairAdjustment(const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *adjust, POINT *advance)
Definition: opentype.c:1770
GPOS_apply_ChainContextPos
static unsigned int GPOS_apply_ChainContextPos(const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, const OT_LookupList *lookup, const OT_LookupTable *look, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
Definition: opentype.c:2261
GPOS_apply_CursiveAttachment
static void GPOS_apply_CursiveAttachment(const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
Definition: opentype.c:1858
round
#define round(x)
Definition: opentype.c:47
GPOS_apply_MarkToBase
static int GPOS_apply_MarkToBase(const ScriptCache *script_cache, const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
Definition: opentype.c:1900
GPOS_convert_design_units_to_device
static void GPOS_convert_design_units_to_device(const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, int desX, int desY, double *devX, double *devY)
Definition: opentype.c:1636
GPOS_apply_MarkToLigature
static void GPOS_apply_MarkToLigature(const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
Definition: opentype.c:1985
GPOS_apply_MarkToMark
static BOOL GPOS_apply_MarkToMark(const OT_LookupTable *look, const SCRIPT_ANALYSIS *analysis, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, unsigned int ppem, POINT *pt)
Definition: opentype.c:2075
GPOS_apply_ContextPos
static unsigned int GPOS_apply_ContextPos(const ScriptCache *script_cache, const OUTLINETEXTMETRICW *otm, const LOGFONTW *logfont, const SCRIPT_ANALYSIS *analysis, int *advance, const OT_LookupList *lookup, const OT_LookupTable *look, const WORD *glyphs, unsigned int glyph_index, unsigned int glyph_count, GOFFSET *goffset)
Definition: opentype.c:2142
GPOS_ExtensionPosFormat1
Definition: opentype.c:617
OT_LookupTable
Definition: opentype.c:192
OT_LookupTable::SubTable
WORD SubTable[1]
Definition: opentype.c:196
OT_LookupTable::LookupFlag
WORD LookupFlag
Definition: opentype.c:194
OT_LookupTable::LookupType
WORD LookupType
Definition: opentype.c:193

Referenced by GPOS_apply_ChainContextPos(), GPOS_apply_ContextPos(), and OpenType_apply_GPOS_lookup().

◆ GPOS_apply_MarkToBase()

static int GPOS_apply_MarkToBase ( const ScriptCache *  script_cache,
const OT_LookupTable *  look,
const SCRIPT_ANALYSIS *  analysis,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
unsigned int  ppem,
POINT *  pt 
)
static

Definition at line 1900 of file opentype.c.

1903{
1904 int j;
1905 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
1906 const void *glyph_class_table = NULL;
1907 int rc = -1;
1908
1909 if (script_cache->GDEF_Table)
1910 {
1911 const GDEF_Header *header = script_cache->GDEF_Table;
1912 WORD offset = GET_BE_WORD( header->GlyphClassDef );
1913 if (offset)
1914 glyph_class_table = (const BYTE *)script_cache->GDEF_Table + offset;
1915 }
1916
1917 TRACE("MarkToBase Attachment Positioning Subtable\n");
1918
1919 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1920 {
1921 const GPOS_MarkBasePosFormat1 *mbpf1 = (const GPOS_MarkBasePosFormat1 *)GPOS_get_subtable(look, j);
1922 if (GET_BE_WORD(mbpf1->PosFormat) == 1)
1923 {
1924 int offset = GET_BE_WORD(mbpf1->MarkCoverage);
1925 int mark_index;
1926 mark_index = GSUB_is_glyph_covered((const BYTE*)mbpf1+offset, glyphs[glyph_index]);
1927 if (mark_index != -1)
1928 {
1929 int base_index;
1930 int base_glyph = glyph_index - write_dir;
1931
1932 if (glyph_class_table)
1933 {
1934 while (OT_get_glyph_class(glyph_class_table, glyphs[base_glyph]) == MarkGlyph && base_glyph > 0 && base_glyph < glyph_count)
1935 base_glyph -= write_dir;
1936 }
1937
1938 offset = GET_BE_WORD(mbpf1->BaseCoverage);
1939 base_index = GSUB_is_glyph_covered((const BYTE*)mbpf1+offset, glyphs[base_glyph]);
1940 if (base_index != -1)
1941 {
1942 const GPOS_MarkArray *ma;
1943 const GPOS_MarkRecord *mr;
1944 const GPOS_BaseArray *ba;
1945 const GPOS_BaseRecord *br;
1946 int mark_class;
1947 int class_count = GET_BE_WORD(mbpf1->ClassCount);
1948 int baserecord_size;
1949 POINT base_pt;
1950 POINT mark_pt;
1951 TRACE("Mark %x(%i) and base %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[base_glyph], base_index);
1952 offset = GET_BE_WORD(mbpf1->MarkArray);
1953 ma = (const GPOS_MarkArray*)((const BYTE*)mbpf1 + offset);
1954 if (mark_index > GET_BE_WORD(ma->MarkCount))
1955 {
1956 ERR("Mark index exceeded mark count\n");
1957 return -1;
1958 }
1959 mr = &ma->MarkRecord[mark_index];
1960 mark_class = GET_BE_WORD(mr->Class);
1961 TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
1962 offset = GET_BE_WORD(mbpf1->BaseArray);
1963 ba = (const GPOS_BaseArray*)((const BYTE*)mbpf1 + offset);
1964 baserecord_size = class_count * sizeof(WORD);
1965 br = (const GPOS_BaseRecord*)((const BYTE*)ba + sizeof(WORD) + (baserecord_size * base_index));
1966 offset = GET_BE_WORD(br->BaseAnchor[mark_class]);
1967 GPOS_get_anchor_values((const BYTE*)ba + offset, &base_pt, ppem);
1968 offset = GET_BE_WORD(mr->MarkAnchor);
1969 GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
1970 TRACE("Offset on base is %s design units\n",wine_dbgstr_point(&base_pt));
1971 TRACE("Offset on mark is %s design units\n",wine_dbgstr_point(&mark_pt));
1972 pt->x += base_pt.x - mark_pt.x;
1973 pt->y += base_pt.y - mark_pt.y;
1974 TRACE("Resulting cumulative offset is %s design units\n",wine_dbgstr_point(pt));
1975 rc = base_glyph;
1976 }
1977 }
1978 }
1979 else
1980 FIXME("Unhandled Mark To Base Format %i\n",GET_BE_WORD(mbpf1->PosFormat));
1981 }
1982 return rc;
1983}
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
GDEF_Header
Definition: opentype.c:107
GPOS_BaseArray
Definition: opentype.c:512
GPOS_BaseRecord
Definition: opentype.c:508
GPOS_MarkArray
Definition: opentype.c:522
GPOS_MarkArray::MarkRecord
GPOS_MarkRecord MarkRecord[1]
Definition: opentype.c:524
GPOS_MarkArray::MarkCount
WORD MarkCount
Definition: opentype.c:523
GPOS_MarkBasePosFormat1
Definition: opentype.c:499
GPOS_MarkBasePosFormat1::BaseArray
WORD BaseArray
Definition: opentype.c:505
GPOS_MarkBasePosFormat1::PosFormat
WORD PosFormat
Definition: opentype.c:500
GPOS_MarkBasePosFormat1::MarkArray
WORD MarkArray
Definition: opentype.c:504
GPOS_MarkBasePosFormat1::ClassCount
WORD ClassCount
Definition: opentype.c:503
GPOS_MarkBasePosFormat1::MarkCoverage
WORD MarkCoverage
Definition: opentype.c:501
GPOS_MarkBasePosFormat1::BaseCoverage
WORD BaseCoverage
Definition: opentype.c:502
GPOS_MarkRecord
Definition: opentype.c:517
GPOS_MarkRecord::MarkAnchor
WORD MarkAnchor
Definition: opentype.c:519
GPOS_MarkRecord::Class
WORD Class
Definition: opentype.c:518
ScriptCache::GDEF_Table
void * GDEF_Table
Definition: usp10_internal.h:201

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_MarkToLigature()

static void GPOS_apply_MarkToLigature ( const OT_LookupTable *  look,
const SCRIPT_ANALYSIS *  analysis,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
unsigned int  ppem,
POINT *  pt 
)
static

Definition at line 1985 of file opentype.c.

1987{
1988 int j;
1989 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
1990
1991 TRACE("MarkToLigature Attachment Positioning Subtable\n");
1992
1993 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1994 {
1995 const GPOS_MarkLigPosFormat1 *mlpf1 = (const GPOS_MarkLigPosFormat1 *)GPOS_get_subtable(look, j);
1996 if (GET_BE_WORD(mlpf1->PosFormat) == 1)
1997 {
1998 int offset = GET_BE_WORD(mlpf1->MarkCoverage);
1999 int mark_index;
2000 mark_index = GSUB_is_glyph_covered((const BYTE*)mlpf1+offset, glyphs[glyph_index]);
2001 if (mark_index != -1)
2002 {
2003 int ligature_index;
2004 offset = GET_BE_WORD(mlpf1->LigatureCoverage);
2005 ligature_index = GSUB_is_glyph_covered((const BYTE*)mlpf1+offset, glyphs[glyph_index - write_dir]);
2006 if (ligature_index != -1)
2007 {
2008 const GPOS_MarkArray *ma;
2009 const GPOS_MarkRecord *mr;
2010
2011 const GPOS_LigatureArray *la;
2012 const GPOS_LigatureAttach *lt;
2013 int mark_class;
2014 int class_count = GET_BE_WORD(mlpf1->ClassCount);
2015 int component_count;
2016 int component_size;
2017 int i;
2018 POINT ligature_pt;
2019 POINT mark_pt;
2020
2021 TRACE("Mark %x(%i) and ligature %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[glyph_index - write_dir], ligature_index);
2022 offset = GET_BE_WORD(mlpf1->MarkArray);
2023 ma = (const GPOS_MarkArray*)((const BYTE*)mlpf1 + offset);
2024 if (mark_index > GET_BE_WORD(ma->MarkCount))
2025 {
2026 ERR("Mark index exceeded mark count\n");
2027 return;
2028 }
2029 mr = &ma->MarkRecord[mark_index];
2030 mark_class = GET_BE_WORD(mr->Class);
2031 TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
2032 offset = GET_BE_WORD(mlpf1->LigatureArray);
2033 la = (const GPOS_LigatureArray*)((const BYTE*)mlpf1 + offset);
2034 if (ligature_index > GET_BE_WORD(la->LigatureCount))
2035 {
2036 ERR("Ligature index exceeded ligature count\n");
2037 return;
2038 }
2039 offset = GET_BE_WORD(la->LigatureAttach[ligature_index]);
2040 lt = (const GPOS_LigatureAttach*)((const BYTE*)la + offset);
2041
2042 component_count = GET_BE_WORD(lt->ComponentCount);
2043 component_size = class_count * sizeof(WORD);
2044 offset = 0;
2045 for (i = 0; i < component_count && !offset; i++)
2046 {
2047 int k;
2048 const GPOS_ComponentRecord *cr = (const GPOS_ComponentRecord*)((const BYTE*)lt->ComponentRecord + (component_size * i));
2049 for (k = 0; k < class_count && !offset; k++)
2050 offset = GET_BE_WORD(cr->LigatureAnchor[k]);
2051 cr = (const GPOS_ComponentRecord*)((const BYTE*)cr + component_size);
2052 }
2053 if (!offset)
2054 {
2055 ERR("Failed to find available ligature connection point\n");
2056 return;
2057 }
2058
2059 GPOS_get_anchor_values((const BYTE*)lt + offset, &ligature_pt, ppem);
2060 offset = GET_BE_WORD(mr->MarkAnchor);
2061 GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
2062 TRACE("Offset on ligature is %s design units\n",wine_dbgstr_point(&ligature_pt));
2063 TRACE("Offset on mark is %s design units\n",wine_dbgstr_point(&mark_pt));
2064 pt->x += ligature_pt.x - mark_pt.x;
2065 pt->y += ligature_pt.y - mark_pt.y;
2066 TRACE("Resulting cumulative offset is %s design units\n",wine_dbgstr_point(pt));
2067 }
2068 }
2069 }
2070 else
2071 FIXME("Unhandled Mark To Ligature Format %i\n",GET_BE_WORD(mlpf1->PosFormat));
2072 }
2073}
component_count
unsigned int component_count
Definition: vertexdeclaration.c:30
component_size
unsigned int component_size
Definition: vertexdeclaration.c:31
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GPOS_ComponentRecord
Definition: opentype.c:541
GPOS_ComponentRecord::LigatureAnchor
WORD LigatureAnchor[1]
Definition: opentype.c:542
GPOS_LigatureArray
Definition: opentype.c:536
GPOS_LigatureArray::LigatureAttach
WORD LigatureAttach[1]
Definition: opentype.c:538
GPOS_LigatureArray::LigatureCount
WORD LigatureCount
Definition: opentype.c:537
GPOS_LigatureAttach
Definition: opentype.c:545
GPOS_LigatureAttach::ComponentRecord
GPOS_ComponentRecord ComponentRecord[1]
Definition: opentype.c:547
GPOS_LigatureAttach::ComponentCount
WORD ComponentCount
Definition: opentype.c:546
GPOS_MarkLigPosFormat1
Definition: opentype.c:527
GPOS_MarkLigPosFormat1::ClassCount
WORD ClassCount
Definition: opentype.c:531
GPOS_MarkLigPosFormat1::MarkArray
WORD MarkArray
Definition: opentype.c:532
GPOS_MarkLigPosFormat1::MarkCoverage
WORD MarkCoverage
Definition: opentype.c:529
GPOS_MarkLigPosFormat1::LigatureCoverage
WORD LigatureCoverage
Definition: opentype.c:530
GPOS_MarkLigPosFormat1::PosFormat
WORD PosFormat
Definition: opentype.c:528
GPOS_MarkLigPosFormat1::LigatureArray
WORD LigatureArray
Definition: opentype.c:533

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_MarkToMark()

static BOOL GPOS_apply_MarkToMark ( const OT_LookupTable *  look,
const SCRIPT_ANALYSIS *  analysis,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
unsigned int  ppem,
POINT *  pt 
)
static

Definition at line 2075 of file opentype.c.

2077{
2078 int j;
2079 BOOL rc = FALSE;
2080 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
2081
2082 TRACE("MarkToMark Attachment Positioning Subtable\n");
2083
2084 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
2085 {
2086 const GPOS_MarkMarkPosFormat1 *mmpf1 = (const GPOS_MarkMarkPosFormat1 *)GPOS_get_subtable(look, j);
2087 if (GET_BE_WORD(mmpf1->PosFormat) == 1)
2088 {
2089 int offset = GET_BE_WORD(mmpf1->Mark1Coverage);
2090 int mark_index;
2091 mark_index = GSUB_is_glyph_covered((const BYTE*)mmpf1+offset, glyphs[glyph_index]);
2092 if (mark_index != -1)
2093 {
2094 int mark2_index;
2095 offset = GET_BE_WORD(mmpf1->Mark2Coverage);
2096 mark2_index = GSUB_is_glyph_covered((const BYTE*)mmpf1+offset, glyphs[glyph_index - write_dir]);
2097 if (mark2_index != -1)
2098 {
2099 const GPOS_MarkArray *ma;
2100 const GPOS_MarkRecord *mr;
2101 const GPOS_Mark2Array *m2a;
2102 const GPOS_Mark2Record *m2r;
2103 int mark_class;
2104 int class_count = GET_BE_WORD(mmpf1->ClassCount);
2105 int mark2record_size;
2106 POINT mark2_pt;
2107 POINT mark_pt;
2108 TRACE("Mark %x(%i) and Mark2 %x(%i)\n",glyphs[glyph_index], mark_index, glyphs[glyph_index - write_dir], mark2_index);
2109 offset = GET_BE_WORD(mmpf1->Mark1Array);
2110 ma = (const GPOS_MarkArray*)((const BYTE*)mmpf1 + offset);
2111 if (mark_index > GET_BE_WORD(ma->MarkCount))
2112 {
2113 ERR("Mark index exceeded mark count\n");
2114 return FALSE;
2115 }
2116 mr = &ma->MarkRecord[mark_index];
2117 mark_class = GET_BE_WORD(mr->Class);
2118 TRACE("Mark Class %i total classes %i\n",mark_class,class_count);
2119 offset = GET_BE_WORD(mmpf1->Mark2Array);
2120 m2a = (const GPOS_Mark2Array*)((const BYTE*)mmpf1 + offset);
2121 mark2record_size = class_count * sizeof(WORD);
2122 m2r = (const GPOS_Mark2Record*)((const BYTE*)m2a + sizeof(WORD) + (mark2record_size * mark2_index));
2123 offset = GET_BE_WORD(m2r->Mark2Anchor[mark_class]);
2124 GPOS_get_anchor_values((const BYTE*)m2a + offset, &mark2_pt, ppem);
2125 offset = GET_BE_WORD(mr->MarkAnchor);
2126 GPOS_get_anchor_values((const BYTE*)ma + offset, &mark_pt, ppem);
2127 TRACE("Offset on mark2 is %s design units\n",wine_dbgstr_point(&mark2_pt));
2128 TRACE("Offset on mark is %s design units\n",wine_dbgstr_point(&mark_pt));
2129 pt->x += mark2_pt.x - mark_pt.x;
2130 pt->y += mark2_pt.y - mark_pt.y;
2131 TRACE("Resulting cumulative offset is %s design units\n",wine_dbgstr_point(pt));
2132 rc = TRUE;
2133 }
2134 }
2135 }
2136 else
2137 FIXME("Unhandled Mark To Mark Format %i\n",GET_BE_WORD(mmpf1->PosFormat));
2138 }
2139 return rc;
2140}
FALSE
#define FALSE
Definition: types.h:117
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
GPOS_Mark2Array
Definition: opentype.c:563
GPOS_Mark2Record
Definition: opentype.c:559
GPOS_MarkMarkPosFormat1
Definition: opentype.c:550
GPOS_MarkMarkPosFormat1::Mark1Array
WORD Mark1Array
Definition: opentype.c:555
GPOS_MarkMarkPosFormat1::ClassCount
WORD ClassCount
Definition: opentype.c:554
GPOS_MarkMarkPosFormat1::Mark1Coverage
WORD Mark1Coverage
Definition: opentype.c:552
GPOS_MarkMarkPosFormat1::Mark2Array
WORD Mark2Array
Definition: opentype.c:556
GPOS_MarkMarkPosFormat1::Mark2Coverage
WORD Mark2Coverage
Definition: opentype.c:553
GPOS_MarkMarkPosFormat1::PosFormat
WORD PosFormat
Definition: opentype.c:551

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_PairAdjustment()

static int GPOS_apply_PairAdjustment ( const OT_LookupTable *  look,
const SCRIPT_ANALYSIS *  analysis,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
unsigned int  ppem,
POINT *  adjust,
POINT *  advance 
)
static

Definition at line 1770 of file opentype.c.

1773{
1774 int j;
1775 int write_dir = (analysis->fRTL && !analysis->fLogicalOrder) ? -1 : 1;
1776
1777 if (glyph_index + write_dir >= glyph_count)
1778 return 1;
1779
1780 TRACE("Pair Adjustment Positioning Subtable\n");
1781
1782 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1783 {
1784 const GPOS_PairPosFormat1 *ppf1 = (const GPOS_PairPosFormat1*)GPOS_get_subtable(look, j);
1785 WORD offset;
1786 if (GET_BE_WORD(ppf1->PosFormat) == 1)
1787 {
1788 int index;
1789 WORD ValueFormat1 = GET_BE_WORD(ppf1->ValueFormat1);
1790 WORD ValueFormat2 = GET_BE_WORD(ppf1->ValueFormat2);
1791 INT val_fmt1_size = GPOS_get_value_record( ValueFormat1, NULL, NULL );
1792 INT val_fmt2_size = GPOS_get_value_record( ValueFormat2, NULL, NULL );
1793 offset = GET_BE_WORD(ppf1->Coverage);
1794 index = GSUB_is_glyph_covered((const BYTE*)ppf1+offset, glyphs[glyph_index]);
1795 if (index != -1 && index < GET_BE_WORD(ppf1->PairSetCount))
1796 {
1797 int k;
1798 int pair_count;
1799 const GPOS_PairSet *ps;
1800 const GPOS_PairValueRecord *pair_val_rec;
1801 offset = GET_BE_WORD(ppf1->PairSetOffset[index]);
1802 ps = (const GPOS_PairSet*)((const BYTE*)ppf1+offset);
1803 pair_count = GET_BE_WORD(ps->PairValueCount);
1804 pair_val_rec = ps->PairValueRecord;
1805 for (k = 0; k < pair_count; k++)
1806 {
1807 WORD second_glyph = GET_BE_WORD(pair_val_rec->SecondGlyph);
1808 if (glyphs[glyph_index+write_dir] == second_glyph)
1809 {
1810 int next = 1;
1811 TRACE("Format 1: Found Pair %x,%x\n",glyphs[glyph_index],glyphs[glyph_index+write_dir]);
1812 apply_pair_value(ppf1, ValueFormat1, ValueFormat2,
1813 pair_val_rec->Value1, ppem, adjust, advance);
1814 if (ValueFormat2) next++;
1815 return next;
1816 }
1817 pair_val_rec = (const GPOS_PairValueRecord *)(pair_val_rec->Value1 + val_fmt1_size + val_fmt2_size);
1818 }
1819 }
1820 }
1821 else if (GET_BE_WORD(ppf1->PosFormat) == 2)
1822 {
1823 const GPOS_PairPosFormat2 *ppf2 = (const GPOS_PairPosFormat2*)ppf1;
1824 int index;
1825 WORD ValueFormat1 = GET_BE_WORD( ppf2->ValueFormat1 );
1826 WORD ValueFormat2 = GET_BE_WORD( ppf2->ValueFormat2 );
1827 INT val_fmt1_size = GPOS_get_value_record( ValueFormat1, NULL, NULL );
1828 INT val_fmt2_size = GPOS_get_value_record( ValueFormat2, NULL, NULL );
1829 WORD class1_count = GET_BE_WORD( ppf2->Class1Count );
1830 WORD class2_count = GET_BE_WORD( ppf2->Class2Count );
1831
1832 offset = GET_BE_WORD( ppf2->Coverage );
1833 index = GSUB_is_glyph_covered( (const BYTE*)ppf2 + offset, glyphs[glyph_index] );
1834 if (index != -1)
1835 {
1836 WORD class1, class2;
1837 class1 = OT_get_glyph_class( (const BYTE *)ppf2 + GET_BE_WORD(ppf2->ClassDef1), glyphs[glyph_index] );
1838 class2 = OT_get_glyph_class( (const BYTE *)ppf2 + GET_BE_WORD(ppf2->ClassDef2), glyphs[glyph_index + write_dir] );
1839 if (class1 < class1_count && class2 < class2_count)
1840 {
1841 const WORD *pair_val = ppf2->Class1Record + (class1 * class2_count + class2) * (val_fmt1_size + val_fmt2_size);
1842 int next = 1;
1843
1844 TRACE( "Format 2: Found Pair %x,%x\n", glyphs[glyph_index], glyphs[glyph_index + write_dir] );
1845
1846 apply_pair_value(ppf2, ValueFormat1, ValueFormat2, pair_val, ppem, adjust, advance);
1847 if (ValueFormat2) next++;
1848 return next;
1849 }
1850 }
1851 }
1852 else
1853 FIXME("Pair Adjustment Positioning: Format %i Unhandled\n",GET_BE_WORD(ppf1->PosFormat));
1854 }
1855 return 1;
1856}
apply_pair_value
static void apply_pair_value(const void *pos_table, WORD val_fmt1, WORD val_fmt2, const WORD *pair, INT ppem, POINT *adjust, POINT *advance)
Definition: opentype.c:1746
next
static unsigned __int64 next
Definition: rand_nt.c:6
GPOS_PairPosFormat1
Definition: opentype.c:455
GPOS_PairPosFormat1::ValueFormat1
WORD ValueFormat1
Definition: opentype.c:458
GPOS_PairPosFormat1::Coverage
WORD Coverage
Definition: opentype.c:457
GPOS_PairPosFormat1::ValueFormat2
WORD ValueFormat2
Definition: opentype.c:459
GPOS_PairPosFormat1::PairSetOffset
WORD PairSetOffset[1]
Definition: opentype.c:461
GPOS_PairPosFormat1::PairSetCount
WORD PairSetCount
Definition: opentype.c:460
GPOS_PairPosFormat1::PosFormat
WORD PosFormat
Definition: opentype.c:456
GPOS_PairPosFormat2
Definition: opentype.c:464
GPOS_PairPosFormat2::Class2Count
WORD Class2Count
Definition: opentype.c:472
GPOS_PairPosFormat2::Coverage
WORD Coverage
Definition: opentype.c:466
GPOS_PairPosFormat2::Class1Record
WORD Class1Record[1]
Definition: opentype.c:473
GPOS_PairPosFormat2::Class1Count
WORD Class1Count
Definition: opentype.c:471
GPOS_PairPosFormat2::ClassDef1
WORD ClassDef1
Definition: opentype.c:469
GPOS_PairPosFormat2::ValueFormat2
WORD ValueFormat2
Definition: opentype.c:468
GPOS_PairPosFormat2::ClassDef2
WORD ClassDef2
Definition: opentype.c:470
GPOS_PairPosFormat2::ValueFormat1
WORD ValueFormat1
Definition: opentype.c:467
GPOS_PairSet
Definition: opentype.c:482
GPOS_PairSet::PairValueCount
WORD PairValueCount
Definition: opentype.c:483
GPOS_PairSet::PairValueRecord
GPOS_PairValueRecord PairValueRecord[1]
Definition: opentype.c:484
GPOS_PairValueRecord
Definition: opentype.c:476
GPOS_PairValueRecord::SecondGlyph
WORD SecondGlyph
Definition: opentype.c:477
GPOS_PairValueRecord::Value1
WORD Value1[1]
Definition: opentype.c:478

Referenced by GPOS_apply_lookup().

◆ GPOS_apply_SingleAdjustment()

static void GPOS_apply_SingleAdjustment ( const OT_LookupTable *  look,
const SCRIPT_ANALYSIS *  analysis,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
unsigned int  ppem,
POINT *  adjust,
POINT *  advance 
)
static

Definition at line 1695 of file opentype.c.

1698{
1699 int j;
1700
1701 TRACE("Single Adjustment Positioning Subtable\n");
1702
1703 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1704 {
1705 const GPOS_SinglePosFormat1 *spf1 = (const GPOS_SinglePosFormat1*)GPOS_get_subtable(look, j);
1706 WORD offset;
1707 if (GET_BE_WORD(spf1->PosFormat) == 1)
1708 {
1709 offset = GET_BE_WORD(spf1->Coverage);
1710 if (GSUB_is_glyph_covered((const BYTE*)spf1+offset, glyphs[glyph_index]) != -1)
1711 {
1712 GPOS_ValueRecord ValueRecord = {0,0,0,0,0,0,0,0};
1713 WORD ValueFormat = GET_BE_WORD(spf1->ValueFormat);
1714 GPOS_get_value_record(ValueFormat, spf1->Value, &ValueRecord);
1715 GPOS_get_value_record_offsets((const BYTE *)spf1, &ValueRecord, ValueFormat, ppem, adjust, advance);
1716 TRACE("Glyph Adjusted by %i,%i\n",ValueRecord.XPlacement,ValueRecord.YPlacement);
1717 }
1718 }
1719 else if (GET_BE_WORD(spf1->PosFormat) == 2)
1720 {
1721 int index;
1722 const GPOS_SinglePosFormat2 *spf2;
1723 spf2 = (const GPOS_SinglePosFormat2*)spf1;
1724 offset = GET_BE_WORD(spf2->Coverage);
1725 index = GSUB_is_glyph_covered((const BYTE*)spf2+offset, glyphs[glyph_index]);
1726 if (index != -1)
1727 {
1728 int size;
1729 GPOS_ValueRecord ValueRecord = {0,0,0,0,0,0,0,0};
1730 WORD ValueFormat = GET_BE_WORD(spf2->ValueFormat);
1731 size = GPOS_get_value_record(ValueFormat, spf2->Value, &ValueRecord);
1732 if (index > 0)
1733 {
1734 offset = size * index;
1735 GPOS_get_value_record(ValueFormat, &spf2->Value[offset], &ValueRecord);
1736 }
1737 GPOS_get_value_record_offsets((const BYTE *)spf2, &ValueRecord, ValueFormat, ppem, adjust, advance);
1738 TRACE("Glyph Adjusted by %i,%i\n",ValueRecord.XPlacement,ValueRecord.YPlacement);
1739 }
1740 }
1741 else
1742 FIXME("Single Adjustment Positioning: Format %i Unhandled\n",GET_BE_WORD(spf1->PosFormat));
1743 }
1744}
GPOS_SinglePosFormat1
Definition: opentype.c:440
GPOS_SinglePosFormat1::Coverage
WORD Coverage
Definition: opentype.c:442
GPOS_SinglePosFormat1::PosFormat
WORD PosFormat
Definition: opentype.c:441
GPOS_SinglePosFormat1::ValueFormat
WORD ValueFormat
Definition: opentype.c:443
GPOS_SinglePosFormat1::Value
WORD Value[1]
Definition: opentype.c:444
GPOS_SinglePosFormat2
Definition: opentype.c:447
GPOS_SinglePosFormat2::Value
WORD Value[1]
Definition: opentype.c:452
GPOS_SinglePosFormat2::Coverage
WORD Coverage
Definition: opentype.c:449
GPOS_SinglePosFormat2::ValueFormat
WORD ValueFormat
Definition: opentype.c:450
GPOS_ValueRecord::YPlacement
WORD YPlacement
Definition: opentype.c:431
GPOS_ValueRecord::XPlacement
WORD XPlacement
Definition: opentype.c:430

Referenced by GPOS_apply_lookup().

◆ GPOS_convert_design_units_to_device()

static void GPOS_convert_design_units_to_device ( const OUTLINETEXTMETRICW *  otm,
const LOGFONTW *  logfont,
int  desX,
int  desY,
double *  devX,
double *  devY 
)
static

Definition at line 1636 of file opentype.c.

1638{
1639 int emHeight = otm->otmTextMetrics.tmAscent + otm->otmTextMetrics.tmDescent - otm->otmTextMetrics.tmInternalLeading;
1640
1641 TRACE("emHeight %i lfWidth %i\n",emHeight, logfont->lfWidth);
1642 *devX = (desX * emHeight) / (double)otm->otmEMSquare;
1643 *devY = (desY * emHeight) / (double)otm->otmEMSquare;
1644 if (logfont->lfWidth)
1645 FIXME("Font with lfWidth set not handled properly.\n");
1646}
LOGFONTW::lfWidth
LONG lfWidth
Definition: dimm.idl:60
_OUTLINETEXTMETRICW::otmEMSquare
UINT otmEMSquare
Definition: wingdi.h:2968
_OUTLINETEXTMETRICW::otmTextMetrics
TEXTMETRICW otmTextMetrics
Definition: wingdi.h:2960
tagTEXTMETRICW::tmAscent
LONG tmAscent
Definition: wingdi.h:2830
tagTEXTMETRICW::tmInternalLeading
LONG tmInternalLeading
Definition: wingdi.h:2832
tagTEXTMETRICW::tmDescent
LONG tmDescent
Definition: wingdi.h:2831

Referenced by GPOS_apply_lookup().

◆ GPOS_get_anchor_values()

static void GPOS_get_anchor_values ( const void *  table,
POINT *  pt,
WORD  ppem 
)
static

Definition at line 1584 of file opentype.c.

1585{
1586 const GPOS_AnchorFormat1* anchor1 = (const GPOS_AnchorFormat1*)table;
1587
1588 switch (GET_BE_WORD(anchor1->AnchorFormat))
1589 {
1590 case 1:
1591 {
1592 TRACE("Anchor Format 1\n");
1593 pt->x = (short)GET_BE_WORD(anchor1->XCoordinate);
1594 pt->y = (short)GET_BE_WORD(anchor1->YCoordinate);
1595 break;
1596 }
1597 case 2:
1598 {
1599 const GPOS_AnchorFormat2* anchor2 = (const GPOS_AnchorFormat2*)table;
1600 TRACE("Anchor Format 2\n");
1601 pt->x = (short)GET_BE_WORD(anchor2->XCoordinate);
1602 pt->y = (short)GET_BE_WORD(anchor2->YCoordinate);
1603 break;
1604 }
1605 case 3:
1606 {
1607 int offset;
1608 const GPOS_AnchorFormat3* anchor3 = (const GPOS_AnchorFormat3*)table;
1609 TRACE("Anchor Format 3\n");
1610 pt->x = (short)GET_BE_WORD(anchor3->XCoordinate);
1611 pt->y = (short)GET_BE_WORD(anchor3->YCoordinate);
1612 offset = GET_BE_WORD(anchor3->XDeviceTable);
1613 TRACE("ppem %i\n",ppem);
1614 if (offset)
1615 {
1616 const OT_DeviceTable* DeviceTableX = NULL;
1617 DeviceTableX = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
1618 pt->x += GPOS_get_device_table_value(DeviceTableX, ppem);
1619 }
1620 offset = GET_BE_WORD(anchor3->YDeviceTable);
1621 if (offset)
1622 {
1623 const OT_DeviceTable* DeviceTableY = NULL;
1624 DeviceTableY = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
1625 pt->y += GPOS_get_device_table_value(DeviceTableY, ppem);
1626 }
1627 break;
1628 }
1629 default:
1630 ERR("Unknown Anchor Format %i\n",GET_BE_WORD(anchor1->AnchorFormat));
1631 pt->x = 0;
1632 pt->y = 0;
1633 }
1634}
short
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
GPOS_get_device_table_value
static INT GPOS_get_device_table_value(const OT_DeviceTable *DeviceTable, WORD ppem)
Definition: opentype.c:1557
GPOS_AnchorFormat1
Definition: opentype.c:408
GPOS_AnchorFormat1::YCoordinate
WORD YCoordinate
Definition: opentype.c:411
GPOS_AnchorFormat1::AnchorFormat
WORD AnchorFormat
Definition: opentype.c:409
GPOS_AnchorFormat1::XCoordinate
WORD XCoordinate
Definition: opentype.c:410
GPOS_AnchorFormat2
Definition: opentype.c:414
GPOS_AnchorFormat2::XCoordinate
WORD XCoordinate
Definition: opentype.c:416
GPOS_AnchorFormat2::YCoordinate
WORD YCoordinate
Definition: opentype.c:417
GPOS_AnchorFormat3
Definition: opentype.c:421
GPOS_AnchorFormat3::YDeviceTable
WORD YDeviceTable
Definition: opentype.c:426
GPOS_AnchorFormat3::XCoordinate
WORD XCoordinate
Definition: opentype.c:423
GPOS_AnchorFormat3::YCoordinate
WORD YCoordinate
Definition: opentype.c:424
GPOS_AnchorFormat3::XDeviceTable
WORD XDeviceTable
Definition: opentype.c:425
OT_DeviceTable
Definition: opentype.c:401

Referenced by GPOS_apply_CursiveAttachment(), GPOS_apply_MarkToBase(), GPOS_apply_MarkToLigature(), and GPOS_apply_MarkToMark().

◆ GPOS_get_device_table_value()

static INT GPOS_get_device_table_value ( const OT_DeviceTable *  DeviceTable,
WORD  ppem 
)
static

Definition at line 1557 of file opentype.c.

1558{
1559 static const WORD mask[3] = {3,0xf,0xff};
1560 if (DeviceTable && ppem >= GET_BE_WORD(DeviceTable->StartSize) && ppem <= GET_BE_WORD(DeviceTable->EndSize))
1561 {
1562 WORD format = GET_BE_WORD(DeviceTable->DeltaFormat);
1563 int index = ppem - GET_BE_WORD(DeviceTable->StartSize);
1564 int value;
1565
1566 TRACE("device table, format %#x, index %i\n", format, index);
1567
1568 if (format < 1 || format > 3)
1569 {
1570 WARN("invalid delta format %#x\n", format);
1571 return 0;
1572 }
1573
1574 index = index << format;
1575 value = (DeviceTable->DeltaValue[index/sizeof(WORD)] << (index%sizeof(WORD)))&mask[format-1];
1576 TRACE("offset %i, value %i\n",index, value);
1577 if (value > mask[format-1]/2)
1578 value = -1 * ((mask[format-1]+1) - value);
1579 return value;
1580 }
1581 return 0;
1582}
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
OT_DeviceTable::DeltaValue
WORD DeltaValue[1]
Definition: opentype.c:405
OT_DeviceTable::DeltaFormat
WORD DeltaFormat
Definition: opentype.c:404
OT_DeviceTable::StartSize
WORD StartSize
Definition: opentype.c:402
OT_DeviceTable::EndSize
WORD EndSize
Definition: opentype.c:403
format
Definition: format.c:58
value
Definition: pdh_main.c:96

Referenced by GPOS_get_anchor_values(), and GPOS_get_value_record_offsets().

◆ GPOS_get_subtable()

static const BYTE * GPOS_get_subtable ( const OT_LookupTable *  look,
int  index 
)
static

Definition at line 1676 of file opentype.c.

1677{
1678 int offset = GET_BE_WORD(look->SubTable[index]);
1679
1680 if (GET_BE_WORD(look->LookupType) == GPOS_LOOKUP_POSITION_EXTENSION)
1681 {
1682 const GPOS_ExtensionPosFormat1 *ext = (const GPOS_ExtensionPosFormat1 *)((const BYTE *)look + offset);
1683 if (GET_BE_WORD(ext->PosFormat) == 1)
1684 {
1685 offset += GET_BE_DWORD(ext->ExtensionOffset);
1686 }
1687 else
1688 {
1689 FIXME("Unhandled Extension Positioning Format %i\n",GET_BE_WORD(ext->PosFormat));
1690 }
1691 }
1692 return (const BYTE *)look + offset;
1693}

Referenced by GPOS_apply_ChainContextPos(), GPOS_apply_ContextPos(), GPOS_apply_CursiveAttachment(), GPOS_apply_MarkToBase(), GPOS_apply_MarkToLigature(), GPOS_apply_MarkToMark(), GPOS_apply_PairAdjustment(), and GPOS_apply_SingleAdjustment().

◆ GPOS_get_value_record()

static INT GPOS_get_value_record ( WORD  ValueFormat,
const WORD  data[],
GPOS_ValueRecord *  record 
)
static

Definition at line 1648 of file opentype.c.

1649{
1650 INT offset = 0;
1651 if (ValueFormat & 0x0001) { if (data) record->XPlacement = GET_BE_WORD(data[offset]); offset++; }
1652 if (ValueFormat & 0x0002) { if (data) record->YPlacement = GET_BE_WORD(data[offset]); offset++; }
1653 if (ValueFormat & 0x0004) { if (data) record->XAdvance = GET_BE_WORD(data[offset]); offset++; }
1654 if (ValueFormat & 0x0008) { if (data) record->YAdvance = GET_BE_WORD(data[offset]); offset++; }
1655 if (ValueFormat & 0x0010) { if (data) record->XPlaDevice = GET_BE_WORD(data[offset]); offset++; }
1656 if (ValueFormat & 0x0020) { if (data) record->YPlaDevice = GET_BE_WORD(data[offset]); offset++; }
1657 if (ValueFormat & 0x0040) { if (data) record->XAdvDevice = GET_BE_WORD(data[offset]); offset++; }
1658 if (ValueFormat & 0x0080) { if (data) record->YAdvDevice = GET_BE_WORD(data[offset]); offset++; }
1659 return offset;
1660}
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950

Referenced by apply_pair_value(), GPOS_apply_PairAdjustment(), and GPOS_apply_SingleAdjustment().

◆ GPOS_get_value_record_offsets()

static void GPOS_get_value_record_offsets ( const BYTE *  head,
GPOS_ValueRecord *  ValueRecord,
WORD  ValueFormat,
unsigned int  ppem,
POINT *  ptPlacement,
POINT *  ptAdvance 
)
static

Definition at line 1662 of file opentype.c.

1664{
1665 if (ValueFormat & 0x0001) ptPlacement->x += (short)ValueRecord->XPlacement;
1666 if (ValueFormat & 0x0002) ptPlacement->y += (short)ValueRecord->YPlacement;
1667 if (ValueFormat & 0x0004) ptAdvance->x += (short)ValueRecord->XAdvance;
1668 if (ValueFormat & 0x0008) ptAdvance->y += (short)ValueRecord->YAdvance;
1669 if (ValueFormat & 0x0010) ptPlacement->x += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->XPlaDevice), ppem);
1670 if (ValueFormat & 0x0020) ptPlacement->y += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->YPlaDevice), ppem);
1671 if (ValueFormat & 0x0040) ptAdvance->x += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->XAdvDevice), ppem);
1672 if (ValueFormat & 0x0080) ptAdvance->y += GPOS_get_device_table_value((const OT_DeviceTable*)(head + ValueRecord->YAdvDevice), ppem);
1673 if (ValueFormat & 0xFF00) FIXME("Unhandled Value Format %x\n",ValueFormat&0xFF00);
1674}
head
struct outqueuenode * head
Definition: adnsresfilter.c:66
if
if(dx< 0)
Definition: linetemp.h:194
GPOS_ValueRecord::YAdvDevice
WORD YAdvDevice
Definition: opentype.c:437
GPOS_ValueRecord::YAdvance
WORD YAdvance
Definition: opentype.c:433
GPOS_ValueRecord::XAdvDevice
WORD XAdvDevice
Definition: opentype.c:436
GPOS_ValueRecord::XPlaDevice
WORD XPlaDevice
Definition: opentype.c:434
GPOS_ValueRecord::YPlaDevice
WORD YPlaDevice
Definition: opentype.c:435
GPOS_ValueRecord::XAdvance
WORD XAdvance
Definition: opentype.c:432

Referenced by apply_pair_value(), and GPOS_apply_SingleAdjustment().

◆ GSUB_apply_AlternateSubst()

static INT GSUB_apply_AlternateSubst ( const OT_LookupTable *  look,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 978 of file opentype.c.

979{
980 int j;
981 TRACE("Alternate Substitution Subtable\n");
982
983 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
984 {
985 int offset;
986 const GSUB_AlternateSubstFormat1 *asf1;
987 INT index;
988
989 asf1 = (const GSUB_AlternateSubstFormat1*)GSUB_get_subtable(look, j);
990 offset = GET_BE_WORD(asf1->Coverage);
991
992 index = GSUB_is_glyph_covered((const BYTE*)asf1+offset, glyphs[glyph_index]);
993 if (index != -1)
994 {
995 const GSUB_AlternateSet *as;
996 offset = GET_BE_WORD(asf1->AlternateSet[index]);
997 as = (const GSUB_AlternateSet*)((const BYTE*)asf1+offset);
998 FIXME("%i alternates, picking index 0\n",GET_BE_WORD(as->GlyphCount));
999 if (glyphs[glyph_index] == GET_BE_WORD(as->Alternate[0]))
1000 return GSUB_E_NOGLYPH;
1001
1002 TRACE(" Glyph 0x%x ->",glyphs[glyph_index]);
1003 glyphs[glyph_index] = GET_BE_WORD(as->Alternate[0]);
1004 TRACE(" 0x%x\n",glyphs[glyph_index]);
1005 return glyph_index + write_dir;
1006 }
1007 }
1008 return GSUB_E_NOGLYPH;
1009}
GSUB_get_subtable
static const BYTE * GSUB_get_subtable(const OT_LookupTable *look, int index)
Definition: opentype.c:863
GSUB_AlternateSet
Definition: opentype.c:381
GSUB_AlternateSet::Alternate
WORD Alternate[1]
Definition: opentype.c:383
GSUB_AlternateSet::GlyphCount
WORD GlyphCount
Definition: opentype.c:382
GSUB_AlternateSubstFormat1
Definition: opentype.c:374
GSUB_AlternateSubstFormat1::Coverage
WORD Coverage
Definition: opentype.c:376
GSUB_AlternateSubstFormat1::AlternateSet
WORD AlternateSet[1]
Definition: opentype.c:378
GSUB_E_NOGLYPH
#define GSUB_E_NOGLYPH
Definition: usp10_internal.h:139

Referenced by GSUB_apply_lookup().

◆ GSUB_apply_ChainContextSubst()

static INT GSUB_apply_ChainContextSubst ( const OT_LookupList *  lookup,
const OT_LookupTable *  look,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 1245 of file opentype.c.

1246{
1247 int j;
1248
1249 TRACE("Chaining Contextual Substitution Subtable\n");
1250 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1251 {
1252 const GSUB_ChainContextSubstFormat1 *ccsf1;
1253 int offset;
1254 int dirLookahead = write_dir;
1255 int dirBacktrack = -1 * write_dir;
1256
1257 ccsf1 = (const GSUB_ChainContextSubstFormat1*)GSUB_get_subtable(look, j);
1258 if (GET_BE_WORD(ccsf1->SubstFormat) == 1)
1259 {
1260 static int once;
1261 if (!once++)
1262 FIXME(" TODO: subtype 1 (Simple context glyph substitution)\n");
1263 continue;
1264 }
1265 else if (GET_BE_WORD(ccsf1->SubstFormat) == 2)
1266 {
1267 WORD offset, count;
1268 const void *backtrack_class_table;
1269 const void *input_class_table;
1270 const void *lookahead_class_table;
1271 int i;
1272 WORD class;
1273
1274 const GSUB_ChainContextSubstFormat2 *ccsf2 = (const GSUB_ChainContextSubstFormat2*)ccsf1;
1275 const GSUB_ChainSubClassSet *csc;
1276
1277 TRACE(" subtype 2 (Class-based Chaining Context Glyph Substitution)\n");
1278
1279 offset = GET_BE_WORD(ccsf2->Coverage);
1280
1281 if (GSUB_is_glyph_covered((const BYTE*)ccsf2+offset, glyphs[glyph_index]) == -1)
1282 {
1283 TRACE("Glyph not covered\n");
1284 continue;
1285 }
1286 offset = GET_BE_WORD(ccsf2->BacktrackClassDef);
1287 backtrack_class_table = (const BYTE*)ccsf2+offset;
1288 offset = GET_BE_WORD(ccsf2->InputClassDef);
1289 input_class_table = (const BYTE*)ccsf2+offset;
1290 offset = GET_BE_WORD(ccsf2->LookaheadClassDef);
1291 lookahead_class_table = (const BYTE*)ccsf2+offset;
1292 count = GET_BE_WORD(ccsf2->ChainSubClassSetCnt);
1293
1294 class = OT_get_glyph_class(input_class_table, glyphs[glyph_index]);
1295 offset = GET_BE_WORD(ccsf2->ChainSubClassSet[class]);
1296
1297 if (offset == 0)
1298 {
1299 TRACE("No rules for class\n");
1300 continue;
1301 }
1302
1303 csc = (const GSUB_ChainSubClassSet*)((BYTE*)ccsf2+offset);
1304 count = GET_BE_WORD(csc->ChainSubClassRuleCnt);
1305
1306 TRACE("%i rules to check\n",count);
1307
1308 for (i = 0; i < count; i++)
1309 {
1310 WORD backtrack_count, input_count, lookahead_count, substitute_count;
1311 int k;
1312 const GSUB_ChainSubClassRule_1 *backtrack;
1313 const GSUB_ChainSubClassRule_2 *input;
1314 const GSUB_ChainSubClassRule_3 *lookahead;
1315 const GSUB_ChainSubClassRule_4 *substitute;
1316 int new_index = GSUB_E_NOGLYPH;
1317
1318 offset = GET_BE_WORD(csc->ChainSubClassRule[i]);
1319 backtrack = (const GSUB_ChainSubClassRule_1 *)((BYTE *)csc + offset);
1320 backtrack_count = GET_BE_WORD(backtrack->BacktrackGlyphCount);
1321 k = glyph_index + dirBacktrack * backtrack_count;
1322 if (k < 0 || k >= *glyph_count)
1323 continue;
1324
1325 input = (const GSUB_ChainSubClassRule_2 *)&backtrack->Backtrack[backtrack_count];
1326 input_count = GET_BE_WORD(input->InputGlyphCount) - 1;
1327 k = glyph_index + write_dir * input_count;
1328 if (k < 0 || k >= *glyph_count)
1329 continue;
1330
1331 lookahead = (const GSUB_ChainSubClassRule_3 *)&input->Input[input_count];
1332 lookahead_count = GET_BE_WORD(lookahead->LookaheadGlyphCount);
1333 k = glyph_index + dirLookahead * (input_count + lookahead_count);
1334 if (k < 0 || k >= *glyph_count)
1335 continue;
1336
1337 substitute = (const GSUB_ChainSubClassRule_4 *)&lookahead->LookAhead[lookahead_count];
1338
1339 for (k = 0; k < backtrack_count; ++k)
1340 {
1341 WORD target_class = GET_BE_WORD(backtrack->Backtrack[k]);
1342 WORD glyph_class = OT_get_glyph_class(backtrack_class_table, glyphs[glyph_index + (dirBacktrack * (k+1))]);
1343 if (target_class != glyph_class)
1344 break;
1345 }
1346 if (k != backtrack_count)
1347 continue;
1348 TRACE("Matched Backtrack\n");
1349
1350 for (k = 0; k < input_count; ++k)
1351 {
1352 WORD target_class = GET_BE_WORD(input->Input[k]);
1353 WORD glyph_class = OT_get_glyph_class(input_class_table, glyphs[glyph_index + (write_dir * (k+1))]);
1354 if (target_class != glyph_class)
1355 break;
1356 }
1357 if (k != input_count)
1358 continue;
1359 TRACE("Matched IndexGlyphs\n");
1360
1361 for (k = 0; k < lookahead_count; ++k)
1362 {
1363 WORD target_class = GET_BE_WORD(lookahead->LookAhead[k]);
1364 WORD glyph_class = OT_get_glyph_class(lookahead_class_table,
1365 glyphs[glyph_index + (dirLookahead * (input_count + k + 1))]);
1366 if (target_class != glyph_class)
1367 break;
1368 }
1369 if (k != lookahead_count)
1370 continue;
1371 TRACE("Matched LookAhead\n");
1372
1373 substitute_count = GET_BE_WORD(substitute->SubstCount);
1374 for (k = 0; k < substitute_count; ++k)
1375 {
1376 unsigned int lookup_index = GET_BE_WORD(substitute->SubstLookupRecord[k].LookupListIndex);
1377 unsigned int sequence_index = GET_BE_WORD(substitute->SubstLookupRecord[k].SequenceIndex);
1378 unsigned int g = glyph_index + write_dir * sequence_index;
1379
1380 if (g >= *glyph_count)
1381 {
1382 WARN("Skipping invalid sequence index %u (glyph index %u, write dir %d).\n",
1383 sequence_index, glyph_index, write_dir);
1384 continue;
1385 }
1386
1387 TRACE("SUBST: %u -> %u %u.\n", k, sequence_index, lookup_index);
1388 new_index = GSUB_apply_lookup(lookup, lookup_index, glyphs, g, write_dir, glyph_count);
1389 if (new_index == GSUB_E_NOGLYPH)
1390 ERR("Chain failed to generate a glyph.\n");
1391 }
1392 return new_index;
1393 }
1394 }
1395 else if (GET_BE_WORD(ccsf1->SubstFormat) == 3)
1396 {
1397 WORD backtrack_count, input_count, lookahead_count, substitution_count;
1398 int k;
1399 const GSUB_ChainContextSubstFormat3_1 *backtrack;
1400 const GSUB_ChainContextSubstFormat3_2 *input;
1401 const GSUB_ChainContextSubstFormat3_3 *lookahead;
1402 const GSUB_ChainContextSubstFormat3_4 *substitute;
1403 int new_index = GSUB_E_NOGLYPH;
1404
1405 TRACE(" subtype 3 (Coverage-based Chaining Context Glyph Substitution)\n");
1406
1407 backtrack = (const GSUB_ChainContextSubstFormat3_1 *)ccsf1;
1408 backtrack_count = GET_BE_WORD(backtrack->BacktrackGlyphCount);
1409 k = glyph_index + dirBacktrack * backtrack_count;
1410 if (k < 0 || k >= *glyph_count)
1411 continue;
1412
1413 input = (const GSUB_ChainContextSubstFormat3_2 *)&backtrack->Coverage[backtrack_count];
1414 input_count = GET_BE_WORD(input->InputGlyphCount);
1415 k = glyph_index + write_dir * (input_count - 1);
1416 if (k < 0 || k >= *glyph_count)
1417 continue;
1418
1419 lookahead = (const GSUB_ChainContextSubstFormat3_3 *)&input->Coverage[input_count];
1420 lookahead_count = GET_BE_WORD(lookahead->LookaheadGlyphCount);
1421 k = glyph_index + dirLookahead * (input_count + lookahead_count - 1);
1422 if (k < 0 || k >= *glyph_count)
1423 continue;
1424
1425 substitute = (const GSUB_ChainContextSubstFormat3_4 *)&lookahead->Coverage[lookahead_count];
1426
1427 for (k = 0; k < backtrack_count; ++k)
1428 {
1429 offset = GET_BE_WORD(backtrack->Coverage[k]);
1430 if (GSUB_is_glyph_covered((const BYTE *)ccsf1 + offset,
1431 glyphs[glyph_index + (dirBacktrack * (k + 1))]) == -1)
1432 break;
1433 }
1434 if (k != backtrack_count)
1435 continue;
1436 TRACE("Matched Backtrack\n");
1437
1438 for (k = 0; k < input_count; ++k)
1439 {
1440 offset = GET_BE_WORD(input->Coverage[k]);
1441 if (GSUB_is_glyph_covered((const BYTE *)ccsf1 + offset,
1442 glyphs[glyph_index + (write_dir * k)]) == -1)
1443 break;
1444 }
1445 if (k != input_count)
1446 continue;
1447 TRACE("Matched IndexGlyphs\n");
1448
1449 for (k = 0; k < lookahead_count; ++k)
1450 {
1451 offset = GET_BE_WORD(lookahead->Coverage[k]);
1452 if (GSUB_is_glyph_covered((const BYTE *)ccsf1 + offset,
1453 glyphs[glyph_index + (dirLookahead * (input_count + k))]) == -1)
1454 break;
1455 }
1456 if (k != lookahead_count)
1457 continue;
1458 TRACE("Matched LookAhead\n");
1459
1460 substitution_count = GET_BE_WORD(substitute->SubstCount);
1461 for (k = 0; k < substitution_count; ++k)
1462 {
1463 unsigned int lookup_index = GET_BE_WORD(substitute->SubstLookupRecord[k].LookupListIndex);
1464 unsigned int sequence_index = GET_BE_WORD(substitute->SubstLookupRecord[k].SequenceIndex);
1465 unsigned int g = glyph_index + write_dir * sequence_index;
1466
1467 if (g >= *glyph_count)
1468 {
1469 WARN("Skipping invalid sequence index %u (glyph index %u, write dir %d).\n",
1470 sequence_index, glyph_index, write_dir);
1471 continue;
1472 }
1473
1474 TRACE("SUBST: %u -> %u %u.\n", k, sequence_index, lookup_index);
1475 new_index = GSUB_apply_lookup(lookup, lookup_index, glyphs, g, write_dir, glyph_count);
1476 if (new_index == GSUB_E_NOGLYPH)
1477 ERR("Chain failed to generate a glyph.\n");
1478 }
1479 return new_index;
1480 }
1481 }
1482 return GSUB_E_NOGLYPH;
1483}
GSUB_apply_lookup
static INT GSUB_apply_lookup(const OT_LookupList *lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:1485
GSUB_ChainContextSubstFormat1
Definition: opentype.c:311
GSUB_ChainContextSubstFormat1::SubstFormat
WORD SubstFormat
Definition: opentype.c:312
GSUB_ChainContextSubstFormat2
Definition: opentype.c:318
GSUB_ChainContextSubstFormat2::LookaheadClassDef
WORD LookaheadClassDef
Definition: opentype.c:323
GSUB_ChainContextSubstFormat2::BacktrackClassDef
WORD BacktrackClassDef
Definition: opentype.c:321
GSUB_ChainContextSubstFormat2::ChainSubClassSet
WORD ChainSubClassSet[1]
Definition: opentype.c:325
GSUB_ChainContextSubstFormat2::ChainSubClassSetCnt
WORD ChainSubClassSetCnt
Definition: opentype.c:324
GSUB_ChainContextSubstFormat2::InputClassDef
WORD InputClassDef
Definition: opentype.c:322
GSUB_ChainContextSubstFormat2::Coverage
WORD Coverage
Definition: opentype.c:320
GSUB_ChainContextSubstFormat3_1
Definition: opentype.c:353
GSUB_ChainContextSubstFormat3_1::Coverage
WORD Coverage[1]
Definition: opentype.c:356
GSUB_ChainContextSubstFormat3_1::BacktrackGlyphCount
WORD BacktrackGlyphCount
Definition: opentype.c:355
GSUB_ChainContextSubstFormat3_2
Definition: opentype.c:359
GSUB_ChainContextSubstFormat3_3
Definition: opentype.c:364
GSUB_ChainContextSubstFormat3_3::LookaheadGlyphCount
WORD LookaheadGlyphCount
Definition: opentype.c:365
GSUB_ChainContextSubstFormat3_3::Coverage
WORD Coverage[1]
Definition: opentype.c:366
GSUB_ChainContextSubstFormat3_4
Definition: opentype.c:369
GSUB_ChainContextSubstFormat3_4::SubstCount
WORD SubstCount
Definition: opentype.c:370
GSUB_ChainContextSubstFormat3_4::SubstLookupRecord
GSUB_SubstLookupRecord SubstLookupRecord[1]
Definition: opentype.c:371
GSUB_ChainSubClassRule_1
Definition: opentype.c:333
GSUB_ChainSubClassRule_1::BacktrackGlyphCount
WORD BacktrackGlyphCount
Definition: opentype.c:334
GSUB_ChainSubClassRule_1::Backtrack
WORD Backtrack[1]
Definition: opentype.c:335
GSUB_ChainSubClassRule_2
Definition: opentype.c:338
GSUB_ChainSubClassRule_3
Definition: opentype.c:343
GSUB_ChainSubClassRule_3::LookAhead
WORD LookAhead[1]
Definition: opentype.c:345
GSUB_ChainSubClassRule_3::LookaheadGlyphCount
WORD LookaheadGlyphCount
Definition: opentype.c:344
GSUB_ChainSubClassRule_4
Definition: opentype.c:348
GSUB_ChainSubClassRule_4::SubstCount
WORD SubstCount
Definition: opentype.c:349
GSUB_ChainSubClassRule_4::SubstLookupRecord
GSUB_SubstLookupRecord SubstLookupRecord[1]
Definition: opentype.c:350
GSUB_ChainSubClassSet
Definition: opentype.c:328
GSUB_ChainSubClassSet::ChainSubClassRule
WORD ChainSubClassRule[1]
Definition: opentype.c:330
GSUB_ChainSubClassSet::ChainSubClassRuleCnt
WORD ChainSubClassRuleCnt
Definition: opentype.c:329
GSUB_SubstLookupRecord::SequenceIndex
WORD SequenceIndex
Definition: opentype.c:261
GSUB_SubstLookupRecord::LookupListIndex
WORD LookupListIndex
Definition: opentype.c:262

Referenced by GSUB_apply_lookup().

◆ GSUB_apply_ContextSubst()

static INT GSUB_apply_ContextSubst ( const OT_LookupList *  lookup,
const OT_LookupTable *  look,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 1074 of file opentype.c.

1075{
1076 int j;
1077 TRACE("Context Substitution Subtable\n");
1078 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1079 {
1080 const GSUB_ContextSubstFormat1 *csf1;
1081
1082 csf1 = (const GSUB_ContextSubstFormat1*)GSUB_get_subtable(look, j);
1083 if (GET_BE_WORD(csf1->SubstFormat) == 1)
1084 {
1085 int offset, index;
1086 TRACE("Context Substitution Subtable: Class 1\n");
1087 offset = GET_BE_WORD(csf1->Coverage);
1088 index = GSUB_is_glyph_covered((const BYTE*)csf1+offset, glyphs[glyph_index]);
1089 TRACE(" Coverage index %i\n",index);
1090 if (index != -1)
1091 {
1092 int k, count;
1093 const GSUB_SubRuleSet *srs;
1094 offset = GET_BE_WORD(csf1->SubRuleSet[index]);
1095 srs = (const GSUB_SubRuleSet*)((const BYTE*)csf1+offset);
1096 count = GET_BE_WORD(srs->SubRuleCount);
1097 TRACE(" SubRuleSet has %i members\n",count);
1098 for (k = 0; k < count; k++)
1099 {
1100 const GSUB_SubRule_1 *sr;
1101 const GSUB_SubRule_2 *sr_2;
1102 unsigned int g;
1103 int g_count, l;
1104 int newIndex = glyph_index;
1105
1106 offset = GET_BE_WORD(srs->SubRule[k]);
1107 sr = (const GSUB_SubRule_1*)((const BYTE*)srs+offset);
1108 g_count = GET_BE_WORD(sr->GlyphCount);
1109 TRACE(" SubRule has %i glyphs\n",g_count);
1110
1111 g = glyph_index + write_dir * (g_count - 1);
1112 if (g >= *glyph_count)
1113 continue;
1114
1115 for (l = 0; l < g_count-1; l++)
1116 if (glyphs[glyph_index + (write_dir * (l+1))] != GET_BE_WORD(sr->Input[l])) break;
1117
1118 if (l < g_count-1)
1119 {
1120 TRACE(" Rule does not match\n");
1121 continue;
1122 }
1123
1124 TRACE(" Rule matches\n");
1125 sr_2 = (const GSUB_SubRule_2 *)&sr->Input[g_count - 1];
1126
1127 for (l = 0; l < GET_BE_WORD(sr->SubstCount); l++)
1128 {
1129 unsigned int lookup_index = GET_BE_WORD(sr_2->SubstLookupRecord[l].LookupListIndex);
1130 unsigned int sequence_index = GET_BE_WORD(sr_2->SubstLookupRecord[l].SequenceIndex);
1131
1132 g = glyph_index + write_dir * sequence_index;
1133 if (g >= *glyph_count)
1134 {
1135 WARN("Invalid sequence index %u (glyph index %u, write dir %d).\n",
1136 sequence_index, glyph_index, write_dir);
1137 continue;
1138 }
1139
1140 TRACE(" SUBST: %u -> %u %u.\n", l, sequence_index, lookup_index);
1141 newIndex = GSUB_apply_lookup(lookup, lookup_index, glyphs, g, write_dir, glyph_count);
1142 if (newIndex == GSUB_E_NOGLYPH)
1143 {
1144 ERR(" Chain failed to generate a glyph\n");
1145 continue;
1146 }
1147 }
1148 return newIndex;
1149 }
1150 }
1151 }
1152 else if (GET_BE_WORD(csf1->SubstFormat) == 2)
1153 {
1154 const GSUB_ContextSubstFormat2 *csf2;
1155 const void *glyph_class_table;
1156 int offset, index;
1157
1158 csf2 = (const GSUB_ContextSubstFormat2*)csf1;
1159 TRACE("Context Substitution Subtable: Class 2\n");
1160 offset = GET_BE_WORD(csf2->Coverage);
1161 index = GSUB_is_glyph_covered((const BYTE*)csf2+offset, glyphs[glyph_index]);
1162 TRACE(" Coverage index %i\n",index);
1163 if (index != -1)
1164 {
1165 int k, count, class;
1166 const GSUB_SubClassSet *scs;
1167
1168 offset = GET_BE_WORD(csf2->ClassDef);
1169 glyph_class_table = (const BYTE *)csf2 + offset;
1170
1171 class = OT_get_glyph_class(glyph_class_table,glyphs[glyph_index]);
1172
1173 offset = GET_BE_WORD(csf2->SubClassSet[class]);
1174 if (offset == 0)
1175 {
1176 TRACE(" No class rule table for class %i\n",class);
1177 continue;
1178 }
1179 scs = (const GSUB_SubClassSet*)((const BYTE*)csf2+offset);
1180 count = GET_BE_WORD(scs->SubClassRuleCnt);
1181 TRACE(" SubClassSet has %i members\n",count);
1182 for (k = 0; k < count; k++)
1183 {
1184 const GSUB_SubClassRule_1 *sr;
1185 const GSUB_SubClassRule_2 *sr_2;
1186 unsigned int g;
1187 int g_count, l;
1188 int newIndex = glyph_index;
1189
1190 offset = GET_BE_WORD(scs->SubClassRule[k]);
1191 sr = (const GSUB_SubClassRule_1*)((const BYTE*)scs+offset);
1192 g_count = GET_BE_WORD(sr->GlyphCount);
1193 TRACE(" SubClassRule has %i glyphs classes\n",g_count);
1194
1195 g = glyph_index + write_dir * (g_count - 1);
1196 if (g >= *glyph_count)
1197 continue;
1198
1199 for (l = 0; l < g_count-1; l++)
1200 {
1201 int g_class = OT_get_glyph_class(glyph_class_table, glyphs[glyph_index + (write_dir * (l+1))]);
1202 if (g_class != GET_BE_WORD(sr->Class[l])) break;
1203 }
1204
1205 if (l < g_count-1)
1206 {
1207 TRACE(" Rule does not match\n");
1208 continue;
1209 }
1210
1211 TRACE(" Rule matches\n");
1212 sr_2 = (const GSUB_SubClassRule_2 *)&sr->Class[g_count - 1];
1213
1214 for (l = 0; l < GET_BE_WORD(sr->SubstCount); l++)
1215 {
1216 unsigned int lookup_index = GET_BE_WORD(sr_2->SubstLookupRecord[l].LookupListIndex);
1217 unsigned int sequence_index = GET_BE_WORD(sr_2->SubstLookupRecord[l].SequenceIndex);
1218
1219 g = glyph_index + write_dir * sequence_index;
1220 if (g >= *glyph_count)
1221 {
1222 WARN("Invalid sequence index %u (glyph index %u, write dir %d).\n",
1223 sequence_index, glyph_index, write_dir);
1224 continue;
1225 }
1226
1227 TRACE(" SUBST: %u -> %u %u.\n", l, sequence_index, lookup_index);
1228 newIndex = GSUB_apply_lookup(lookup, lookup_index, glyphs, g, write_dir, glyph_count);
1229 if (newIndex == GSUB_E_NOGLYPH)
1230 {
1231 ERR(" Chain failed to generate a glyph\n");
1232 continue;
1233 }
1234 }
1235 return newIndex;
1236 }
1237 }
1238 }
1239 else
1240 FIXME("Unhandled Context Substitution Format %i\n", GET_BE_WORD(csf1->SubstFormat));
1241 }
1242 return GSUB_E_NOGLYPH;
1243}
GSUB_ContextSubstFormat1
Definition: opentype.c:266
GSUB_ContextSubstFormat1::SubRuleSet
WORD SubRuleSet[1]
Definition: opentype.c:270
GSUB_ContextSubstFormat1::Coverage
WORD Coverage
Definition: opentype.c:268
GSUB_ContextSubstFormat1::SubstFormat
WORD SubstFormat
Definition: opentype.c:267
GSUB_ContextSubstFormat2
Definition: opentype.c:288
GSUB_ContextSubstFormat2::SubClassSet
WORD SubClassSet[1]
Definition: opentype.c:293
GSUB_ContextSubstFormat2::ClassDef
WORD ClassDef
Definition: opentype.c:291
GSUB_ContextSubstFormat2::Coverage
WORD Coverage
Definition: opentype.c:290
GSUB_SubClassRule_1
Definition: opentype.c:301
GSUB_SubClassRule_1::Class
WORD Class[1]
Definition: opentype.c:304
GSUB_SubClassRule_1::SubstCount
WORD SubstCount
Definition: opentype.c:303
GSUB_SubClassRule_1::GlyphCount
WORD GlyphCount
Definition: opentype.c:302
GSUB_SubClassRule_2
Definition: opentype.c:307
GSUB_SubClassRule_2::SubstLookupRecord
GSUB_SubstLookupRecord SubstLookupRecord[1]
Definition: opentype.c:308
GSUB_SubClassSet
Definition: opentype.c:296
GSUB_SubClassSet::SubClassRuleCnt
WORD SubClassRuleCnt
Definition: opentype.c:297
GSUB_SubClassSet::SubClassRule
WORD SubClassRule[1]
Definition: opentype.c:298
GSUB_SubRuleSet
Definition: opentype.c:273
GSUB_SubRuleSet::SubRule
WORD SubRule[1]
Definition: opentype.c:275
GSUB_SubRuleSet::SubRuleCount
WORD SubRuleCount
Definition: opentype.c:274
GSUB_SubRule_1
Definition: opentype.c:278
GSUB_SubRule_1::SubstCount
WORD SubstCount
Definition: opentype.c:280
GSUB_SubRule_1::Input
WORD Input[1]
Definition: opentype.c:281
GSUB_SubRule_1::GlyphCount
WORD GlyphCount
Definition: opentype.c:279
GSUB_SubRule_2
Definition: opentype.c:284
GSUB_SubRule_2::SubstLookupRecord
GSUB_SubstLookupRecord SubstLookupRecord[1]
Definition: opentype.c:285

Referenced by GSUB_apply_lookup().

◆ GSUB_apply_LigatureSubst()

static INT GSUB_apply_LigatureSubst ( const OT_LookupTable *  look,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 1011 of file opentype.c.

1012{
1013 int j;
1014
1015 TRACE("Ligature Substitution Subtable\n");
1016 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
1017 {
1018 const GSUB_LigatureSubstFormat1 *lsf1;
1019 int offset,index;
1020
1021 lsf1 = (const GSUB_LigatureSubstFormat1*)GSUB_get_subtable(look, j);
1022 offset = GET_BE_WORD(lsf1->Coverage);
1023 index = GSUB_is_glyph_covered((const BYTE*)lsf1+offset, glyphs[glyph_index]);
1024 TRACE(" Coverage index %i\n",index);
1025 if (index != -1)
1026 {
1027 const GSUB_LigatureSet *ls;
1028 int k, count;
1029
1030 offset = GET_BE_WORD(lsf1->LigatureSet[index]);
1031 ls = (const GSUB_LigatureSet*)((const BYTE*)lsf1+offset);
1032 count = GET_BE_WORD(ls->LigatureCount);
1033 TRACE(" LigatureSet has %i members\n",count);
1034 for (k = 0; k < count; k++)
1035 {
1036 const GSUB_Ligature *lig;
1037 int CompCount,l,CompIndex;
1038
1039 offset = GET_BE_WORD(ls->Ligature[k]);
1040 lig = (const GSUB_Ligature*)((const BYTE*)ls+offset);
1041 CompCount = GET_BE_WORD(lig->CompCount) - 1;
1042 CompIndex = glyph_index+write_dir;
1043 for (l = 0; l < CompCount && CompIndex >= 0 && CompIndex < *glyph_count; l++)
1044 {
1045 int CompGlyph;
1046 CompGlyph = GET_BE_WORD(lig->Component[l]);
1047 if (CompGlyph != glyphs[CompIndex])
1048 break;
1049 CompIndex += write_dir;
1050 }
1051 if (l == CompCount)
1052 {
1053 int replaceIdx = glyph_index;
1054 if (write_dir < 0)
1055 replaceIdx = glyph_index - CompCount;
1056
1057 TRACE(" Glyph is 0x%x (+%i) ->",glyphs[glyph_index],CompCount);
1058 glyphs[replaceIdx] = GET_BE_WORD(lig->LigGlyph);
1059 TRACE("0x%x\n",glyphs[replaceIdx]);
1060 if (CompCount > 0)
1061 {
1062 unsigned int j = replaceIdx + 1;
1063 memmove(&glyphs[j], &glyphs[j + CompCount], (*glyph_count - j) * sizeof(*glyphs));
1064 *glyph_count = *glyph_count - CompCount;
1065 }
1066 return replaceIdx + write_dir;
1067 }
1068 }
1069 }
1070 }
1071 return GSUB_E_NOGLYPH;
1072}
ls
void ls(int argc, const char *argv[])
Definition: cmds.c:1136
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
GSUB_LigatureSet
Definition: opentype.c:249
GSUB_LigatureSubstFormat1
Definition: opentype.c:242
GSUB_LigatureSubstFormat1::Coverage
WORD Coverage
Definition: opentype.c:244
GSUB_LigatureSubstFormat1::LigatureSet
WORD LigatureSet[1]
Definition: opentype.c:246
GSUB_Ligature
Definition: opentype.c:254
GSUB_Ligature::Component
WORD Component[1]
Definition: opentype.c:257
GSUB_Ligature::CompCount
WORD CompCount
Definition: opentype.c:256
GSUB_Ligature::LigGlyph
WORD LigGlyph
Definition: opentype.c:255

Referenced by GSUB_apply_lookup().

◆ GSUB_apply_lookup()

static INT GSUB_apply_lookup ( const OT_LookupList *  lookup,
INT  lookup_index,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 1485 of file opentype.c.

1486{
1487 int offset;
1488 enum gsub_lookup_type type;
1489 const OT_LookupTable *look;
1490
1491 offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
1492 look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
1493 type = GET_BE_WORD(look->LookupType);
1494 TRACE("type %#x, flag %#x, subtables %u.\n", type,
1495 GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
1496
1497 if (type == GSUB_LOOKUP_EXTENSION)
1498 {
1499 if (GET_BE_WORD(look->SubTableCount))
1500 {
1501 const GSUB_ExtensionPosFormat1 *ext = (const GSUB_ExtensionPosFormat1 *)((const BYTE *)look + GET_BE_WORD(look->SubTable[0]));
1502 if (GET_BE_WORD(ext->SubstFormat) == 1)
1503 {
1504 type = GET_BE_WORD(ext->ExtensionLookupType);
1505 TRACE("extension type %i\n",type);
1506 }
1507 else
1508 {
1509 FIXME("Unhandled Extension Substitution Format %i\n",GET_BE_WORD(ext->SubstFormat));
1510 }
1511 }
1512 else
1513 {
1514 WARN("lookup type is Extension Substitution but no extension subtable exists\n");
1515 }
1516 }
1517 switch(type)
1518 {
1519 case GSUB_LOOKUP_SINGLE:
1520 return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1521 case GSUB_LOOKUP_MULTIPLE:
1522 return GSUB_apply_MultipleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1523 case GSUB_LOOKUP_ALTERNATE:
1524 return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1525 case GSUB_LOOKUP_LIGATURE:
1526 return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1527 case GSUB_LOOKUP_CONTEXT:
1528 return GSUB_apply_ContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
1529 case GSUB_LOOKUP_CONTEXT_CHAINED:
1530 return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
1531 case GSUB_LOOKUP_EXTENSION:
1532 FIXME("Extension Substitution types not valid here\n");
1533 break;
1534 default:
1535 FIXME("Unhandled GSUB lookup type %#x.\n", type);
1536 }
1537 return GSUB_E_NOGLYPH;
1538}
GSUB_apply_ContextSubst
static INT GSUB_apply_ContextSubst(const OT_LookupList *lookup, const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:1074
GSUB_apply_ChainContextSubst
static INT GSUB_apply_ChainContextSubst(const OT_LookupList *lookup, const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:1245
GSUB_apply_LigatureSubst
static INT GSUB_apply_LigatureSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:1011
GSUB_apply_SingleSubst
static INT GSUB_apply_SingleSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:882
gsub_lookup_type
gsub_lookup_type
Definition: opentype.c:66
GSUB_apply_MultipleSubst
static INT GSUB_apply_MultipleSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:928
GSUB_apply_AlternateSubst
static INT GSUB_apply_AlternateSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
Definition: opentype.c:978
GSUB_ExtensionPosFormat1
Definition: opentype.c:386

Referenced by GSUB_apply_ChainContextSubst(), GSUB_apply_ContextSubst(), and OpenType_apply_GSUB_lookup().

◆ GSUB_apply_MultipleSubst()

static INT GSUB_apply_MultipleSubst ( const OT_LookupTable *  look,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 928 of file opentype.c.

929{
930 int j;
931 TRACE("Multiple Substitution Subtable\n");
932
933 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
934 {
935 int offset, index;
936 const GSUB_MultipleSubstFormat1 *msf1;
937 msf1 = (const GSUB_MultipleSubstFormat1*)GSUB_get_subtable(look, j);
938
939 offset = GET_BE_WORD(msf1->Coverage);
940 index = GSUB_is_glyph_covered((const BYTE*)msf1+offset, glyphs[glyph_index]);
941 if (index != -1)
942 {
943 const GSUB_Sequence *seq;
944 int sub_count;
945 int j;
946 offset = GET_BE_WORD(msf1->Sequence[index]);
947 seq = (const GSUB_Sequence*)((const BYTE*)msf1+offset);
948 sub_count = GET_BE_WORD(seq->GlyphCount);
949 TRACE(" Glyph 0x%x (+%i)->",glyphs[glyph_index],(sub_count-1));
950
951 for (j = (*glyph_count)+(sub_count-1); j > glyph_index; j--)
952 glyphs[j] =glyphs[j-(sub_count-1)];
953
954 for (j = 0; j < sub_count; j++)
955 if (write_dir < 0)
956 glyphs[glyph_index + (sub_count-1) - j] = GET_BE_WORD(seq->Substitute[j]);
957 else
958 glyphs[glyph_index + j] = GET_BE_WORD(seq->Substitute[j]);
959
960 *glyph_count = *glyph_count + (sub_count - 1);
961
962 if (TRACE_ON(uniscribe))
963 {
964 for (j = 0; j < sub_count; j++)
965 TRACE(" 0x%x",glyphs[glyph_index+j]);
966 TRACE("\n");
967 }
968
969 if (write_dir > 0)
970 return glyph_index + sub_count;
971 else
972 return glyph_index - 1;
973 }
974 }
975 return GSUB_E_NOGLYPH;
976}
TRACE_ON
#define TRACE_ON(x)
Definition: compat.h:75
GSUB_MultipleSubstFormat1
Definition: opentype.c:230
GSUB_MultipleSubstFormat1::Coverage
WORD Coverage
Definition: opentype.c:232
GSUB_MultipleSubstFormat1::Sequence
WORD Sequence[1]
Definition: opentype.c:234
GSUB_Sequence
Definition: opentype.c:237
GSUB_Sequence::Substitute
WORD Substitute[1]
Definition: opentype.c:239
GSUB_Sequence::GlyphCount
WORD GlyphCount
Definition: opentype.c:238

Referenced by GSUB_apply_lookup().

◆ GSUB_apply_SingleSubst()

static INT GSUB_apply_SingleSubst ( const OT_LookupTable *  look,
WORD *  glyphs,
INT  glyph_index,
INT  write_dir,
INT *  glyph_count 
)
static

Definition at line 882 of file opentype.c.

883{
884 int j;
885 TRACE("Single Substitution Subtable\n");
886
887 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
888 {
889 const GSUB_SingleSubstFormat1 *ssf1 = (const GSUB_SingleSubstFormat1*)GSUB_get_subtable(look, j);
890 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
891 {
892 int offset = GET_BE_WORD(ssf1->Coverage);
893 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
894 if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyphs[glyph_index]) != -1)
895 {
896 TRACE(" Glyph 0x%x ->",glyphs[glyph_index]);
897 glyphs[glyph_index] = glyphs[glyph_index] + GET_BE_WORD(ssf1->DeltaGlyphID);
898 TRACE(" 0x%x\n",glyphs[glyph_index]);
899 return glyph_index + write_dir;
900 }
901 }
902 else
903 {
904 const GSUB_SingleSubstFormat2 *ssf2;
905 INT index;
906 INT offset;
907
908 ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
909 offset = GET_BE_WORD(ssf1->Coverage);
910 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
911 index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyphs[glyph_index]);
912 TRACE(" Coverage index %i\n",index);
913 if (index != -1)
914 {
915 if (glyphs[glyph_index] == GET_BE_WORD(ssf2->Substitute[index]))
916 return GSUB_E_NOGLYPH;
917
918 TRACE(" Glyph is 0x%x ->",glyphs[glyph_index]);
919 glyphs[glyph_index] = GET_BE_WORD(ssf2->Substitute[index]);
920 TRACE("0x%x\n",glyphs[glyph_index]);
921 return glyph_index + write_dir;
922 }
923 }
924 }
925 return GSUB_E_NOGLYPH;
926}
GSUB_SingleSubstFormat1
Definition: opentype.c:217
GSUB_SingleSubstFormat1::SubstFormat
WORD SubstFormat
Definition: opentype.c:218
GSUB_SingleSubstFormat1::DeltaGlyphID
WORD DeltaGlyphID
Definition: opentype.c:220
GSUB_SingleSubstFormat1::Coverage
WORD Coverage
Definition: opentype.c:219
GSUB_SingleSubstFormat2
Definition: opentype.c:223
GSUB_SingleSubstFormat2::GlyphCount
WORD GlyphCount
Definition: opentype.c:226
GSUB_SingleSubstFormat2::Substitute
WORD Substitute[1]
Definition: opentype.c:227

Referenced by GSUB_apply_lookup().

◆ GSUB_get_subtable()

static const BYTE * GSUB_get_subtable ( const OT_LookupTable *  look,
int  index 
)
static

Definition at line 863 of file opentype.c.

864{
865 int offset = GET_BE_WORD(look->SubTable[index]);
866
867 if (GET_BE_WORD(look->LookupType) == GSUB_LOOKUP_EXTENSION)
868 {
869 const GSUB_ExtensionPosFormat1 *ext = (const GSUB_ExtensionPosFormat1 *)((const BYTE *)look + offset);
870 if (GET_BE_WORD(ext->SubstFormat) == 1)
871 {
872 offset += GET_BE_DWORD(ext->ExtensionOffset);
873 }
874 else
875 {
876 FIXME("Unhandled Extension Substitution Format %i\n",GET_BE_WORD(ext->SubstFormat));
877 }
878 }
879 return (const BYTE *)look + offset;
880}

Referenced by GSUB_apply_AlternateSubst(), GSUB_apply_ChainContextSubst(), GSUB_apply_ContextSubst(), GSUB_apply_LigatureSubst(), GSUB_apply_MultipleSubst(), and GSUB_apply_SingleSubst().

◆ GSUB_is_glyph_covered()

static int GSUB_is_glyph_covered ( const void *  table,
unsigned int  glyph 
)
static

Definition at line 819 of file opentype.c.

820{
821 const OT_CoverageFormat1* cf1;
822
823 cf1 = table;
824
825 if (GET_BE_WORD(cf1->CoverageFormat) == 1)
826 {
827 int count = GET_BE_WORD(cf1->GlyphCount);
828 int i;
829 TRACE("Coverage Format 1, %i glyphs\n",count);
830 for (i = 0; i < count; i++)
831 if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
832 return i;
833 return -1;
834 }
835 else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
836 {
837 const OT_CoverageFormat2* cf2;
838 int i;
839 int count;
840 cf2 = (const OT_CoverageFormat2*)cf1;
841
842 count = GET_BE_WORD(cf2->RangeCount);
843 TRACE("Coverage Format 2, %i ranges\n",count);
844 for (i = 0; i < count; i++)
845 {
846 if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
847 return -1;
848 if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
849 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
850 {
851 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
852 glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
853 }
854 }
855 return -1;
856 }
857 else
858 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
859
860 return -1;
861}
OT_CoverageFormat1
Definition: opentype.c:199
OT_CoverageFormat1::GlyphCount
WORD GlyphCount
Definition: opentype.c:201
OT_CoverageFormat1::CoverageFormat
WORD CoverageFormat
Definition: opentype.c:200
OT_CoverageFormat1::GlyphArray
WORD GlyphArray[1]
Definition: opentype.c:202
OT_CoverageFormat2
Definition: opentype.c:211
OT_CoverageFormat2::RangeCount
WORD RangeCount
Definition: opentype.c:213
OT_CoverageFormat2::RangeRecord
OT_RangeRecord RangeRecord[1]
Definition: opentype.c:214
OT_RangeRecord::StartCoverageIndex
WORD StartCoverageIndex
Definition: opentype.c:208
OT_RangeRecord::End
WORD End
Definition: opentype.c:207
OT_RangeRecord::Start
WORD Start
Definition: opentype.c:206

Referenced by GPOS_apply_ChainContextPos(), GPOS_apply_ContextPos(), GPOS_apply_CursiveAttachment(), GPOS_apply_MarkToBase(), GPOS_apply_MarkToLigature(), GPOS_apply_MarkToMark(), GPOS_apply_PairAdjustment(), GPOS_apply_SingleAdjustment(), GSUB_apply_AlternateSubst(), GSUB_apply_ChainContextSubst(), GSUB_apply_ContextSubst(), GSUB_apply_LigatureSubst(), GSUB_apply_MultipleSubst(), and GSUB_apply_SingleSubst().

◆ load_CMAP_format12_table()

static VOID * load_CMAP_format12_table ( HDC  hdc,
ScriptCache *  psc 
)
static

Definition at line 627 of file opentype.c.

628{
629 CMAP_Header *CMAP_Table = NULL;
630 int length;
631 int i;
632
633 if (!psc->CMAP_Table)
634 {
635 length = GetFontData(hdc, CMAP_TAG , 0, NULL, 0);
636 if (length != GDI_ERROR)
637 {
638 psc->CMAP_Table = heap_alloc(length);
639 GetFontData(hdc, CMAP_TAG , 0, psc->CMAP_Table, length);
640 TRACE("Loaded cmap table of %i bytes\n",length);
641 }
642 else
643 return NULL;
644 }
645
646 CMAP_Table = psc->CMAP_Table;
647
648 for (i = 0; i < GET_BE_WORD(CMAP_Table->numTables); i++)
649 {
650 if ( (GET_BE_WORD(CMAP_Table->tables[i].platformID) == 3) &&
651 (GET_BE_WORD(CMAP_Table->tables[i].encodingID) == 10) )
652 {
653 CMAP_SegmentedCoverage *format = (CMAP_SegmentedCoverage*)(((BYTE*)CMAP_Table) + GET_BE_DWORD(CMAP_Table->tables[i].offset));
654 if (GET_BE_WORD(format->format) == 12)
655 return format;
656 }
657 }
658 return NULL;
659}
heap_alloc
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
length
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
hdc
HDC hdc
Definition: main.c:9
CMAP_TAG
#define CMAP_TAG
Definition: opentype.c:50
CMAP_EncodingRecord::platformID
WORD platformID
Definition: opentype.c:78
CMAP_EncodingRecord::encodingID
WORD encodingID
Definition: opentype.c:79
CMAP_EncodingRecord::offset
DWORD offset
Definition: opentype.c:80
CMAP_Header
Definition: opentype.c:83
CMAP_Header::tables
CMAP_EncodingRecord tables[1]
Definition: opentype.c:86
CMAP_Header::numTables
WORD numTables
Definition: opentype.c:85
CMAP_SegmentedCoverage
Definition: opentype.c:95
GetFontData
DWORD WINAPI GetFontData(HDC hdc, DWORD dwTable, DWORD dwOffset, LPVOID lpvBuffer, DWORD cbData)
Definition: font.c:2780
GDI_ERROR
#define GDI_ERROR
Definition: wingdi.h:1309

Referenced by OpenType_CMAP_GetGlyphIndex().

◆ OpenType_apply_GPOS_lookup()

unsigned int OpenType_apply_GPOS_lookup ( const ScriptCache *  script_cache,
const OUTLINETEXTMETRICW *  otm,
const LOGFONTW *  logfont,
const SCRIPT_ANALYSIS *  analysis,
int *  advance,
unsigned int  lookup_index,
const WORD *  glyphs,
unsigned int  glyph_index,
unsigned int  glyph_count,
GOFFSET *  goffset 
)

Definition at line 2557 of file opentype.c.

2560{
2561 const GPOS_Header *header = (const GPOS_Header *)script_cache->GPOS_Table;
2562 const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
2563
2564 return GPOS_apply_lookup(script_cache, otm, logfont, analysis, advance, lookup,
2565 lookup_index, glyphs, glyph_index, glyph_count, goffset);
2566}
OT_LookupList
Definition: opentype.c:187

Referenced by GPOS_apply_feature().

◆ OpenType_apply_GSUB_lookup()

int OpenType_apply_GSUB_lookup ( const void *  table,
unsigned int  lookup_index,
WORD *  glyphs,
unsigned int  glyph_index,
int  write_dir,
int *  glyph_count 
)

Definition at line 1540 of file opentype.c.

1542{
1543 const GSUB_Header *header = (const GSUB_Header *)table;
1544 const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1545
1546 return GSUB_apply_lookup(lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count);
1547}

Referenced by apply_GSUB_feature(), and GSUB_apply_feature_all_lookups().

◆ OpenType_CMAP_GetGlyphIndex()

DWORD OpenType_CMAP_GetGlyphIndex ( HDC  hdc,
ScriptCache *  psc,
DWORD  utf32c,
WORD *  glyph_index,
DWORD  flags 
)

Definition at line 673 of file opentype.c.

674{
675 /* BMP: use gdi32 for ease */
676 if (utf32c < 0x10000)
677 {
678 WCHAR ch = utf32c;
679 return GetGlyphIndicesW(hdc, &ch, 1, glyph_index, flags);
680 }
681
682 if (!psc->CMAP_format12_Table)
683 psc->CMAP_format12_Table = load_CMAP_format12_table(hdc, psc);
684
685 if (flags & GGI_MARK_NONEXISTING_GLYPHS)
686 *glyph_index = 0xffffu;
687 else
688 *glyph_index = 0u;
689
690 if (psc->CMAP_format12_Table)
691 {
692 CMAP_SegmentedCoverage *format = NULL;
693 CMAP_SegmentedCoverage_group *group = NULL;
694
695 format = (CMAP_SegmentedCoverage *)psc->CMAP_format12_Table;
696
697 group = bsearch(&utf32c, format->groups, GET_BE_DWORD(format->nGroups),
698 sizeof(CMAP_SegmentedCoverage_group), compare_group);
699
700 if (group)
701 {
702 DWORD offset = utf32c - GET_BE_DWORD(group->startCharCode);
703 *glyph_index = GET_BE_DWORD(group->startGlyphID) + offset;
704 return 0;
705 }
706 }
707 return 0;
708}
flags
GLbitfield flags
Definition: glext.h:7161
u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
load_CMAP_format12_table
static VOID * load_CMAP_format12_table(HDC hdc, ScriptCache *psc)
Definition: opentype.c:627
compare_group
static int __cdecl compare_group(const void *a, const void *b)
Definition: opentype.c:661
format::groups
int groups
Definition: format.c:66
bsearch
#define bsearch
Definition: tif_config.wince.h:38
GetGlyphIndicesW
DWORD WINAPI GetGlyphIndicesW(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpstr, _In_ int c, _Out_writes_(c) LPWORD pgi, _In_ DWORD fl)
GGI_MARK_NONEXISTING_GLYPHS
#define GGI_MARK_NONEXISTING_GLYPHS
Definition: wingdi.h:1085
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by ScriptShapeOpenType().

◆ OpenType_GDEF_UpdateGlyphProps()

void OpenType_GDEF_UpdateGlyphProps ( ScriptCache *  psc,
const WORD *  pwGlyphs,
const WORD  cGlyphs,
WORD *  pwLogClust,
const WORD  cChars,
SCRIPT_GLYPHPROP *  pGlyphProp 
)

Definition at line 751 of file opentype.c.

752{
753 int i;
754 void *glyph_class_table = NULL;
755
756 if (psc->GDEF_Table)
757 {
758 const GDEF_Header *header = psc->GDEF_Table;
759 WORD offset = GET_BE_WORD( header->GlyphClassDef );
760 if (offset)
761 glyph_class_table = (BYTE *)psc->GDEF_Table + offset;
762 }
763
764 for (i = 0; i < cGlyphs; i++)
765 {
766 WORD class;
767 int char_count = 0;
768 int k;
769
770 k = USP10_FindGlyphInLogClust(pwLogClust, cChars, i);
771 if (k >= 0)
772 {
773 for (; k < cChars && pwLogClust[k] == i; k++)
774 char_count++;
775 }
776
777 class = OT_get_glyph_class( glyph_class_table, pwGlyphs[i] );
778
779 switch (class)
780 {
781 case 0:
782 case BaseGlyph:
783 pGlyphProp[i].sva.fClusterStart = 1;
784 pGlyphProp[i].sva.fDiacritic = 0;
785 pGlyphProp[i].sva.fZeroWidth = 0;
786 break;
787 case LigatureGlyph:
788 pGlyphProp[i].sva.fClusterStart = 1;
789 pGlyphProp[i].sva.fDiacritic = 0;
790 pGlyphProp[i].sva.fZeroWidth = 0;
791 break;
792 case MarkGlyph:
793 pGlyphProp[i].sva.fClusterStart = 0;
794 pGlyphProp[i].sva.fDiacritic = 1;
795 pGlyphProp[i].sva.fZeroWidth = 1;
796 break;
797 case ComponentGlyph:
798 pGlyphProp[i].sva.fClusterStart = 0;
799 pGlyphProp[i].sva.fDiacritic = 0;
800 pGlyphProp[i].sva.fZeroWidth = 0;
801 break;
802 default:
803 ERR("Unknown glyph class %i\n",class);
804 pGlyphProp[i].sva.fClusterStart = 1;
805 pGlyphProp[i].sva.fDiacritic = 0;
806 pGlyphProp[i].sva.fZeroWidth = 0;
807 }
808
809 if (char_count == 0)
810 pGlyphProp[i].sva.fClusterStart = 0;
811 }
812}
USP10_FindGlyphInLogClust
int USP10_FindGlyphInLogClust(const WORD *pwLogClust, int cChars, WORD target)
Definition: usp10.c:1044
cChars
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int cChars
Definition: usp10.c:64
pwLogClust
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int WORD * pwLogClust
Definition: usp10.c:64
tagSCRIPT_GLYPHPROP::sva
SCRIPT_VISATTR sva
Definition: usp10.h:215
tag_SCRIPT_VISATTR::fDiacritic
WORD fDiacritic
Definition: usp10.h:180
tag_SCRIPT_VISATTR::fClusterStart
WORD fClusterStart
Definition: usp10.h:179
tag_SCRIPT_VISATTR::fZeroWidth
WORD fZeroWidth
Definition: usp10.h:181
cGlyphs
_In_ FONTOBJ _In_ ULONG _In_ ULONG cGlyphs
Definition: winddi.h:3799

Referenced by ShapeCharGlyphProp_Arabic(), ShapeCharGlyphProp_BaseIndic(), ShapeCharGlyphProp_Default(), ShapeCharGlyphProp_Hebrew(), ShapeCharGlyphProp_None(), ShapeCharGlyphProp_Thai(), and ShapeCharGlyphProp_Tibet().

◆ OpenType_GetFontFeatureTags()

HRESULT OpenType_GetFontFeatureTags ( ScriptCache *  psc,
OPENTYPE_TAG  script_tag,
OPENTYPE_TAG  language_tag,
BOOL  filtered,
OPENTYPE_TAG  searchingFor,
char  tableType,
int  cMaxTags,
OPENTYPE_TAG *  pFeatureTags,
int *  pcTags,
LoadedFeature **  feature 
)

Definition at line 2872 of file opentype.c.

2873{
2874 int i;
2875 LoadedLanguage *language;
2876 LoadedScript *script;
2877 HRESULT rc = S_OK;
2878
2879 _initialize_script_cache(psc);
2880 if (!(script = usp10_script_cache_get_script(psc, script_tag)))
2881 {
2882 *pcTags = 0;
2883 if (!filtered)
2884 return S_OK;
2885 else
2886 return E_INVALIDARG;
2887 }
2888
2889 _initialize_language_cache(script);
2890
2891 language = &script->default_language;
2892 if (language->tag != language_tag || (!language->table[USP10_LANGUAGE_TABLE_GSUB]
2893 && !language->table[USP10_LANGUAGE_TABLE_GPOS]))
2894 language = usp10_script_get_language(script, language_tag);
2895
2896 if (!language)
2897 {
2898 *pcTags = 0;
2899 return S_OK;
2900 }
2901
2902 _initialize_feature_cache(psc, language);
2903
2904 if (tableType)
2905 {
2906 *pcTags = 0;
2907 for (i = 0; i < language->feature_count; i++)
2908 if (language->features[i].tableType == tableType)
2909 *pcTags = (*pcTags)+1;
2910 }
2911 else
2912 *pcTags = language->feature_count;
2913
2914 if (!searchingFor && cMaxTags < *pcTags)
2915 rc = E_OUTOFMEMORY;
2916 else if (searchingFor)
2917 rc = E_INVALIDARG;
2918
2919 for (i = 0; i < language->feature_count; i++)
2920 {
2921 if (i < cMaxTags)
2922 {
2923 if (!tableType || language->features[i].tableType == tableType)
2924 pFeatureTags[i] = language->features[i].tag;
2925 }
2926
2927 if (searchingFor)
2928 {
2929 if ((searchingFor == language->features[i].tag) &&
2930 (!tableType || language->features[i].tableType == tableType))
2931 {
2932 pFeatureTags[0] = language->features[i].tag;
2933 *pcTags = 1;
2934 if (feature)
2935 *feature = &language->features[i];
2936 rc = S_OK;
2937 break;
2938 }
2939 }
2940 }
2941 return rc;
2942}
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
S_OK
#define S_OK
Definition: intsafe.h:52
feature
INTERNETFEATURELIST feature
Definition: misc.c:1719
pFeatureTags
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int OPENTYPE_TAG * pFeatureTags
Definition: usp10.c:68
cMaxTags
static SCRIPT_CACHE SCRIPT_ANALYSIS int cMaxTags
Definition: usp10.c:66
pcTags
static SCRIPT_CACHE SCRIPT_ANALYSIS int OPENTYPE_TAG int * pcTags
Definition: usp10.c:66
_initialize_script_cache
static void _initialize_script_cache(ScriptCache *script_cache)
Definition: opentype.c:2628
_initialize_language_cache
static void _initialize_language_cache(LoadedScript *script)
Definition: opentype.c:2746
usp10_script_cache_get_script
static LoadedScript * usp10_script_cache_get_script(ScriptCache *script_cache, OPENTYPE_TAG tag)
Definition: opentype.c:2585
_initialize_feature_cache
static void _initialize_feature_cache(ScriptCache *psc, LoadedLanguage *language)
Definition: opentype.c:2847
usp10_script_get_language
static LoadedLanguage * usp10_script_get_language(LoadedScript *script, OPENTYPE_TAG tag)
Definition: opentype.c:2695
LoadedFeature::tag
OPENTYPE_TAG tag
Definition: usp10_internal.h:146
LoadedLanguage::tag
OPENTYPE_TAG tag
Definition: usp10_internal.h:161
LoadedLanguage::features
LoadedFeature * features
Definition: usp10_internal.h:164

Referenced by load_OT_feature(), and SHAPE_GetFontFeatureTags().

◆ OpenType_GetFontLanguageTags()

HRESULT OpenType_GetFontLanguageTags ( ScriptCache *  psc,
OPENTYPE_TAG  script_tag,
OPENTYPE_TAG  searchingFor,
int  cMaxTags,
OPENTYPE_TAG *  pLanguageTags,
int *  pcTags 
)

Definition at line 2761 of file opentype.c.

2762{
2763 int i;
2764 HRESULT rc = S_OK;
2765 LoadedScript *script = NULL;
2766
2767 _initialize_script_cache(psc);
2768 if (!(script = usp10_script_cache_get_script(psc, script_tag)))
2769 return E_INVALIDARG;
2770
2771 _initialize_language_cache(script);
2772
2773 if (!searchingFor && cMaxTags < script->language_count)
2774 rc = E_OUTOFMEMORY;
2775 else if (searchingFor)
2776 rc = E_INVALIDARG;
2777
2778 *pcTags = script->language_count;
2779
2780 for (i = 0; i < script->language_count; i++)
2781 {
2782 if (i < cMaxTags)
2783 pLanguageTags[i] = script->languages[i].tag;
2784
2785 if (searchingFor)
2786 {
2787 if (searchingFor == script->languages[i].tag)
2788 {
2789 pLanguageTags[0] = script->languages[i].tag;
2790 *pcTags = 1;
2791 rc = S_OK;
2792 break;
2793 }
2794 }
2795 }
2796
2797 if (script->default_language.table[USP10_LANGUAGE_TABLE_GSUB])
2798 {
2799 if (i < cMaxTags)
2800 pLanguageTags[i] = script->default_language.tag;
2801
2802 if (searchingFor && FAILED(rc))
2803 {
2804 pLanguageTags[0] = script->default_language.tag;
2805 }
2806 i++;
2807 *pcTags = (*pcTags) + 1;
2808 }
2809
2810 return rc;
2811}
FAILED
#define FAILED(hr)
Definition: intsafe.h:51

Referenced by SHAPE_GetFontLanguageTags().

◆ OpenType_GetFontScriptTags()

HRESULT OpenType_GetFontScriptTags ( ScriptCache *  psc,
OPENTYPE_TAG  searchingFor,
int  cMaxTags,
OPENTYPE_TAG *  pScriptTags,
int *  pcTags 
)

Definition at line 2647 of file opentype.c.

2648{
2649 int i;
2650 const LoadedScript *script;
2651 HRESULT rc = S_OK;
2652
2653 _initialize_script_cache(psc);
2654
2655 *pcTags = psc->script_count;
2656
2657 if (searchingFor)
2658 {
2659 if (!(script = usp10_script_cache_get_script(psc, searchingFor)))
2660 return USP_E_SCRIPT_NOT_IN_FONT;
2661
2662 *pScriptTags = script->tag;
2663 *pcTags = 1;
2664 return S_OK;
2665 }
2666
2667 if (cMaxTags < *pcTags)
2668 rc = E_OUTOFMEMORY;
2669
2670 cMaxTags = min(cMaxTags, psc->script_count);
2671 for (i = 0; i < cMaxTags; ++i)
2672 {
2673 pScriptTags[i] = psc->scripts[i].tag;
2674 }
2675 return rc;
2676}
pScriptTags
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM ULONG * pScriptTags
Definition: usp10.c:62
min
#define min(a, b)
Definition: monoChain.cc:55
USP_E_SCRIPT_NOT_IN_FONT
#define USP_E_SCRIPT_NOT_IN_FONT
Definition: usp10.h:71

Referenced by get_GSUB_Indic2(), and SHAPE_GetFontScriptTags().

◆ OT_get_glyph_class()

static WORD OT_get_glyph_class ( const void *  table,
WORD  glyph 
)
static

Definition at line 714 of file opentype.c.

715{
716 WORD class = 0;
717 const OT_ClassDefFormat1 *cf1 = table;
718
719 if (!table) return 0;
720
721 if (GET_BE_WORD(cf1->ClassFormat) == 1)
722 {
723 if (glyph >= GET_BE_WORD(cf1->StartGlyph))
724 {
725 int index = glyph - GET_BE_WORD(cf1->StartGlyph);
726 if (index < GET_BE_WORD(cf1->GlyphCount))
727 class = GET_BE_WORD(cf1->ClassValueArray[index]);
728 }
729 }
730 else if (GET_BE_WORD(cf1->ClassFormat) == 2)
731 {
732 const OT_ClassDefFormat2 *cf2 = table;
733 int i, top;
734 top = GET_BE_WORD(cf2->ClassRangeCount);
735 for (i = 0; i < top; i++)
736 {
737 if (glyph >= GET_BE_WORD(cf2->ClassRangeRecord[i].Start) &&
738 glyph <= GET_BE_WORD(cf2->ClassRangeRecord[i].End))
739 {
740 class = GET_BE_WORD(cf2->ClassRangeRecord[i].Class);
741 break;
742 }
743 }
744 }
745 else
746 ERR("Unknown Class Format %i\n",GET_BE_WORD(cf1->ClassFormat));
747
748 return class;
749}
top
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
OT_ClassDefFormat1
Definition: opentype.c:115
OT_ClassDefFormat2
Definition: opentype.c:128
OT_ClassDefFormat2::ClassRangeCount
WORD ClassRangeCount
Definition: opentype.c:130
OT_ClassDefFormat2::ClassRangeRecord
OT_ClassRangeRecord ClassRangeRecord[1]
Definition: opentype.c:131
OT_ClassRangeRecord::End
WORD End
Definition: opentype.c:124
OT_ClassRangeRecord::Start
WORD Start
Definition: opentype.c:123

Referenced by GPOS_apply_ContextPos(), GPOS_apply_MarkToBase(), GPOS_apply_PairAdjustment(), GSUB_apply_ChainContextSubst(), GSUB_apply_ContextSubst(), and OpenType_GDEF_UpdateGlyphProps().

◆ usp10_language_add_feature_list()

static void usp10_language_add_feature_list ( LoadedLanguage *  language,
char  table_type,
const OT_LangSys *  lang,
const OT_FeatureList *  feature_list 
)
static

Definition at line 2813 of file opentype.c.

2815{
2816 unsigned int count = GET_BE_WORD(lang->FeatureCount);
2817 unsigned int i, j;
2818
2819 TRACE("table_type %#x, %u features.\n", table_type, count);
2820
2821 if (!count || !usp10_array_reserve((void **)&language->features, &language->features_size,
2822 language->feature_count + count, sizeof(*language->features)))
2823 return;
2824
2825 for (i = 0; i < count; ++i)
2826 {
2827 const OT_FeatureRecord *record;
2828 LoadedFeature *loaded_feature;
2829 const OT_Feature *feature;
2830
2831 record = &feature_list->FeatureRecord[GET_BE_WORD(lang->FeatureIndex[i])];
2832 feature = (const OT_Feature *)((const BYTE *)feature_list + GET_BE_WORD(record->Feature));
2833
2834 loaded_feature = &language->features[language->feature_count + i];
2835 loaded_feature->tag = MS_MAKE_TAG(record->FeatureTag[0], record->FeatureTag[1],
2836 record->FeatureTag[2], record->FeatureTag[3]);
2837 loaded_feature->tableType = table_type;
2838 loaded_feature->feature = feature;
2839 loaded_feature->lookup_count = GET_BE_WORD(feature->LookupCount);
2840 loaded_feature->lookups = heap_calloc(loaded_feature->lookup_count, sizeof(*loaded_feature->lookups));
2841 for (j = 0; j < loaded_feature->lookup_count; ++j)
2842 loaded_feature->lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
2843 }
2844 language->feature_count += count;
2845}
MS_MAKE_TAG
#define MS_MAKE_TAG(ch0, ch1, ch2, ch3)
Definition: font.c:113
usp10_array_reserve
BOOL usp10_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size)
Definition: usp10.c:730
heap_calloc
static void * heap_calloc(SIZE_T count, SIZE_T size)
Definition: heap.h:49
LoadedFeature::feature
const void * feature
Definition: usp10_internal.h:148
OT_FeatureList::FeatureRecord
OT_FeatureRecord FeatureRecord[1]
Definition: opentype.c:178
OT_FeatureRecord
Definition: opentype.c:171
OT_Feature
Definition: opentype.c:181

Referenced by _initialize_feature_cache().

◆ usp10_script_add_language()

static LoadedLanguage * usp10_script_add_language ( LoadedScript *  script,
OPENTYPE_TAG  tag 
)
static

Definition at line 2678 of file opentype.c.

2679{
2680 LoadedLanguage *language;
2681
2682 if (!usp10_array_reserve((void **)&script->languages, &script->languages_size,
2683 script->language_count + 1, sizeof(*script->languages)))
2684 {
2685 ERR("Failed to grow languages array.\n");
2686 return NULL;
2687 }
2688
2689 language = &script->languages[script->language_count++];
2690 language->tag = tag;
2691
2692 return language;
2693}
tag
Definition: ecma_167.h:138

Referenced by usp10_script_add_language_list().

◆ usp10_script_add_language_list()

static void usp10_script_add_language_list ( LoadedScript *  script,
enum usp10_language_table  table,
const OT_Script *  list 
)
static

Definition at line 2708 of file opentype.c.

2710{
2711 SIZE_T initial_count, count, i;
2712 LoadedLanguage *language;
2713 OPENTYPE_TAG tag;
2714 DWORD offset;
2715
2716 TRACE("script %p, table %#x, list %p.\n", script, table, list);
2717
2718 if ((offset = GET_BE_WORD(list->DefaultLangSys)))
2719 {
2720 script->default_language.tag = MS_MAKE_TAG('d','f','l','t');
2721 script->default_language.table[table] = (const BYTE *)list + offset;
2722 TRACE("Default language %p.\n", script->default_language.table[table]);
2723 }
2724
2725 if (!(count = GET_BE_WORD(list->LangSysCount)))
2726 return;
2727
2728 TRACE("Adding %lu languages.\n", count);
2729
2730 initial_count = script->language_count;
2731 for (i = 0; i < count; ++i)
2732 {
2733 tag = MS_MAKE_TAG(list->LangSysRecord[i].LangSysTag[0],
2734 list->LangSysRecord[i].LangSysTag[1],
2735 list->LangSysRecord[i].LangSysTag[2],
2736 list->LangSysRecord[i].LangSysTag[3]);
2737
2738 if (!(initial_count && (language = usp10_script_get_language(script, tag)))
2739 && !(language = usp10_script_add_language(script, tag)))
2740 return;
2741
2742 language->table[table] = (const BYTE *)list + GET_BE_WORD(list->LangSysRecord[i].LangSys);
2743 }
2744}
usp10_script_add_language
static LoadedLanguage * usp10_script_add_language(LoadedScript *script, OPENTYPE_TAG tag)
Definition: opentype.c:2678
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
OPENTYPE_TAG
ULONG OPENTYPE_TAG
Definition: usp10.h:205

Referenced by _initialize_language_cache().

◆ usp10_script_cache_add_script()

static LoadedScript * usp10_script_cache_add_script ( ScriptCache *  script_cache,
OPENTYPE_TAG  tag 
)
static

Definition at line 2568 of file opentype.c.

2569{
2570 LoadedScript *script;
2571
2572 if (!usp10_array_reserve((void **)&script_cache->scripts, &script_cache->scripts_size,
2573 script_cache->script_count + 1, sizeof(*script_cache->scripts)))
2574 {
2575 ERR("Failed to grow scripts array.\n");
2576 return NULL;
2577 }
2578
2579 script = &script_cache->scripts[script_cache->script_count++];
2580 script->tag = tag;
2581
2582 return script;
2583}
LoadedScript::tag
OPENTYPE_TAG tag
Definition: usp10_internal.h:177
ScriptCache::script_count
SIZE_T script_count
Definition: usp10_internal.h:208
ScriptCache::scripts
LoadedScript * scripts
Definition: usp10_internal.h:206
ScriptCache::scripts_size
SIZE_T scripts_size
Definition: usp10_internal.h:207

Referenced by usp10_script_cache_add_script_list().

◆ usp10_script_cache_add_script_list()

static void usp10_script_cache_add_script_list ( ScriptCache *  script_cache,
enum usp10_script_table  table,
const OT_ScriptList *  list 
)
static

Definition at line 2598 of file opentype.c.

2600{
2601 SIZE_T initial_count, count, i;
2602 LoadedScript *script;
2603 OPENTYPE_TAG tag;
2604
2605 TRACE("script_cache %p, table %#x, list %p.\n", script_cache, table, list);
2606
2607 if (!(count = GET_BE_WORD(list->ScriptCount)))
2608 return;
2609
2610 TRACE("Adding %lu scripts.\n", count);
2611
2612 initial_count = script_cache->script_count;
2613 for (i = 0; i < count; ++i)
2614 {
2615 tag = MS_MAKE_TAG(list->ScriptRecord[i].ScriptTag[0],
2616 list->ScriptRecord[i].ScriptTag[1],
2617 list->ScriptRecord[i].ScriptTag[2],
2618 list->ScriptRecord[i].ScriptTag[3]);
2619
2620 if (!(initial_count && (script = usp10_script_cache_get_script(script_cache, tag)))
2621 && !(script = usp10_script_cache_add_script(script_cache, tag)))
2622 return;
2623
2624 script->table[table] = (const BYTE *)list + GET_BE_WORD(list->ScriptRecord[i].Script);
2625 }
2626}
usp10_script_cache_add_script
static LoadedScript * usp10_script_cache_add_script(ScriptCache *script_cache, OPENTYPE_TAG tag)
Definition: opentype.c:2568

Referenced by _initialize_script_cache().

◆ usp10_script_cache_get_script()

static LoadedScript * usp10_script_cache_get_script ( ScriptCache *  script_cache,
OPENTYPE_TAG  tag 
)
static

Definition at line 2585 of file opentype.c.

2586{
2587 size_t i;
2588
2589 for (i = 0; i < script_cache->script_count; ++i)
2590 {
2591 if (script_cache->scripts[i].tag == tag)
2592 return &script_cache->scripts[i];
2593 }
2594
2595 return NULL;
2596}

Referenced by OpenType_GetFontFeatureTags(), OpenType_GetFontLanguageTags(), OpenType_GetFontScriptTags(), and usp10_script_cache_add_script_list().

◆ usp10_script_get_language()

static LoadedLanguage * usp10_script_get_language ( LoadedScript *  script,
OPENTYPE_TAG  tag 
)
static

Definition at line 2695 of file opentype.c.

2696{
2697 size_t i;
2698
2699 for (i = 0; i < script->language_count; ++i)
2700 {
2701 if (script->languages[i].tag == tag)
2702 return &script->languages[i];
2703 }
2704
2705 return NULL;
2706}

Referenced by OpenType_GetFontFeatureTags(), and usp10_script_add_language_list().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( uniscribe  )