/**
* pango_ot_tag_from_script:
* @script: A #PangoScript
*
* Finds the OpenType script tag corresponding to @script.
*
* The %PANGO_SCRIPT_COMMON, %PANGO_SCRIPT_INHERITED, and
* %PANGO_SCRIPT_UNKNOWN scripts are mapped to the OpenType
* 'DFLT' script tag that is also defined as
* %PANGO_OT_TAG_DEFAULT_SCRIPT.
*
* Note that multiple #PangoScript values may map to the same
* OpenType script tag. In particular, %PANGO_SCRIPT_HIRAGANA
* and %PANGO_SCRIPT_KATAKANA both map to the OT tag 'kana'.
*
* Return value: #PangoOTTag corresponding to @script or
* %PANGO_OT_TAG_DEFAULT_SCRIPT if none found.
*
* Since: 1.18
**/
PangoOTTag
pango_ot_tag_from_script (PangoScript script)
{
hb_tag_t tag1, tag2;
hb_ot_tags_from_script (hb_glib_script_to_script (script), &tag1, &tag2);
return (PangoOTTag) tag1;
}
FT_Error
af_get_coverage( AF_FaceGlobals globals,
AF_StyleClass style_class,
FT_UShort* gstyles )
{
hb_face_t* face;
hb_set_t* gsub_lookups; /* GSUB lookups for a given script */
hb_set_t* gsub_glyphs; /* glyphs covered by GSUB lookups */
hb_set_t* gpos_lookups; /* GPOS lookups for a given script */
hb_set_t* gpos_glyphs; /* glyphs covered by GPOS lookups */
hb_script_t script;
const hb_tag_t* coverage_tags;
hb_tag_t script_tags[] = { HB_TAG_NONE,
HB_TAG_NONE,
HB_TAG_NONE,
HB_TAG_NONE };
hb_codepoint_t idx;
#ifdef FT_DEBUG_LEVEL_TRACE
int count;
#endif
if ( !globals || !style_class || !gstyles )
return FT_THROW( Invalid_Argument );
face = hb_font_get_face( globals->hb_font );
gsub_lookups = hb_set_create();
gsub_glyphs = hb_set_create();
gpos_lookups = hb_set_create();
gpos_glyphs = hb_set_create();
coverage_tags = coverages[style_class->coverage];
script = scripts[style_class->script];
/* Convert a HarfBuzz script tag into the corresponding OpenType */
/* tag or tags -- some Indic scripts like Devanagari have an old */
/* and a new set of features. */
hb_ot_tags_from_script( script,
&script_tags[0],
&script_tags[1] );
/* `hb_ot_tags_from_script' usually returns HB_OT_TAG_DEFAULT_SCRIPT */
/* as the second tag. We change that to HB_TAG_NONE except for the */
/* default script. */
if ( style_class->script == globals->module->default_script &&
style_class->coverage == AF_COVERAGE_DEFAULT )
{
if ( script_tags[0] == HB_TAG_NONE )
script_tags[0] = HB_OT_TAG_DEFAULT_SCRIPT;
else
{
if ( script_tags[1] == HB_TAG_NONE )
script_tags[1] = HB_OT_TAG_DEFAULT_SCRIPT;
else if ( script_tags[1] != HB_OT_TAG_DEFAULT_SCRIPT )
script_tags[2] = HB_OT_TAG_DEFAULT_SCRIPT;
}
}
else
{
if ( script_tags[1] == HB_OT_TAG_DEFAULT_SCRIPT )
script_tags[1] = HB_TAG_NONE;
}
hb_ot_layout_collect_lookups( face,
HB_OT_TAG_GSUB,
script_tags,
NULL,
coverage_tags,
gsub_lookups );
if ( hb_set_is_empty( gsub_lookups ) )
goto Exit; /* nothing to do */
hb_ot_layout_collect_lookups( face,
HB_OT_TAG_GPOS,
script_tags,
NULL,
coverage_tags,
gpos_lookups );
FT_TRACE4(( "GSUB lookups (style `%s'):\n"
" ",
af_style_names[style_class->style] ));
#ifdef FT_DEBUG_LEVEL_TRACE
count = 0;
#endif
for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gsub_lookups, &idx ); )
{
#ifdef FT_DEBUG_LEVEL_TRACE
FT_TRACE4(( " %d", idx ));
count++;
#endif
/* get output coverage of GSUB feature */
hb_ot_layout_lookup_collect_glyphs( face,
HB_OT_TAG_GSUB,
idx,
NULL,
NULL,
NULL,
gsub_glyphs );
}
#ifdef FT_DEBUG_LEVEL_TRACE
if ( !count )
FT_TRACE4(( " (none)" ));
FT_TRACE4(( "\n\n" ));
#endif
FT_TRACE4(( "GPOS lookups (style `%s'):\n"
" ",
af_style_names[style_class->style] ));
#ifdef FT_DEBUG_LEVEL_TRACE
count = 0;
#endif
for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gpos_lookups, &idx ); )
{
#ifdef FT_DEBUG_LEVEL_TRACE
FT_TRACE4(( " %d", idx ));
count++;
#endif
/* get input coverage of GPOS feature */
hb_ot_layout_lookup_collect_glyphs( face,
HB_OT_TAG_GPOS,
idx,
NULL,
gpos_glyphs,
NULL,
NULL );
}
#ifdef FT_DEBUG_LEVEL_TRACE
if ( !count )
FT_TRACE4(( " (none)" ));
FT_TRACE4(( "\n\n" ));
#endif
/*
* We now check whether we can construct blue zones, using glyphs
* covered by the feature only. In case there is not a single zone
* (this is, not a single character is covered), we skip this coverage.
*
*/
if ( style_class->coverage != AF_COVERAGE_DEFAULT )
{
AF_Blue_Stringset bss = style_class->blue_stringset;
const AF_Blue_StringRec* bs = &af_blue_stringsets[bss];
FT_Bool found = 0;
for ( ; bs->string != AF_BLUE_STRING_MAX; bs++ )
{
const char* p = &af_blue_strings[bs->string];
while ( *p )
{
hb_codepoint_t ch;
GET_UTF8_CHAR( ch, p );
for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gsub_lookups,
&idx ); )
{
hb_codepoint_t gidx = FT_Get_Char_Index( globals->face, ch );
if ( hb_ot_layout_lookup_would_substitute( face, idx,
&gidx, 1, 1 ) )
{
found = 1;
break;
}
}
}
}
if ( !found )
{
FT_TRACE4(( " no blue characters found; style skipped\n" ));
goto Exit;
}
}
/*
* Various OpenType features might use the same glyphs at different
* vertical positions; for example, superscript and subscript glyphs
* could be the same. However, the auto-hinter is completely
* agnostic of OpenType features after the feature analysis has been
* completed: The engine then simply receives a glyph index and returns a
* hinted and usually rendered glyph.
*
* Consider the superscript feature of font `pala.ttf': Some of the
* glyphs are `real', this is, they have a zero vertical offset, but
* most of them are small caps glyphs shifted up to the superscript
* position (this is, the `sups' feature is present in both the GSUB and
* GPOS tables). The code for blue zones computation actually uses a
* feature's y offset so that the `real' glyphs get correct hints. But
* later on it is impossible to decide whether a glyph index belongs to,
* say, the small caps or superscript feature.
*
* For this reason, we don't assign a style to a glyph if the current
* feature covers the glyph in both the GSUB and the GPOS tables. This
* is quite a broad condition, assuming that
*
* (a) glyphs that get used in multiple features are present in a
* feature without vertical shift,
*
* and
*
* (b) a feature's GPOS data really moves the glyph vertically.
*
* Not fulfilling condition (a) makes a font larger; it would also
* reduce the number of glyphs that could be addressed directly without
* using OpenType features, so this assumption is rather strong.
*
* Condition (b) is much weaker, and there might be glyphs which get
* missed. However, the OpenType features we are going to handle are
* primarily located in GSUB, and HarfBuzz doesn't provide an API to
* directly get the necessary information from the GPOS table. A
* possible solution might be to directly parse the GPOS table to find
* out whether a glyph gets shifted vertically, but this is something I
* would like to avoid if not really necessary.
*
* Note that we don't follow this logic for the default coverage.
* Complex scripts like Devanagari have mandatory GPOS features to
* position many glyph elements, using mark-to-base or mark-to-ligature
* tables; the number of glyphs missed due to condition (b) would be far
* too large.
*
*/
if ( style_class->coverage != AF_COVERAGE_DEFAULT )
hb_set_subtract( gsub_glyphs, gpos_glyphs );
#ifdef FT_DEBUG_LEVEL_TRACE
FT_TRACE4(( " glyphs without GPOS data (`*' means already assigned)" ));
count = 0;
#endif
for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gsub_glyphs, &idx ); )
{
#ifdef FT_DEBUG_LEVEL_TRACE
if ( !( count % 10 ) )
FT_TRACE4(( "\n"
" " ));
FT_TRACE4(( " %d", idx ));
count++;
#endif
/* glyph indices returned by `hb_ot_layout_lookup_collect_glyphs' */
/* can be arbitrary: some fonts use fake indices for processing */
/* internal to GSUB or GPOS, which is fully valid */
if ( idx >= (hb_codepoint_t)globals->glyph_count )
continue;
if ( gstyles[idx] == AF_STYLE_UNASSIGNED )
gstyles[idx] = (FT_UShort)style_class->style;
#ifdef FT_DEBUG_LEVEL_TRACE
else
FT_TRACE4(( "*" ));
#endif
}
#ifdef FT_DEBUG_LEVEL_TRACE
if ( !count )
FT_TRACE4(( "\n"
" (none)" ));
FT_TRACE4(( "\n\n" ));
#endif
Exit:
hb_set_destroy( gsub_lookups );
hb_set_destroy( gsub_glyphs );
hb_set_destroy( gpos_lookups );
hb_set_destroy( gpos_glyphs );
return FT_Err_Ok;
}
bool OpenTypeCapsSupport::supportsOpenTypeFeature(
hb_script_t script,
uint32_t tag) const
{
hb_face_t* face = hb_font_get_face(m_harfBuzzFace->getScaledFont());
ASSERT(face);
ASSERT((tag == HB_TAG('s', 'm', 'c', 'p')
|| tag == HB_TAG('c', '2', 's', 'c')
|| tag == HB_TAG('p', 'c', 'a', 'p')
|| tag == HB_TAG('c', '2', 'p', 'c')
|| tag == HB_TAG('s', 'u', 'p', 's')
|| tag == HB_TAG('s', 'u', 'b', 's')
|| tag == HB_TAG('t', 'i', 't', 'l')
|| tag == HB_TAG('u', 'n', 'i', 'c')
|| tag == HB_TAG('v', 'e', 'r', 't')));
bool result = false;
if (!hb_ot_layout_has_substitution(face))
return false;
// Get the OpenType tag(s) that match this script code
const size_t kMaxScriptTags = 4;
hb_tag_t scriptTags[kMaxScriptTags] = {
HB_TAG_NONE,
HB_TAG_NONE,
HB_TAG_NONE,
HB_TAG_NONE
};
hb_ot_tags_from_script(static_cast<hb_script_t>(script),
&scriptTags[0],
&scriptTags[1]);
// Replace the first remaining NONE with DEFAULT
for (size_t i = 0; i < kMaxScriptTags; ++i) {
if (scriptTags[i] == HB_TAG_NONE) {
scriptTags[i] = HB_OT_TAG_DEFAULT_SCRIPT;
break;
}
}
// Now check for 'smcp' under the first of those scripts that is present
const hb_tag_t kGSUB = HB_TAG('G', 'S', 'U', 'B');
for (size_t j = 0; j < kMaxScriptTags; ++j) {
if (scriptTags[j] == HB_TAG_NONE)
break;
unsigned scriptIndex;
if (hb_ot_layout_table_find_script(face,
kGSUB,
scriptTags[j],
&scriptIndex)) {
if (hb_ot_layout_language_find_feature(face, kGSUB,
scriptIndex,
HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX,
tag, nullptr)) {
result = true;
}
break;
}
}
return result;
}
