## Fonts

Fonts — Font Handling

## Synopsis

    typedef     cairo_font_face_t;
    typedef     cairo_scaled_font_t;
    void        cairo_font_face_reference       (cairo_font_face_t *font_face);
    void        cairo_font_face_destroy         (cairo_font_face_t *font_face);
    void*       cairo_font_face_get_user_data   (cairo_font_face_t *font_face,
                                                 const cairo_user_data_key_t *key);
    cairo_status_t cairo_font_face_set_user_data
                                                (cairo_font_face_t *font_face,
                                                 const cairo_user_data_key_t *key,
                                                 void *user_data,
                                                 cairo_destroy_func_t destroy);
    cairo_scaled_font_t* cairo_scaled_font_create
                                                (cairo_font_face_t *font_face,
                                                 const cairo_matrix_t *font_matrix,
                                                 const cairo_matrix_t *ctm);
    void        cairo_scaled_font_reference     (cairo_scaled_font_t *scaled_font);
    void        cairo_scaled_font_destroy       (cairo_scaled_font_t *scaled_font);
                cairo_font_extents_t;
    cairo_status_t cairo_scaled_font_extents    (cairo_scaled_font_t *scaled_font,
                                                 cairo_font_extents_t *extents);
                cairo_text_extents_t;
    void        cairo_scaled_font_glyph_extents (cairo_scaled_font_t *scaled_font,
                                                 cairo_glyph_t *glyphs,
                                                 int num_glyphs,
                                                 cairo_text_extents_t *extents);

## Description

## Details

### cairo_font_face_t

    typedef struct _cairo_font_face cairo_font_face_t;

A cairo_font_face_t specifies all aspects of a font other than the size or font matrix (a font matrix is used to distort a font by sheering it or scaling it unequally in the two directions) . A font face can be set on a cairo_t by using `cairo_set_font_face()`; the size and font matrix are set with `cairo_set_font_size()` and `cairo_set_font_matrix()`.

### cairo_scaled_font_t

    typedef struct _cairo_scaled_font cairo_scaled_font_t;

A cairo_scaled_font_t is a font scaled to a particular size and device resolution. A cairo_scaled_font_t is most useful for low-level font usage where a library or application wants to cache a reference to a scaled font to speed up the computation of metrics.

### cairo_font_face_reference ()

    void        cairo_font_face_reference       (cairo_font_face_t *font_face);

Increases the reference count on `font_face` by one. This prevents `font_face` from being destroyed until a matching call to `cairo_font_face_destroy()` is made.

`font_face` : | a cairo_font_face_t, (may be NULL in which case this function does nothing).

### cairo_font_face_destroy ()

    void        cairo_font_face_destroy         (cairo_font_face_t *font_face);

Decreases the reference count on `font_face` by one. If the result is zero, then `font_face` and all associated resources are freed. See `cairo_font_face_reference()`.

`font_face` : | a cairo_font_face_t

### cairo_font_face_get_user_data ()

    void*       cairo_font_face_get_user_data   (cairo_font_face_t *font_face,
                                                 const cairo_user_data_key_t *key);

Return user data previously attached to `font_face` using the specified key. If no user data has been attached with the given key this function returns `NULL`.

`font_face` : | a cairo_font_face_t
`key` : | the address of the cairo_user_data_key_t the user data was attached to
Returns : | the user data previously attached or `NULL`.

### cairo_font_face_set_user_data ()

    cairo_status_t cairo_font_face_set_user_data
                                                (cairo_font_face_t *font_face,
                                                 const cairo_user_data_key_t *key,
                                                 void *user_data,
                                                 cairo_destroy_func_t destroy);

Attach user data to `font_face`. To remove user data from a font face, call this function with the key that was used to set it and `NULL` for `data`.

`font_face` : | a cairo_font_face_t
`key` : | the address of a cairo_user_data_key_t to attach the user data to
`user_data` : | the user data to attach to the font face
`destroy` : | a cairo_destroy_func_t which will be called when the font face is destroyed or when new user data is attached using the same key.
Returns : | `CAIRO_STATUS_SUCCESS` or `CAIRO_STATUS_NO_MEMORY` if a slot could not be allocated for the user data.

### cairo_scaled_font_create ()

    cairo_scaled_font_t* cairo_scaled_font_create
                                                (cairo_font_face_t *font_face,
                                                 const cairo_matrix_t *font_matrix,
                                                 const cairo_matrix_t *ctm);

Creates a cairo_scaled_font_t object from a font face and matrices that describe the size of the font and the environment in which it will be used.

