454 lines
18 KiB
XML
454 lines
18 KiB
XML
<?xml version="1.0"?>
|
|
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
|
|
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
|
|
<!ENTITY % local.common.attrib "xmlns:xi CDATA #FIXED 'http://www.w3.org/2003/XInclude'">
|
|
<!ENTITY version SYSTEM "version.xml">
|
|
]>
|
|
<chapter id="fonts-and-faces">
|
|
<title>Fonts, faces, and output</title>
|
|
<para>
|
|
In the previous chapter, we saw how to set up a buffer and fill
|
|
it with text as Unicode code points. In order to shape this
|
|
buffer text with HarfBuzz, you will need also need a font
|
|
object.
|
|
</para>
|
|
<para>
|
|
HarfBuzz provides abstractions to help you cache and reuse the
|
|
heavier parts of working with binary fonts, so we will look at
|
|
how to do that. We will also look at how to work with the
|
|
FreeType font-rendering library and at how you can customize
|
|
HarfBuzz to work with other libraries.
|
|
</para>
|
|
<para>
|
|
Finally, we will look at how to work with OpenType variable
|
|
fonts, the latest update to the OpenType font format, and at
|
|
some other recent additions to OpenType.
|
|
</para>
|
|
|
|
<section id="fonts-and-faces-objects">
|
|
<title>Font and face objects</title>
|
|
<para>
|
|
The outcome of shaping a run of text depends on the contents of
|
|
a specific font file (such as the substitutions and positioning
|
|
moves in the 'GSUB' and 'GPOS' tables), so HarfBuzz makes
|
|
accessing those internals fast.
|
|
</para>
|
|
<para>
|
|
An <type>hb_face_t</type> represents a <emphasis>face</emphasis>
|
|
in HarfBuzz. This data type is a wrapper around an
|
|
<type>hb_blob_t</type> blob that holds the contents of a binary
|
|
font file. Since HarfBuzz supports TrueType Collections and
|
|
OpenType Collections (each of which can include multiple
|
|
typefaces), a HarfBuzz face also requires an index number
|
|
specifying which typeface in the file you want to use. Most of
|
|
the font files you will encounter in the wild include just a
|
|
single face, however, so most of the time you would pass in
|
|
<literal>0</literal> as the index when you create a face:
|
|
</para>
|
|
<programlisting language="C">
|
|
hb_blob_t* blob = hb_blob_create_from_file(file);
|
|
...
|
|
hb_face_t* face = hb_face_create(blob, 0);
|
|
</programlisting>
|
|
<para>
|
|
On its own, a face object is not quite ready to use for
|
|
shaping. The typeface must be set to a specific point size in
|
|
order for some details (such as hinting) to work. In addition,
|
|
if the font file in question is an OpenType Variable Font, then
|
|
you may need to specify one or variation-axis settings (or a
|
|
named instance) in order to get the output you need.
|
|
</para>
|
|
<para>
|
|
In HarfBuzz, you do this by creating a <emphasis>font</emphasis>
|
|
object from your face.
|
|
</para>
|
|
<para>
|
|
Font objects also have the advantage of being considerably
|
|
lighter-weight than face objects (remember that a face contains
|
|
the contents of a binary font file mapped into memory). As a
|
|
result, you can cache and reuse a font object, but you could
|
|
also create a new one for each additional size you needed.
|
|
Creating new fonts incurs some additional overhead, of course,
|
|
but whether or not it is excessive is your call in the end. In
|
|
contrast, face objects are substantially larger, and you really
|
|
should cache them and reuse them whenever possible.
|
|
</para>
|
|
<para>
|
|
You can create a font object from a face object:
|
|
</para>
|
|
<programlisting language="C">
|
|
hb_font_t* hb_font = hb_font_create(hb_face);
|
|
</programlisting>
|
|
<para>
|
|
After creating a font, there are a few properties you should
|
|
set. Many fonts enable and disable hints based on the size it
|
|
is used at, so setting this is important for font
|
|
objects. <function>hb_font_set_ppem(font, x_ppem,
|
|
y_ppem)</function> sets the pixels-per-EM value of the font. You
|
|
can also set the point size of the font with
|
|
<function>hb_font_set_ptem(font, ptem)</function>. HarfBuzz uses the
|
|
industry standard 72 points per inch.
|
|
</para>
|
|
<para>
|
|
HarfBuzz lets you specify the degree subpixel precision you want
|
|
through a scaling factor. You can set horizontal and
|
|
vertical scaling factors on the
|
|
font by calling <function>hb_font_set_scale(font, x_scale,
|
|
y_scale)</function>.
|
|
</para>
|
|
<para>
|
|
There may be times when you are handed a font object and need to
|
|
access the face object that it comes from. For that, you can call
|
|
</para>
|
|
<programlisting language="C">
|
|
hb_face = hb_font_get_face(hb_font);
|
|
</programlisting>
|
|
<para>
|
|
You can also create a font object from an existing font object
|
|
using the <function>hb_font_create_sub_font()</function>
|
|
function. This creates a child font object that is initiated
|
|
with the same attributes as its parent; it can be used to
|
|
quickly set up a new font for the purpose of overriding a specific
|
|
font-functions method.
|
|
</para>
|
|
<para>
|
|
All face objects and font objects are lifecycle-managed by
|
|
HarfBuzz. After creating a face, you increase its reference
|
|
count with <function>hb_face_reference(face)</function> and
|
|
decrease it with
|
|
<function>hb_face_destroy(face)</function>. Likewise, you
|
|
increase the reference count on a font with
|
|
<function>hb_font_reference(font)</function> and decrease it
|
|
with <function>hb_font_destroy(font)</function>.
|
|
</para>
|
|
<para>
|
|
You can also attach user data to face objects and font objects.
|
|
</para>
|
|
</section>
|
|
|
|
<section id="fonts-and-faces-custom-functions">
|
|
<title>Customizing font functions</title>
|
|
<para>
|
|
During shaping, HarfBuzz frequently needs to query font objects
|
|
to get at the contents and parameters of the glyphs in a font
|
|
file. It includes a built-in set of functions that is tailored
|
|
to working with OpenType fonts. However, as was the case with
|
|
Unicode functions in the buffers chapter, HarfBuzz also wants to
|
|
make it easy for you to assign a substitute set of font
|
|
functions if you are developing a program to work with a library
|
|
or platform that provides its own font functions.
|
|
</para>
|
|
<para>
|
|
Therefore, the HarfBuzz API defines a set of virtual
|
|
methods for accessing font-object properties, and you can
|
|
replace the defaults with your own selections without
|
|
interfering with the shaping process. Each font object in
|
|
HarfBuzz includes a structure called
|
|
<literal>font_funcs</literal> that serves as a vtable for the
|
|
font object. The virtual methods in
|
|
<literal>font_funcs</literal> are:
|
|
</para>
|
|
<itemizedlist>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_font_h_extents_func_t</function>: returns
|
|
the extents of the font for horizontal text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_font_v_extents_func_t</function>: returns
|
|
the extents of the font for vertical text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_nominal_glyph_func_t</function>: returns
|
|
the font's nominal glyph for a given code point.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_variation_glyph_func_t</function>: returns
|
|
the font's glyph for a given code point when it is followed by a
|
|
given Variation Selector.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_nominal_glyphs_func_t</function>: returns
|
|
the font's nominal glyphs for a series of code points.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_advance_func_t</function>: returns
|
|
the advance for a glyph.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_h_advance_func_t</function>: returns
|
|
the advance for a glyph for horizontal text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_v_advance_func_t</function>:returns
|
|
the advance for a glyph for vertical text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_advances_func_t</function>: returns
|
|
the advances for a series of glyphs.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_h_advances_func_t</function>: returns
|
|
the advances for a series of glyphs for horizontal text .
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_v_advances_func_t</function>: returns
|
|
the advances for a series of glyphs for vertical text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_origin_func_t</function>: returns
|
|
the origin coordinates of a glyph.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_h_origin_func_t</function>: returns
|
|
the origin coordinates of a glyph for horizontal text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_v_origin_func_t</function>: returns
|
|
the origin coordinates of a glyph for vertical text.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_extents_func_t</function>: returns
|
|
the extents for a glyph.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_contour_point_func_t</function>:
|
|
returns the coordinates of a specific contour point from a glyph.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_name_func_t</function>: returns the
|
|
name of a glyph (from its glyph index).
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
<function>hb_font_get_glyph_from_name_func_t</function>: returns
|
|
the glyph index that corresponds to a given glyph name.
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
<para>
|
|
You can fetch the font-functions configuration for a font object
|
|
by calling <function>hb_font_get_font_funcs()</function>:
|
|
</para>
|
|
<programlisting language="C">
|
|
hb_font_funcs_t *ffunctions;
|
|
ffunctions = hb_font_get_font_funcs (font);
|
|
</programlisting>
|
|
<para>
|
|
The individual methods can each be replaced with their own setter
|
|
function, such as
|
|
<function>hb_font_funcs_set_nominal_glyph_func(*ffunctions,
|
|
func, *user_data, destroy)</function>.
|
|
</para>
|
|
<para>
|
|
Font-functions structures can be reused for multiple font
|
|
objects, and can be reference counted with
|
|
<function>hb_font_funcs_reference()</function> and
|
|
<function>hb_font_funcs_destroy()</function>. Just like other
|
|
objects in HarfBuzz, you can set user-data for each
|
|
font-functions structure and assign a destroy callback for
|
|
it.
|
|
</para>
|
|
<para>
|
|
You can also mark a font-functions structure as immutable,
|
|
with <function>hb_font_funcs_make_immutable()</function>. This
|
|
is especially useful if your code is a library or framework that
|
|
will have its own client programs. By marking your
|
|
font-functions structures as immutable, you prevent your client
|
|
programs from changing the configuration and introducing
|
|
inconsistencies and errors downstream.
|
|
</para>
|
|
</section>
|
|
|
|
<section id="fonts-and-faces-native-opentype">
|
|
<title>Font objects and HarfBuzz's native OpenType implementation</title>
|
|
<para>
|
|
By default, whenever HarfBuzz creates a font object, it will
|
|
configure the font to use a built-in set of font functions that
|
|
supports contemporary OpenType font internals. If you want to
|
|
work with OpenType or TrueType fonts, you should be able to use
|
|
these functions without difficulty.
|
|
</para>
|
|
<para>
|
|
Many of the methods in the font-functions structure deal with
|
|
the fundamental properties of glyphs that are required for
|
|
shaping text: extents (the maximums and minimums on each axis),
|
|
origins (the <literal>(0,0)</literal> coordinate point which
|
|
glyphs are drawn in reference to), and advances (the amount that
|
|
the cursor needs to be moved after drawing each glyph, including
|
|
any empty space for the glyph's side bearings).
|
|
</para>
|
|
<para>
|
|
As you can see in the list of functions, there are separate "horizontal"
|
|
and "vertical" variants depending on whether the text is set in
|
|
the horizontal or vertical direction. For some scripts, fonts
|
|
that are designed to support text set horizontally or vertically (for
|
|
example, in Japanese) may include metrics for both text
|
|
directions. When fonts don't include this information, HarfBuzz
|
|
does its best to transform what the font provides.
|
|
</para>
|
|
<para>
|
|
In addition to the direction-specific functions, HarfBuzz
|
|
provides some higher-level functions for fetching information
|
|
like extents and advances for a glyph. If you call
|
|
</para>
|
|
<programlisting language="C">
|
|
hb_font_get_glyph_advance_for_direction(font, direction, extents);
|
|
</programlisting>
|
|
<para>
|
|
then you can provide any <type>hb_direction_t</type> as the
|
|
<parameter>direction</parameter> parameter, and HarfBuzz will
|
|
use the correct function variant for the text direction. There
|
|
are similar higher-level versions of the functions for fetching
|
|
extents, origin coordinates, and contour-point
|
|
coordinates. There are also addition and subtraction functions
|
|
for moving points with respect to the origin.
|
|
</para>
|
|
<para>
|
|
There are also methods for fetching the glyph ID that
|
|
corresponds to a Unicode code point (possibly when followed by a
|
|
variation-selector code point), fetching the glyph name from the
|
|
font, and fetching the glyph ID that corresponds to a glyph name
|
|
you already have.
|
|
</para>
|
|
<para>
|
|
HarfBuzz also provides functions for converting between glyph
|
|
names and string
|
|
variables. <function>hb_font_glyph_to_string(font, glyph, s,
|
|
size)</function> retrieves the name for the glyph ID
|
|
<parameter>glyph</parameter> from the font object. It generates a
|
|
generic name of the form <literal>gidDDD</literal> (where DDD is
|
|
the glyph index) if there is no name for the glyph in the
|
|
font. The <function>hb_font_glyph_from_string(font, s, len,
|
|
glyph)</function> takes an input string <parameter>s</parameter>
|
|
and looks for a glyph with that name in the font, returning its
|
|
glyph ID in the <parameter>glyph</parameter>
|
|
output parameter. It automatically parses
|
|
<literal>gidDDD</literal> and <literal>uniUUUU</literal> strings.
|
|
</para>
|
|
</section>
|
|
|
|
|
|
<!-- Commenting out FreeType integration section-holder for now. May move
|
|
to the full-blown Integration Chapter. -->
|
|
|
|
<!-- <section id="fonts-and-faces-freetype">
|
|
<title>Using FreeType</title>
|
|
<para>
|
|
|
|
</para>
|
|
<para>
|
|
|
|
</para>
|
|
</section> -->
|
|
|
|
<section id="fonts-and-faces-variable">
|
|
<title>Working with OpenType Variable Fonts</title>
|
|
<para>
|
|
If you are working with OpenType Variable Fonts, there are a few
|
|
additional functions you should use to specify the
|
|
variation-axis settings of your font object. Without doing so,
|
|
your variable font's font object can still be used, but only at
|
|
the default setting for every axis (which, of course, is
|
|
sometimes what you want, but does not cover general usage).
|
|
</para>
|
|
<para>
|
|
HarfBuzz manages variation settings in the
|
|
<type>hb_variation_t</type> data type, which holds a <property>tag</property> for the
|
|
variation-axis identifier tag and a <property>value</property> for its
|
|
setting. You can retrieve the list of variation axes in a font
|
|
binary from the face object (not from a font object, notably) by
|
|
calling <function>hb_ot_var_get_axis_count(face)</function> to
|
|
find the number of axes, then using
|
|
<function>hb_ot_var_get_axis_infos()</function> to collect the
|
|
axis structures:
|
|
</para>
|
|
<programlisting language="C">
|
|
axes = hb_ot_var_get_axis_count(face);
|
|
...
|
|
hb_ot_var_get_axis_infos(face, 0, axes, axes_array);
|
|
</programlisting>
|
|
<para>
|
|
For each axis returned in the array, you can can access the
|
|
identifier in its <property>tag</property>. HarfBuzz also has
|
|
tag definitions predefined for the five standard axes specified
|
|
in OpenType (<literal>ital</literal> for italic,
|
|
<literal>opsz</literal> for optical size,
|
|
<literal>slnt</literal> for slant, <literal>wdth</literal> for
|
|
width, and <literal>wght</literal> for weight). Each axis also
|
|
has a <property>min_value</property>, a
|
|
<property>default_value</property>, and a <property>max_value</property>.
|
|
</para>
|
|
<para>
|
|
To set your font object's variation settings, you call the
|
|
<function>hb_font_set_variations()</function> function with an
|
|
array of <type>hb_variation_t</type> variation settings. Let's
|
|
say our font has weight and width axes. We need to specify each
|
|
of the axes by tag and assign a value on the axis:
|
|
</para>
|
|
<programlisting language="C">
|
|
unsigned int variation_count = 2;
|
|
hb_variation_t variation_data[variation_count];
|
|
variation_data[0].tag = HB_OT_TAG_VAR_AXIS_WIDTH;
|
|
variation_data[1].tag = HB_OT_TAG_VAR_AXIS_WEIGHT;
|
|
variation_data[0].value = 80;
|
|
variation_data[1].value = 750;
|
|
...
|
|
hb_font_set_variations(font, variation_data, variation_count);
|
|
</programlisting>
|
|
<para>
|
|
That should give us a slightly condensed font ("normal" on the
|
|
<literal>wdth</literal> axis is 100) at a noticeably bolder
|
|
weight ("regular" is 400 on the <literal>wght</literal> axis).
|
|
</para>
|
|
<para>
|
|
In practice, though, you should always check that the value you
|
|
want to set on the axis is within the
|
|
[<property>min_value</property>,<property>max_value</property>]
|
|
range actually implemented in the font's variation axis. After
|
|
all, a font might only provide lighter-than-regular weights, and
|
|
setting a heavier value on the <literal>wght</literal> axis will
|
|
not change that.
|
|
</para>
|
|
<para>
|
|
Once your variation settings are specified on your font object,
|
|
however, shaping with a variable font is just like shaping a
|
|
static font.
|
|
</para>
|
|
</section>
|
|
|
|
</chapter>
|