/* Fontconfig version older than 2.6 didn't have these options */ #ifndef FC_LCD_FILTER #define FC_LCD_FILTER "lcdfilter" #endif /* Some Ubuntu versions defined FC_LCD_FILTER without defining the following */ #ifndef FC_LCD_NONE #define FC_LCD_NONE 0 #define FC_LCD_DEFAULT 1 #define FC_LCD_LIGHT 2 #define FC_LCD_LEGACY 3 #endif
/* FreeType version older than 2.3.5(?) didn't have these options */ #ifndef FT_LCD_FILTER_NONE #define FT_LCD_FILTER_NONE 0 #define FT_LCD_FILTER_DEFAULT 1 #define FT_LCD_FILTER_LIGHT 2 #define FT_LCD_FILTER_LEGACY 16 #endif
/* FreeType version older than 2.11 does not have the FT_RENDER_MODE_SDF enum value in FT_Render_Mode */ #if FREETYPE_MAJOR > 2 || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR >= 11) #define HAVE_FT_RENDER_MODE_SDF 1 #endif
/** * Function types for FreeType symbols we'll look up at runtime, rather than * relying on build-time checks for availability.
*/ typedef FT_Error (*GetVarFunc) (FT_Face, FT_MM_Var**); typedef FT_Error (*DoneVarFunc) (FT_Library, FT_MM_Var*); typedef FT_Error (*GetVarDesignCoordsFunc) (FT_Face, FT_UInt, FT_Fixed*); typedef FT_Error (*SetVarDesignCoordsFunc) (FT_Face, FT_UInt, FT_Fixed*); typedef FT_Error (*GetVarBlendCoordsFunc) (FT_Face, FT_UInt, FT_Fixed*);
/** * SECTION:cairo-ft * @Title: FreeType Fonts * @Short_Description: Font support for FreeType * @See_Also: #cairo_font_face_t * * The FreeType font backend is primarily used to render text on GNU/Linux * systems, but can be used on other platforms too.
**/
/** * CAIRO_HAS_FT_FONT: * * Defined if the FreeType font backend is available. * This macro can be used to conditionally compile backend-specific code. * * Since: 1.0
**/
/** * CAIRO_HAS_FC_FONT: * * Defined if the Fontconfig-specific functions of the FreeType font backend * are available. * This macro can be used to conditionally compile backend-specific code. * * Since: 1.10
**/
/* * The simple 2x2 matrix is converted into separate scale and shape * factors so that hinting works right
*/
/* * We create an object that corresponds to a single font on the disk; * (identified by a filename/id pair) these are shared between all * fonts using that file. For cairo_ft_font_face_create_for_ft_face(), we * just create a one-off version with a permanent face value.
*/
cairo_bool_t from_face; /* was the FT_Face provided by user? */
FT_Face face; /* provided or cached face */ void *face_context;
/* only set if from_face is false */ char *filename; int id;
/* We temporarily scale the unscaled font as needed */
cairo_bool_t have_scale;
cairo_matrix_t current_scale; double x_scale; /* Extracted X scale factor */ double y_scale; /* Extracted Y scale factor */
cairo_bool_t have_shape; /* true if the current scale has a non-scale component*/
cairo_matrix_t current_shape;
FT_Matrix Current_Shape;
unsignedint have_color_set : 1; unsignedint have_color : 1; /* true if the font contains color glyphs */
FT_Fixed *variations; /* variation settings that FT_Face came */ unsignedint num_palettes;
cairo_mutex_t mutex; int lock_count;
cairo_ft_font_face_t *faces; /* Linked list of faces for this font */
};
#if CAIRO_HAS_FC_FONT
FcPattern *pattern; /* if pattern is set, the above fields will be NULL */
cairo_font_face_t *resolved_font_face;
FcConfig *resolved_config; #endif
};
cairo_status_t
_cairo_ft_to_cairo_error (FT_Error error)
{ /* Currently we don't get many (any?) useful statuses here.
* Populate as needed. */ switch (error)
{ case FT_Err_Ok: return CAIRO_STATUS_SUCCESS; case FT_Err_Out_Of_Memory: return CAIRO_STATUS_NO_MEMORY; default: return CAIRO_STATUS_FREETYPE_ERROR;
}
}
/* * We maintain a hash table to map file/id => #cairo_ft_unscaled_font_t. * The hash table itself isn't limited in size. However, we limit the * number of FT_Face objects we keep around; when we've exceeded that * limit and need to create a new FT_Face, we dump the FT_Face from a * random #cairo_ft_unscaled_font_t which has an unlocked FT_Face, (if * there are any).
*/
/* This function is only intended to be called from * _cairo_ft_unscaled_font_map_lock. So we'll crash if we can
* detect some other call path. */
assert (cairo_ft_unscaled_font_map == NULL);
hash = _cairo_hash_string (filename); /* the constants are just arbitrary primes */
hash += ((uintptr_t) id) * 1607;
hash += ((uintptr_t) face) * 2137;
key->base.hash_entry.hash = hash;
}
/** * _cairo_ft_unscaled_font_init: * * Initialize a #cairo_ft_unscaled_font_t. * * There are two basic flavors of #cairo_ft_unscaled_font_t, one * created from an FT_Face and the other created from a filename/id * pair. These two flavors are identified as from_face and !from_face. * * To initialize a from_face font, pass filename==%NULL, id=0 and the * desired face. * * To initialize a !from_face font, pass the filename/id as desired * and face==%NULL. * * Note that the code handles these two flavors in very distinct * ways. For example there is a hash_table mapping * filename/id->#cairo_unscaled_font_t in the !from_face case, but no * parallel in the from_face case, (where the calling code would have * to do its own mapping to ensure similar sharing).
**/ static cairo_status_t
_cairo_ft_unscaled_font_init (cairo_ft_unscaled_font_t *unscaled,
cairo_bool_t from_face, constchar *filename, int id,
FT_Face face, void *face_context)
{
_cairo_unscaled_font_init (&unscaled->base,
&cairo_ft_unscaled_font_backend);
/** * _cairo_ft_unscaled_font_fini: * * Free all data associated with a #cairo_ft_unscaled_font_t. * * CAUTION: The unscaled->face field must be %NULL before calling this * function. This is because the #cairo_ft_unscaled_font_t_map keeps a * count of these faces (font_map->num_open_faces) so it maintains the * unscaled->face field while it has its lock held. See * _font_map_release_face_lock_held().
**/ staticvoid
_cairo_ft_unscaled_font_fini (cairo_ft_unscaled_font_t *unscaled)
{
assert (unscaled->face == NULL);
/* Finds or creates a #cairo_ft_unscaled_font_t for the filename/id from * pattern. Returns a new reference to the unscaled font.
*/ static cairo_status_t
_cairo_ft_unscaled_font_create_internal (cairo_bool_t from_face, char *filename, int id,
FT_Face font_face, void *face_context,
cairo_ft_unscaled_font_t **out)
{
cairo_ft_unscaled_font_t key, *unscaled;
cairo_ft_unscaled_font_map_t *font_map;
cairo_status_t status;
/* Return existing unscaled font if it exists in the hash table. */
unscaled = _cairo_hash_table_lookup (font_map->hash_table,
&key.base.hash_entry); if (unscaled != NULL) {
_cairo_unscaled_font_reference (&unscaled->base); goto DONE;
}
/* Otherwise create it and insert into hash table. */
unscaled = _cairo_malloc (sizeof (cairo_ft_unscaled_font_t)); if (unlikely (unscaled == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto UNWIND_FONT_MAP_LOCK;
}
status = _cairo_ft_unscaled_font_init (unscaled, from_face, filename, id, font_face, face_context); if (unlikely (status)) goto UNWIND_UNSCALED_MALLOC;
assert (unscaled->base.hash_entry.hash == key.base.hash_entry.hash);
status = _cairo_hash_table_insert (font_map->hash_table,
&unscaled->base.hash_entry); if (unlikely (status)) goto UNWIND_UNSCALED_FONT_INIT;
ret = FcPatternGetFTFace (pattern, FC_FT_FACE, 0, &font_face); if (ret == FcResultMatch) goto DONE; if (ret == FcResultOutOfMemory) return _cairo_error (CAIRO_STATUS_NO_MEMORY);
ret = FcPatternGetString (pattern, FC_FILE, 0, (FcChar8 **) &filename); if (ret == FcResultOutOfMemory) return _cairo_error (CAIRO_STATUS_NO_MEMORY); if (ret == FcResultMatch) { if (access (filename, R_OK) == 0) { /* If FC_INDEX is not set, we just use 0 */
ret = FcPatternGetInteger (pattern, FC_INDEX, 0, &id); if (ret == FcResultOutOfMemory) return _cairo_error (CAIRO_STATUS_NO_MEMORY);
font_map = _cairo_ft_unscaled_font_map_lock (); /* All created objects must have been mapped in the font map. */
assert (font_map != NULL);
if (! _cairo_reference_count_dec_and_test (&unscaled->base.ref_count)) { /* somebody recreated the font whilst we waited for the lock */
_cairo_ft_unscaled_font_map_unlock (); returnFALSE;
}
/* Ensures that an unscaled font has a face object. If we exceed * MAX_OPEN_FACES, try to close some. * * This differs from _cairo_ft_scaled_font_lock_face in that it doesn't * set the scale on the face, but just returns it at the last scale.
*/ static cairo_warn FT_Face
_cairo_ft_unscaled_font_lock_face (cairo_ft_unscaled_font_t *unscaled)
{
cairo_ft_unscaled_font_map_t *font_map;
FT_Face face = NULL;
FT_Error error;
if (unscaled->face_context) { if (!mozilla_LockSharedFTFace (unscaled->face_context, unscaled)) {
unscaled->have_scale = FALSE;
}
} else {
CAIRO_FT_LOCK (unscaled);
}
unscaled->lock_count++;
if (unscaled->face) return unscaled->face;
/* If this unscaled font was created from an FT_Face then we just
* returned it above. */
assert (!unscaled->from_face);
/* The font matrix has x and y "scale" components which we extract and * use as character scale values. These influence the way freetype * chooses hints, as well as selecting different bitmaps in * hand-rendered fonts. We also copy the normalized matrix to * freetype's transformation.
*/
status = _cairo_matrix_compute_basis_scale_factors (scale,
&x_scale, &y_scale,
1); if (unlikely (status)) return status;
/* FreeType docs say this about x_scale and y_scale: * "A character width or height smaller than 1pt is set to 1pt;" * So, we cap them from below at 1.0 and let the FT transform
* take care of sub-1.0 scaling. */ if (x_scale < 1.0)
x_scale = 1.0; if (y_scale < 1.0)
y_scale = 1.0;
for (i = 0; i < unscaled->face->num_fixed_sizes; i++) { double x_size = unscaled->face->available_sizes[i].x_ppem / 64.; double y_size = unscaled->face->available_sizes[i].y_ppem / 64.; double distance = y_size - y_scale;
/* * distance is positive if current strike is larger than desired * size, and negative if smaller. * * We like to prefer down-scaling to upscaling.
*/
/* Temporarily scales an unscaled font to the give scale. We catch * scaling to the same size, since changing a FT_Face is expensive.
*/ static cairo_status_t
_cairo_ft_unscaled_font_set_scale (cairo_ft_unscaled_font_t *unscaled,
cairo_matrix_t *scale)
{
cairo_status_t status;
cairo_ft_font_transform_t sf;
FT_Matrix mat;
FT_Error error;
/* we sometimes need to convert the glyph bitmap in a FT_GlyphSlot * into a different format. For example, we want to convert a * FT_PIXEL_MODE_LCD or FT_PIXEL_MODE_LCD_V bitmap into a 32-bit * ARGB or ABGR bitmap. * * this function prepares a target descriptor for this operation. * * input :: target bitmap descriptor. The function will set its * 'width', 'rows' and 'pitch' fields, and only these * * slot :: the glyph slot containing the source bitmap. this * function assumes that slot->format == FT_GLYPH_FORMAT_BITMAP * * mode :: the requested final rendering mode. supported values are * MONO, NORMAL (i.e. gray), LCD and LCD_V * * the function returns the size in bytes of the corresponding buffer, * it's up to the caller to allocate the corresponding memory block * before calling _fill_xrender_bitmap * * it also returns -1 in case of error (e.g. incompatible arguments, * like trying to convert a gray bitmap into a monochrome one)
*/ staticint
_compute_xrender_bitmap_size(FT_Bitmap *target,
FT_GlyphSlot slot,
FT_Render_Mode mode)
{
FT_Bitmap *ftbit; int width, height, pitch;
if (slot->format != FT_GLYPH_FORMAT_BITMAP) return -1;
/* compute the size of the final bitmap */
ftbit = &slot->bitmap;
case FT_PIXEL_MODE_GRAY: if (mode == FT_RENDER_MODE_LCD ||
mode == FT_RENDER_MODE_LCD_V)
{ /* each pixel is replicated into a 32-bit ARGB value */
pitch = width * 4;
} break;
case FT_PIXEL_MODE_LCD: if (mode != FT_RENDER_MODE_LCD) return -1;
/* horz pixel triplets are packed into 32-bit ARGB values */
width /= 3;
pitch = width * 4; break;
case FT_PIXEL_MODE_LCD_V: if (mode != FT_RENDER_MODE_LCD_V) return -1;
/* vert pixel triplets are packed into 32-bit ARGB values */
height /= 3;
pitch = width * 4; break;
#ifdef FT_LOAD_COLOR case FT_PIXEL_MODE_BGRA: /* each pixel is replicated into a 32-bit ARGB value */
pitch = width * 4; break; #endif
default: /* unsupported source format */ return -1;
}
/* this functions converts the glyph bitmap found in a FT_GlyphSlot * into a different format (see _compute_xrender_bitmap_size) * * you should call this function after _compute_xrender_bitmap_size * * target :: target bitmap descriptor. Note that its 'buffer' pointer * must point to memory allocated by the caller * * slot :: the glyph slot containing the source bitmap * * mode :: the requested final rendering mode * * bgr :: boolean, set if BGR or VBGR pixel ordering is needed
*/ staticvoid
_fill_xrender_bitmap(FT_Bitmap *target,
FT_GlyphSlot slot,
FT_Render_Mode mode, int bgr)
{
FT_Bitmap *ftbit = &slot->bitmap; unsignedchar *srcLine = ftbit->buffer; unsignedchar *dstLine = target->buffer; int src_pitch = ftbit->pitch; int width = target->width; int height = target->rows; int pitch = target->pitch; int subpixel; int h;
while (count--) {
*d = CAIRO_BITSWAP8 (*d);
d++;
}
} #endif
format = CAIRO_FORMAT_A1; break;
case FT_PIXEL_MODE_LCD: case FT_PIXEL_MODE_LCD_V: case FT_PIXEL_MODE_GRAY: if (font_options->antialias != CAIRO_ANTIALIAS_SUBPIXEL ||
bitmap->pixel_mode == FT_PIXEL_MODE_GRAY)
{
stride = bitmap->pitch;
/* We don't support stride not multiple of 4. */ if (stride & 3)
{
assert (!own_buffer); goto convert;
}
if (own_buffer) {
data = bitmap->buffer;
} else {
data = _cairo_malloc_ab (height, stride); if (!data) return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (!_cairo_is_little_endian ())
{ /* Byteswap. */ unsignedint i, count = height * width;
uint32_t *p = (uint32_t *) data; for (i = 0; i < count; i++)
p[i] = bswap_32 (p[i]);
}
format = CAIRO_FORMAT_ARGB32; break; #endif case FT_PIXEL_MODE_GRAY2: case FT_PIXEL_MODE_GRAY4:
convert: if (!own_buffer && library)
{ /* This is pretty much the only case that we can get in here. */ /* Convert to 8bit grayscale. */
stride = bitmap->pitch;
data = _cairo_malloc_ab (height, stride); if (!data) return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (bitmap->num_grays != 256)
{ unsignedint x, y; unsignedint mul = 255 / (bitmap->num_grays - 1);
FT_Byte *p = bitmap->buffer; for (y = 0; y < height; y++) { for (x = 0; x < width; x++)
p[x] *= mul;
p += bitmap->pitch;
}
}
memcpy (data, bitmap->buffer, (size_t)stride * height); break;
} /* fall through */ /* These could be triggered by very rare types of TrueType fonts */ default: if (own_buffer)
free (bitmap->buffer); return _cairo_error (CAIRO_STATUS_INVALID_FORMAT);
}
/* Converts an outline FT_GlyphSlot into an image * * This could go through _render_glyph_bitmap as well, letting * FreeType convert the outline to a bitmap, but doing it ourselves * has two minor advantages: first, we save a copy of the bitmap * buffer: we can directly use the buffer that FreeType renders * into. * * Second, it may help when we add support for subpixel * rendering: the Xft code does it this way. (Keith thinks that * it may also be possible to get the subpixel rendering with * FT_Render_Glyph: something worth looking into in more detail * when we add subpixel support. If so, we may want to eliminate * this version of the code path entirely.
*/ static cairo_status_t
_render_glyph_outline (FT_Face face,
cairo_font_options_t *font_options,
cairo_image_surface_t **surface)
{ int rgba = FC_RGBA_UNKNOWN; int lcd_filter = FT_LCD_FILTER_DEFAULT;
FT_GlyphSlot glyphslot = face->glyph;
FT_Outline *outline = &glyphslot->outline;
FT_Bitmap bitmap;
FT_BBox cbox; unsignedint width, height;
cairo_status_t status;
FT_Error error;
FT_Library library = glyphslot->library;
FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;
switch (font_options->antialias) { case CAIRO_ANTIALIAS_NONE:
render_mode = FT_RENDER_MODE_MONO; break;
case CAIRO_ANTIALIAS_SUBPIXEL: case CAIRO_ANTIALIAS_BEST: switch (font_options->subpixel_order) { case CAIRO_SUBPIXEL_ORDER_DEFAULT: case CAIRO_SUBPIXEL_ORDER_RGB: case CAIRO_SUBPIXEL_ORDER_BGR:
render_mode = FT_RENDER_MODE_LCD; break;
case CAIRO_SUBPIXEL_ORDER_VRGB: case CAIRO_SUBPIXEL_ORDER_VBGR:
render_mode = FT_RENDER_MODE_LCD_V; break;
}
switch (font_options->lcd_filter) { case CAIRO_LCD_FILTER_NONE:
lcd_filter = FT_LCD_FILTER_NONE; break; case CAIRO_LCD_FILTER_INTRA_PIXEL:
lcd_filter = FT_LCD_FILTER_LEGACY; break; case CAIRO_LCD_FILTER_FIR3:
lcd_filter = FT_LCD_FILTER_LIGHT; break; case CAIRO_LCD_FILTER_DEFAULT: case CAIRO_LCD_FILTER_FIR5:
lcd_filter = FT_LCD_FILTER_DEFAULT; break;
}
break;
case CAIRO_ANTIALIAS_DEFAULT: case CAIRO_ANTIALIAS_GRAY: case CAIRO_ANTIALIAS_GOOD: case CAIRO_ANTIALIAS_FAST:
render_mode = FT_RENDER_MODE_NORMAL;
}
if (width * height == 0) {
cairo_format_t format; /* Looks like fb handles zero-sized images just fine */ switch (render_mode) { case FT_RENDER_MODE_MONO:
format = CAIRO_FORMAT_A1; break; case FT_RENDER_MODE_LCD: case FT_RENDER_MODE_LCD_V:
format= CAIRO_FORMAT_ARGB32; break; case FT_RENDER_MODE_LIGHT: case FT_RENDER_MODE_NORMAL: case FT_RENDER_MODE_MAX: #if HAVE_FT_RENDER_MODE_SDF case FT_RENDER_MODE_SDF: #endif default:
format = CAIRO_FORMAT_A8; break;
}
(*surface) = (cairo_image_surface_t *)
cairo_image_surface_create_for_data (NULL, format, 0, 0, 0);
pixman_image_set_component_alpha ((*surface)->pixman_image, TRUE); if ((*surface)->base.status) return (*surface)->base.status;
} else {
int bitmap_size;
switch (render_mode) { case FT_RENDER_MODE_LCD: if (font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_BGR)
rgba = FC_RGBA_BGR; else
rgba = FC_RGBA_RGB; break;
case FT_RENDER_MODE_LCD_V: if (font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_VBGR)
rgba = FC_RGBA_VBGR; else
rgba = FC_RGBA_VRGB; break;
case FT_RENDER_MODE_MONO: case FT_RENDER_MODE_LIGHT: case FT_RENDER_MODE_NORMAL: case FT_RENDER_MODE_MAX: #if HAVE_FT_RENDER_MODE_SDF case FT_RENDER_MODE_SDF: #endif default: break;
}
/* Note: * _get_bitmap_surface will free bitmap.buffer if there is an error
*/
status = _get_bitmap_surface (&bitmap, NULL, TRUE, font_options, surface); if (unlikely (status)) return status;
/* Note: the font's coordinate system is upside down from ours, so the * Y coordinate of the control box needs to be negated. Moreover, device * offsets are position of glyph origin relative to top left while xMin * and yMax are offsets of top left relative to origin. Another negation.
*/
cairo_surface_set_device_offset (&(*surface)->base,
(double)-glyphslot->bitmap_left,
(double)+glyphslot->bitmap_top);
}
return CAIRO_STATUS_SUCCESS;
}
/* Converts a bitmap (or other) FT_GlyphSlot into an image */ static cairo_status_t
_render_glyph_bitmap (FT_Face face,
cairo_font_options_t *font_options,
cairo_image_surface_t **surface)
{
FT_GlyphSlot glyphslot = face->glyph;
cairo_status_t status;
FT_Error error;
/* According to the FreeType docs, glyphslot->format could be * something other than FT_GLYPH_FORMAT_OUTLINE or * FT_GLYPH_FORMAT_BITMAP. Calling FT_Render_Glyph gives FreeType * the opportunity to convert such to * bitmap. FT_GLYPH_FORMAT_COMPOSITE will not be encountered since * we avoid the FT_LOAD_NO_RECURSE flag.
*/
error = FT_Render_Glyph (glyphslot, FT_RENDER_MODE_NORMAL); /* XXX ignoring all other errors for now. They are not fatal, typically
* just a glyph-not-found. */ if (error == FT_Err_Out_Of_Memory) return _cairo_error (CAIRO_STATUS_NO_MEMORY);
status = _get_bitmap_surface (&glyphslot->bitmap,
glyphslot->library, FALSE, font_options,
surface); if (unlikely (status)) return status;
/* * Note: the font's coordinate system is upside down from ours, so the * Y coordinate of the control box needs to be negated. Moreover, device * offsets are position of glyph origin relative to top left while * bitmap_left and bitmap_top are offsets of top left relative to origin. * Another negation.
*/
cairo_surface_set_device_offset (&(*surface)->base,
-glyphslot->bitmap_left,
+glyphslot->bitmap_top);
/* We want to compute a transform that takes the origin * (device_x_offset, device_y_offset) to 0,0, then applies * the "shape" portion of the font transform
*/
original_to_transformed = *shape;
for (i = 1; i < 4; i++) { if (x[i] < x_min)
x_min = floor (x[i]); elseif (x[i] > x_max)
x_max = ceil (x[i]); if (y[i] < y_min)
y_min = floor (y[i]); elseif (y[i] > y_max)
y_max = ceil (y[i]);
}
/* Adjust the transform so that the bounding box starts at 0,0 ... * this gives our final transform from original bitmap to transformed * bitmap.
*/
original_to_transformed.x0 -= x_min;
original_to_transformed.y0 -= y_min;
/* Draw the original bitmap transformed into the new bitmap
*/
_cairo_pattern_init_for_surface (&pattern, &(*surface)->base);
cairo_pattern_set_matrix (&pattern.base, &transformed_to_original);
status = _cairo_surface_paint (image,
CAIRO_OPERATOR_SOURCE,
&pattern.base,
NULL);
_cairo_pattern_fini (&pattern.base);
if (unlikely (status)) {
cairo_surface_destroy (image); return status;
}
/* Now update the cache entry for the new bitmap, recomputing * the origin based on the final transform.
*/
cairo_matrix_transform_point (&original_to_transformed,
&origin_x, &origin_y);
#if CAIRO_HAS_FC_FONT /* The load flags passed to FT_Load_Glyph control aspects like hinting and * antialiasing. Here we compute them from the fields of a FcPattern.
*/ staticvoid
_get_pattern_ft_options (FcPattern *pattern, cairo_ft_options_t *ret)
{
FcBool antialias, vertical_layout, hinting, autohint, bitmap, embolden;
cairo_ft_options_t ft_options; int rgba; #ifdef FC_HINT_STYLE int hintstyle; #endif char *variations;
/* Check whether to force use of embedded bitmaps */ if (FcPatternGetBool (pattern,
FC_EMBEDDED_BITMAP, 0, &bitmap) != FcResultMatch)
bitmap = FcFalse;
/* disable antialiasing if requested */ if (FcPatternGetBool (pattern,
FC_ANTIALIAS, 0, &antialias) != FcResultMatch)
antialias = FcTrue;
if (antialias) {
cairo_subpixel_order_t subpixel_order; int lcd_filter;
/* disable hinting if requested */ if (FcPatternGetBool (pattern,
FC_HINTING, 0, &hinting) != FcResultMatch)
hinting = FcTrue;
status = _cairo_scaled_font_init (&scaled_font->base,
&font_face->base,
font_matrix, ctm, options,
&_cairo_ft_scaled_font_backend); if (unlikely (status)) goto CLEANUP_SCALED_FONT;
status = _cairo_ft_unscaled_font_set_scale (unscaled,
&scaled_font->base.scale); if (unlikely (status)) { /* This can only fail if we encounter an error with the underlying
* font, so propagate the error back to the font-face. */
_cairo_ft_unscaled_font_unlock_face (unscaled);
_cairo_unscaled_font_destroy (&unscaled->base);
free (scaled_font); return status;
}
metrics = &face->size->metrics;
/* * Get to unscaled metrics so that the upper level can get back to * user space * * Also use this path for bitmap-only fonts. The other branch uses * face members that are only relevant for scalable fonts. This is * detected by simply checking for units_per_EM==0.
*/ if (scaled_font->base.options.hint_metrics != CAIRO_HINT_METRICS_OFF ||
face->units_per_EM == 0) { double x_factor, y_factor;
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
