walkero
/
harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Patches from #170414. Reviewed by Matthias Clasen. 

2005-11-03  Behdad Esfahbod  <behdad@gnome.org>

        Patches from #170414.  Reviewed by Matthias Clasen.

        * pango/opentype/ftxgpos.c, pango/opentype/ftxgsub.c: Use call table
        to dispatch different lookup types.

        * pango/opentype/pango-ot-buffer.c, pango/opentype/pango-ot-ruleset.c:
        Small cleanup.
This commit is contained in:
Behdad Esfahbod 2005-11-03 20:13:40 +00:00 committed by Behdad Esfahbod
parent c6b22b9119
commit c0505f3bb2
4 changed files with 164 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
src/ftxgpos.c
View File

@ -1027,16 +1027,27 @@
Free_Coverage( &sp->Coverage, memory ); Free_Coverage( &sp->Coverage, memory );
} }
static FT_Error Lookup_DefaultPos( GPOS_Instance* gpi,
TTO_GPOS_SubTable* st,
OTL_Buffer buffer,
FT_UShort flags,
FT_UShort context_length,
int nesting_level )
{
return TTO_Err_Not_Covered;
}
static FT_Error Lookup_SinglePos( GPOS_Instance* gpi, static FT_Error Lookup_SinglePos( GPOS_Instance* gpi,
TTO_SinglePos* sp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length ) FT_UShort context_length,
int nesting_level )
{ {
FT_UShort index, property; FT_UShort index, property;
FT_Error error; FT_Error error;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_SinglePos* sp = &st->single;
if ( context_length != 0xFFFF && context_length < 1 ) if ( context_length != 0xFFFF && context_length < 1 )
@ -1588,14 +1599,16 @@
static FT_Error Lookup_PairPos( GPOS_Instance* gpi, static FT_Error Lookup_PairPos( GPOS_Instance* gpi,
TTO_PairPos* pp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length ) FT_UShort context_length,
int nesting_level )
{ {
FT_Error error; FT_Error error;
FT_UShort index, property, first_pos; FT_UShort index, property, first_pos;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_PairPos* pp = &st->pair;
if ( buffer->in_pos >= buffer->in_length - 1 ) if ( buffer->in_pos >= buffer->in_length - 1 )
@ -1794,14 +1807,16 @@
static FT_Error Lookup_CursivePos( GPOS_Instance* gpi, static FT_Error Lookup_CursivePos( GPOS_Instance* gpi,
TTO_CursivePos* cp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length ) FT_UShort context_length,
int nesting_level )
{ {
FT_UShort index, property; FT_UShort index, property;
FT_Error error; FT_Error error;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_CursivePos* cp = &st->cursive;
TTO_EntryExitRecord* eer; TTO_EntryExitRecord* eer;
FT_Pos entry_x, entry_y; FT_Pos entry_x, entry_y;
@ -2219,15 +2234,17 @@
static FT_Error Lookup_MarkBasePos( GPOS_Instance* gpi, static FT_Error Lookup_MarkBasePos( GPOS_Instance* gpi,
TTO_MarkBasePos* mbp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length ) FT_UShort context_length,
int nesting_level )
{ {
FT_UShort i, j, mark_index, base_index, property, class; FT_UShort i, j, mark_index, base_index, property, class;
FT_Pos x_mark_value, y_mark_value, x_base_value, y_base_value; FT_Pos x_mark_value, y_mark_value, x_base_value, y_base_value;
FT_Error error; FT_Error error;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_MarkBasePos* mbp = &st->markbase;
TTO_MarkArray* ma; TTO_MarkArray* ma;
TTO_BaseArray* ba; TTO_BaseArray* ba;
@ -2626,16 +2643,18 @@
static FT_Error Lookup_MarkLigPos( GPOS_Instance* gpi, static FT_Error Lookup_MarkLigPos( GPOS_Instance* gpi,
TTO_MarkLigPos* mlp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length ) FT_UShort context_length,
int nesting_level )
{ {
FT_UShort i, j, mark_index, lig_index, property, class; FT_UShort i, j, mark_index, lig_index, property, class;
FT_UShort mark_glyph; FT_UShort mark_glyph;
FT_Pos x_mark_value, y_mark_value, x_lig_value, y_lig_value; FT_Pos x_mark_value, y_mark_value, x_lig_value, y_lig_value;
FT_Error error; FT_Error error;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_MarkLigPos* mlp = &st->marklig;
TTO_MarkArray* ma; TTO_MarkArray* ma;
TTO_LigatureArray* la; TTO_LigatureArray* la;
@ -2965,16 +2984,18 @@
static FT_Error Lookup_MarkMarkPos( GPOS_Instance* gpi, static FT_Error Lookup_MarkMarkPos( GPOS_Instance* gpi,
TTO_MarkMarkPos* mmp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length ) FT_UShort context_length,
int nesting_level )
{ {
FT_UShort j, mark1_index, mark2_index, property, class; FT_UShort j, mark1_index, mark2_index, property, class;
FT_Pos x_mark1_value, y_mark1_value, FT_Pos x_mark1_value, y_mark1_value,
x_mark2_value, y_mark2_value; x_mark2_value, y_mark2_value;
FT_Error error; FT_Error error;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_MarkMarkPos* mmp = &st->markmark;
TTO_MarkArray* ma1; TTO_MarkArray* ma1;
TTO_Mark2Array* ma2; TTO_Mark2Array* ma2;
@ -4055,12 +4076,14 @@
static FT_Error Lookup_ContextPos( GPOS_Instance* gpi, static FT_Error Lookup_ContextPos( GPOS_Instance* gpi,
TTO_ContextPos* cp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
int nesting_level ) int nesting_level )
{ {
TTO_ContextPos* cp = &st->context;
switch ( cp->PosFormat ) switch ( cp->PosFormat )
{ {
case 1: case 1:
@ -5543,12 +5566,14 @@
static FT_Error Lookup_ChainContextPos( static FT_Error Lookup_ChainContextPos(
GPOS_Instance* gpi, GPOS_Instance* gpi,
TTO_ChainContextPos* ccp, TTO_GPOS_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
int nesting_level ) int nesting_level )
{ {
TTO_ChainContextPos* ccp = &st->chain;
switch ( ccp->PosFormat ) switch ( ccp->PosFormat )
{ {
case 1: case 1:
@ -5863,6 +5888,25 @@
} }
typedef FT_Error (*Lookup_Func_Type) ( GPOS_Instance* gpi,
TTO_GPOS_SubTable* st,
OTL_Buffer buffer,
FT_UShort flags,
FT_UShort context_length,
int nesting_level );
static const Lookup_Func_Type Lookup_Call_Table[] = {
Lookup_DefaultPos,
Lookup_SinglePos, /* GPOS_LOOKUP_SINGLE 1 */
Lookup_PairPos, /* GPOS_LOOKUP_PAIR 2 */
Lookup_CursivePos, /* GPOS_LOOKUP_CURSIVE 3 */
Lookup_MarkBasePos, /* GPOS_LOOKUP_MARKBASE 4 */
Lookup_MarkLigPos, /* GPOS_LOOKUP_MARKLIG 5 */
Lookup_MarkMarkPos, /* GPOS_LOOKUP_MARKMARK 6 */
Lookup_ContextPos, /* GPOS_LOOKUP_CONTEXT 7 */
Lookup_ChainContextPos, /* GPOS_LOOKUP_CHAIN 8 */
Lookup_DefaultPos, /* GPOS_LOOKUP_EXTENSION 9 */
};
/* Do an individual subtable lookup. Returns TT_Err_Ok if positioning /* Do an individual subtable lookup. Returns TT_Err_Ok if positioning
has been done, or TTO_Err_Not_Covered if not. */ has been done, or TTO_Err_Not_Covered if not. */
@ -5876,6 +5920,8 @@
FT_UShort i, flags, lookup_count; FT_UShort i, flags, lookup_count;
TTO_GPOSHeader* gpos = gpi->gpos; TTO_GPOSHeader* gpos = gpi->gpos;
TTO_Lookup* lo; TTO_Lookup* lo;
int lt;
Lookup_Func_Type Lookup_Func;
nesting_level++; nesting_level++;
@ -5889,69 +5935,18 @@
lo = &gpos->LookupList.Lookup[lookup_index]; lo = &gpos->LookupList.Lookup[lookup_index];
flags = lo->LookupFlag; flags = lo->LookupFlag;
lt = lo->LookupType;
if (lt >= sizeof Lookup_Call_Table / sizeof Lookup_Call_Table[0])
lt = 0;
Lookup_Func = Lookup_Call_Table[lt];
for ( i = 0; i < lo->SubTableCount; i++ ) for ( i = 0; i < lo->SubTableCount; i++ )
{ {
switch ( lo->LookupType ) error = Lookup_Func ( gpi,
{ &lo->SubTable[i].st.gpos,
case GPOS_LOOKUP_SINGLE: buffer,
error = Lookup_SinglePos( gpi, flags, context_length,
&lo->SubTable[i].st.gpos.single, nesting_level );
buffer,
flags, context_length );
break;
case GPOS_LOOKUP_PAIR:
error = Lookup_PairPos( gpi,
&lo->SubTable[i].st.gpos.pair,
buffer,
flags, context_length );
break;
case GPOS_LOOKUP_CURSIVE:
error = Lookup_CursivePos( gpi,
&lo->SubTable[i].st.gpos.cursive,
buffer,
flags, context_length );
break;
case GPOS_LOOKUP_MARKBASE:
error = Lookup_MarkBasePos( gpi,
&lo->SubTable[i].st.gpos.markbase,
buffer,
flags, context_length );
break;
case GPOS_LOOKUP_MARKLIG:
error = Lookup_MarkLigPos( gpi,
&lo->SubTable[i].st.gpos.marklig,
buffer,
flags, context_length );
break;
case GPOS_LOOKUP_MARKMARK:
error = Lookup_MarkMarkPos( gpi,
&lo->SubTable[i].st.gpos.markmark,
buffer,
flags, context_length );
break;
case GPOS_LOOKUP_CONTEXT:
error = Lookup_ContextPos( gpi,
&lo->SubTable[i].st.gpos.context,
buffer,
flags, context_length,
nesting_level );
break;
case GPOS_LOOKUP_CHAIN:
error = Lookup_ChainContextPos( gpi,
&lo->SubTable[i].st.gpos.chain,
buffer,
flags, context_length,
nesting_level );
break;
}
/* Check whether we have a successful positioning or an error other /* Check whether we have a successful positioning or an error other
than TTO_Err_Not_Covered */ than TTO_Err_Not_Covered */

115
src/ftxgsub.c
View File

@ -208,6 +208,16 @@
* SubTable related functions * SubTable related functions
*****************************/ *****************************/
static FT_Error Lookup_DefaultSubst( TTO_GSUBHeader* gsub,
TTO_GSUB_SubTable* st,
OTL_Buffer buffer,
FT_UShort flags,
FT_UShort context_length,
int nesting_level )
{
return TTO_Err_Not_Covered;
}
/* LookupType 1 */ /* LookupType 1 */
@ -311,14 +321,17 @@
} }
static FT_Error Lookup_SingleSubst( TTO_SingleSubst* ss, static FT_Error Lookup_SingleSubst( TTO_GSUBHeader* gsub,
TTO_GSUB_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
TTO_GDEFHeader* gdef ) int nesting_level )
{ {
FT_UShort index, value, property; FT_UShort index, value, property;
FT_Error error; FT_Error error;
TTO_SingleSubst* ss = &st->single;
TTO_GDEFHeader* gdef = gsub->gdef;
if ( context_length != 0xFFFF && context_length < 1 ) if ( context_length != 0xFFFF && context_length < 1 )
@ -514,15 +527,18 @@
} }
static FT_Error Lookup_MultipleSubst( TTO_MultipleSubst* ms, static FT_Error Lookup_MultipleSubst( TTO_GSUBHeader* gsub,
TTO_GSUB_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
TTO_GDEFHeader* gdef ) int nesting_level )
{ {
FT_Error error; FT_Error error;
FT_UShort index, property, n, count; FT_UShort index, property, n, count;
FT_UShort*s; FT_UShort*s;
TTO_MultipleSubst* ms = &st->multiple;
TTO_GDEFHeader* gdef = gsub->gdef;
if ( context_length != 0xFFFF && context_length < 1 ) if ( context_length != 0xFFFF && context_length < 1 )
@ -711,14 +727,17 @@
static FT_Error Lookup_AlternateSubst( TTO_GSUBHeader* gsub, static FT_Error Lookup_AlternateSubst( TTO_GSUBHeader* gsub,
TTO_AlternateSubst* as, TTO_GSUB_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
TTO_GDEFHeader* gdef ) int nesting_level )
{ {
FT_Error error; FT_Error error;
FT_UShort index, alt_index, property; FT_UShort index, alt_index, property;
TTO_AlternateSubst* as = &st->alternate;
TTO_GDEFHeader* gdef = gsub->gdef;
TTO_AlternateSet aset; TTO_AlternateSet aset;
@ -990,16 +1009,19 @@
} }
static FT_Error Lookup_LigatureSubst( TTO_LigatureSubst* ls, static FT_Error Lookup_LigatureSubst( TTO_GSUBHeader* gsub,
TTO_GSUB_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
TTO_GDEFHeader* gdef ) int nesting_level )
{ {
FT_UShort index, property; FT_UShort index, property;
FT_Error error; FT_Error error;
FT_UShort numlig, i, j, is_mark, first_is_mark = FALSE; FT_UShort numlig, i, j, is_mark, first_is_mark = FALSE;
FT_UShort* c; FT_UShort* c;
TTO_LigatureSubst* ls = &st->ligature;
TTO_GDEFHeader* gdef = gsub->gdef;
TTO_Ligature* lig; TTO_Ligature* lig;
@ -2112,12 +2134,14 @@
static FT_Error Lookup_ContextSubst( TTO_GSUBHeader* gsub, static FT_Error Lookup_ContextSubst( TTO_GSUBHeader* gsub,
TTO_ContextSubst* cs, TTO_GSUB_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
int nesting_level ) int nesting_level )
{ {
TTO_ContextSubst* cs = &st->context;
switch ( cs->SubstFormat ) switch ( cs->SubstFormat )
{ {
case 1: case 1:
@ -3604,12 +3628,14 @@
static FT_Error Lookup_ChainContextSubst( static FT_Error Lookup_ChainContextSubst(
TTO_GSUBHeader* gsub, TTO_GSUBHeader* gsub,
TTO_ChainContextSubst* ccs, TTO_GSUB_SubTable* st,
OTL_Buffer buffer, OTL_Buffer buffer,
FT_UShort flags, FT_UShort flags,
FT_UShort context_length, FT_UShort context_length,
int nesting_level ) int nesting_level )
{ {
TTO_ChainContextSubst* ccs = &st->chain;
switch ( ccs->SubstFormat ) switch ( ccs->SubstFormat )
{ {
case 1: case 1:
@ -3930,6 +3956,23 @@
} }
typedef FT_Error (*Lookup_Func_Type) ( TTO_GSUBHeader* gsub,
TTO_GSUB_SubTable* st,
OTL_Buffer buffer,
FT_UShort flags,
FT_UShort context_length,
int nesting_level );
static const Lookup_Func_Type Lookup_Call_Table[] = {
Lookup_DefaultSubst,
Lookup_SingleSubst, /* GSUB_LOOKUP_SINGLE 1 */
Lookup_MultipleSubst, /* GSUB_LOOKUP_MULTIPLE 2 */
Lookup_AlternateSubst, /* GSUB_LOOKUP_ALTERNATE 3 */
Lookup_LigatureSubst, /* GSUB_LOOKUP_LIGATURE 4 */
Lookup_ContextSubst, /* GSUB_LOOKUP_CONTEXT 5 */
Lookup_ChainContextSubst, /* GSUB_LOOKUP_CHAIN 6 */
Lookup_DefaultSubst, /* GSUB_LOOKUP_EXTENSION 7 */
};
/* Do an individual subtable lookup. Returns TT_Err_Ok if substitution /* Do an individual subtable lookup. Returns TT_Err_Ok if substitution
has been done, or TTO_Err_Not_Covered if not. */ has been done, or TTO_Err_Not_Covered if not. */
@ -3942,6 +3985,8 @@
FT_Error error = TTO_Err_Not_Covered; FT_Error error = TTO_Err_Not_Covered;
FT_UShort i, flags, lookup_count; FT_UShort i, flags, lookup_count;
TTO_Lookup* lo; TTO_Lookup* lo;
int lt;
Lookup_Func_Type Lookup_Func;
nesting_level++; nesting_level++;
@ -3955,50 +4000,18 @@
lo = &gsub->LookupList.Lookup[lookup_index]; lo = &gsub->LookupList.Lookup[lookup_index];
flags = lo->LookupFlag; flags = lo->LookupFlag;
lt = lo->LookupType;
if (lt >= sizeof Lookup_Call_Table / sizeof Lookup_Call_Table[0])
lt = 0;
Lookup_Func = Lookup_Call_Table[lt];
for ( i = 0; i < lo->SubTableCount; i++ ) for ( i = 0; i < lo->SubTableCount; i++ )
{ {
switch ( lo->LookupType ) error = Lookup_Func ( gsub,
{ &lo->SubTable[i].st.gsub,
case GSUB_LOOKUP_SINGLE: buffer,
error = Lookup_SingleSubst( &lo->SubTable[i].st.gsub.single, flags, context_length,
buffer, nesting_level );
flags, context_length, gsub->gdef );
break;
case GSUB_LOOKUP_MULTIPLE:
error = Lookup_MultipleSubst( &lo->SubTable[i].st.gsub.multiple,
buffer,
flags, context_length, gsub->gdef );
break;
case GSUB_LOOKUP_ALTERNATE:
error = Lookup_AlternateSubst( gsub,
&lo->SubTable[i].st.gsub.alternate,
buffer,
flags, context_length, gsub->gdef );
break;
case GSUB_LOOKUP_LIGATURE:
error = Lookup_LigatureSubst( &lo->SubTable[i].st.gsub.ligature,
buffer,
flags, context_length, gsub->gdef );
break;
case GSUB_LOOKUP_CONTEXT:
error = Lookup_ContextSubst( gsub, &lo->SubTable[i].st.gsub.context,
buffer,
flags, context_length, nesting_level );
break;
case GSUB_LOOKUP_CHAIN:
error = Lookup_ChainContextSubst( gsub,
&lo->SubTable[i].st.gsub.chain,
buffer,
flags, context_length,
nesting_level );
break;
}
/* Check whether we have a successful substitution or an error other /* Check whether we have a successful substitution or an error other
than TTO_Err_Not_Covered */ than TTO_Err_Not_Covered */

3
src/pango-ot-buffer.c
View File

@ -79,8 +79,7 @@ void
pango_ot_buffer_set_rtl (PangoOTBuffer *buffer, pango_ot_buffer_set_rtl (PangoOTBuffer *buffer,
gboolean rtl) gboolean rtl)
{ {
rtl = rtl != FALSE; buffer->rtl = rtl != FALSE;
buffer->rtl = rtl;
} }
/** /**

85
src/pango-ot-ruleset.c
View File

@ -144,40 +144,27 @@ pango_ot_ruleset_substitute (PangoOTRuleset *ruleset,
TTO_GSUB gsub = NULL; TTO_GSUB gsub = NULL;
gboolean need_gsub = FALSE;
g_return_if_fail (PANGO_OT_IS_RULESET (ruleset)); g_return_if_fail (PANGO_OT_IS_RULESET (ruleset));
for (i = 0; i < ruleset->rules->len; i++) for (i = 0; i < ruleset->rules->len; i++)
{ {
PangoOTRule *rule = &g_array_index (ruleset->rules, PangoOTRule, i); PangoOTRule *rule = &g_array_index (ruleset->rules, PangoOTRule, i);
if (rule->table_type == PANGO_OT_TABLE_GSUB) if (rule->table_type != PANGO_OT_TABLE_GSUB)
need_gsub = TRUE; continue;
}
if (need_gsub) if (!gsub)
{
gsub = pango_ot_info_get_gsub (ruleset->info);
if (gsub)
TT_GSUB_Clear_Features (gsub);
}
for (i = 0; i < ruleset->rules->len; i++)
{
PangoOTRule *rule = &g_array_index (ruleset->rules, PangoOTRule, i);
if (rule->table_type == PANGO_OT_TABLE_GSUB)
{ {
if (gsub) gsub = pango_ot_info_get_gsub (ruleset->info);
TT_GSUB_Add_Feature (gsub, rule->feature_index, rule->property_bit);
}
}
if (!gsub) if (gsub)
return; TT_GSUB_Clear_Features (gsub);
else
return;
}
TT_GSUB_Add_Feature (gsub, rule->feature_index, rule->property_bit);
}
TT_GSUB_Apply_String (gsub, buffer->buffer); TT_GSUB_Apply_String (gsub, buffer->buffer);
} }
@ -190,43 +177,31 @@ pango_ot_ruleset_position (PangoOTRuleset *ruleset,
TTO_GPOS gpos = NULL; TTO_GPOS gpos = NULL;
gboolean need_gpos = FALSE;
g_return_if_fail (PANGO_OT_IS_RULESET (ruleset)); g_return_if_fail (PANGO_OT_IS_RULESET (ruleset));
for (i = 0; i < ruleset->rules->len; i++) for (i = 0; i < ruleset->rules->len; i++)
{ {
PangoOTRule *rule = &g_array_index (ruleset->rules, PangoOTRule, i); PangoOTRule *rule = &g_array_index (ruleset->rules, PangoOTRule, i);
if (rule->table_type == PANGO_OT_TABLE_GPOS) if (rule->table_type != PANGO_OT_TABLE_GPOS)
need_gpos = TRUE; continue;
if (!gpos)
{
gpos = pango_ot_info_get_gpos (ruleset->info);
if (gpos)
TT_GPOS_Clear_Features (gpos);
else
return;
}
TT_GPOS_Add_Feature (gpos, rule->feature_index, rule->property_bit);
} }
if (need_gpos) if (TT_GPOS_Apply_String (ruleset->info->face, gpos, 0, buffer->buffer,
gpos = pango_ot_info_get_gpos (ruleset->info); FALSE /* enable device-dependant values */,
buffer->rtl) == FT_Err_Ok)
if (gpos) buffer->applied_gpos = TRUE;
{
TT_GPOS_Clear_Features (gpos);
for (i = 0; i < ruleset->rules->len; i++)
{
PangoOTRule *rule = &g_array_index (ruleset->rules, PangoOTRule, i);
if (rule->table_type == PANGO_OT_TABLE_GPOS)
TT_GPOS_Add_Feature (gpos, rule->feature_index, rule->property_bit);
}
}
/* Apply GPOS rules */
if (gpos)
{
if (TT_GPOS_Apply_String (ruleset->info->face, gpos, 0, buffer->buffer,
FALSE /* enable device-dependant values */,
buffer->rtl) == FT_Err_Ok)
{
buffer->applied_gpos = TRUE;
}
}
} }