`font_face` : | a cairo_font_face_t
`font_matrix` : | font space to user space transformation matrix for the font. In the simplest case of a N point font, this matrix is just a scale by N, but it can also be used to shear the font or stretch it unequally along the two axes. See `cairo_set_font_matrix()`.
`ctm` : | user to device transformation matrix with which the font will be used.
Returns : | a newly created cairo_scaled_font_t. Destroy with `cairo_scaled_font_destroy()`

### cairo_scaled_font_reference ()

    void        cairo_scaled_font_reference     (cairo_scaled_font_t *scaled_font);

Increases the reference count on `scaled_font` by one. This prevents `scaled_font` from being destroyed until a matching call to `cairo_scaled_font_destroy()` is made.

`scaled_font` : | a cairo_scaled_font_t, (may be NULL in which case this function does nothing)

### cairo_scaled_font_destroy ()

    void        cairo_scaled_font_destroy       (cairo_scaled_font_t *scaled_font);

Decreases the reference count on `font` by one. If the result is zero, then `font` and all associated resources are freed. See `cairo_scaled_font_reference()`.

`scaled_font` : | a cairo_scaled_font_t

### cairo_font_extents_t

    typedef struct {
        double ascent;
        double descent;
        double height;
        double max_x_advance;
        double max_y_advance;
    } cairo_font_extents_t;

The cairo_text_extents_t structure stores metric information for a font. Values are given in the current user-space coordinate system.

Because font metrics are in user-space coordinates, they are mostly, but not entirely, independent of the current transformation matrix. If you call `cairo_scale(cr, 2.0, 2.0)`, text will be drawn twice as big, but the reported text extents will not be doubled. They will change slightly due to hinting (so you can't assume that metrics are independent of the transformation matrix), but otherwise will remain unchanged.

double `ascent`; | the distance that the font extends above the baseline. Note that this is not always exactly equal to the maximum of the extents of all the glyphs in the font, but rather is picked to express the font designer's intent as to how the font should align with elements above it.
double `descent`; | the distance that the font extends below the baseline. This value is positive for typical fonts that include portions below the baseline. Note that this is not always exactly equal to the maximum of the extents of all the glyphs in the font, but rather is picked to express the font designer's intent as to how the the font should align with elements below it.
double `height`; | the recommended vertical distance between baselines when setting consecutive lines of text with the font. This is greater than `ascent`+`descent` by a quantity known as the line spacing or external leading. When space is at a premium, most fonts can be set with only a distance of `ascent`+`descent` between lines.
double `max_x_advance`; | the maximum distance in the X direction that the the origin is advanced for any glyph in the font.
double `max_y_advance`; | the maximum distance in the Y direction that the the origin is advanced for any glyph in the font. this will be zero for normal fonts used for horizontal writing. (The scripts of East Asia are sometimes written vertically.)

### cairo_scaled_font_extents ()

    cairo_status_t cairo_scaled_font_extents    (cairo_scaled_font_t *scaled_font,
                                                 cairo_font_extents_t *extents);

Gets the metrics for a cairo_scaled_font_t.

`scaled_font` : | a cairo_scaled_font_t
`extents` : | a cairo_font_extents_t which to store the retrieved extents.
Returns : | `CAIRO_STATUS_SUCCESS` on success. Otherwise, an error such as `CAIRO_STATUS_NO_MEMORY`.

### cairo_text_extents_t

    typedef struct {
        double x_bearing;
        double y_bearing;
        double width;
        double height;
        double x_advance;
        double y_advance;
    } cairo_text_extents_t;

The cairo_text_extents_t structure stores the extents of a single glyph or a string of glyphs in user-space coordinates. Because text extents are in user-space coordinates, they are mostly, but not entirely, independent of the current transformation matrix. If you call `cairo_scale(cr, 2.0, 2.0)`, text will be drawn twice as big, but the reported text extents will not be doubled. They will change slightly due to hinting (so you can't assume that metrics are independent of the transformation matrix), but otherwise will remain unchanged.

double `x_bearing`; | the horizontal distance from the origin to the leftmost part of the glyphs as drawn. Positive if the glyphs lie entirely to the right of the origin.
double `y_bearing`; | the vertical distance from the origin to the topmost part of the glyphs as drawn. Positive only if the glyphs lie completely below the origin; will usually be negative.
double `width`; | width of the glyphs as drawn
double `height`; | height of the glyphs as drawn
double `x_advance`; | distance to advance in the X direction after drawing these glyphs
double `y_advance`; | distance to advance in the Y direction after drawing these glyphs. Will typically be zero except for vertical text layout as found in East-Asian languages.

### cairo_scaled_font_glyph_extents ()

    void        cairo_scaled_font_glyph_extents (cairo_scaled_font_t *scaled_font,
                                                 cairo_glyph_t *glyphs,
                                                 int num_glyphs,
                                                 cairo_text_extents_t *extents);

`scaled_font` : |
`glyphs` : |
`num_glyphs` : |
`extents` : |