mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-20 14:31:10 +01:00
937 lines
26 KiB
C++
937 lines
26 KiB
C++
/*
|
|
* Copyright © 2026 Behdad Esfahbod
|
|
*
|
|
* This is part of HarfBuzz, a text shaping library.
|
|
*
|
|
* Permission is hereby granted, without written agreement and without
|
|
* license or royalty fees, to use, copy, modify, and distribute this
|
|
* software and its documentation for any purpose, provided that the
|
|
* above copyright notice and the following two paragraphs appear in
|
|
* all copies of this software.
|
|
*
|
|
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
|
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
|
|
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
|
* DAMAGE.
|
|
*
|
|
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
|
|
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
|
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
|
|
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|
*
|
|
* Author(s): Behdad Esfahbod
|
|
*/
|
|
|
|
#include "hb.hh"
|
|
|
|
#include "hb-vector-draw.hh"
|
|
#include "hb-vector-path.hh"
|
|
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
HB_UNUSED static inline bool
|
|
hb_vector_svg_buffer_contains (const hb_vector_buf_t &buf, const char *needle)
|
|
{
|
|
unsigned nlen = (unsigned) strlen (needle);
|
|
if (!nlen || buf.length < nlen)
|
|
return false;
|
|
|
|
for (unsigned i = 0; i + nlen <= buf.length; i++)
|
|
if (buf.arrayZ[i] == needle[0] &&
|
|
!memcmp (buf.arrayZ + i, needle, nlen))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/* ---- SVG draw callbacks ---- */
|
|
|
|
static void hb_vector_draw_svg_move_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->path.append_c ('M'); d->append_xy_svg (x, y); }
|
|
|
|
static void hb_vector_draw_svg_line_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->path.append_c ('L'); d->append_xy_svg (x, y); }
|
|
|
|
static void hb_vector_draw_svg_quadratic_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float cx, float cy, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->path.append_c ('Q'); d->append_xy_svg (cx, cy); d->path.append_c (' '); d->append_xy_svg (x, y); }
|
|
|
|
static void hb_vector_draw_svg_cubic_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float c1x, float c1y, float c2x, float c2y, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->path.append_c ('C'); d->append_xy_svg (c1x, c1y); d->path.append_c (' '); d->append_xy_svg (c2x, c2y); d->path.append_c (' '); d->append_xy_svg (x, y); }
|
|
|
|
static void hb_vector_draw_svg_close_path (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, void *)
|
|
{ ((hb_vector_draw_t *) dd)->path.append_c ('Z'); }
|
|
|
|
|
|
/* ---- PDF draw callbacks ---- */
|
|
|
|
static void hb_vector_draw_pdf_move_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->append_xy_pdf (x, y); d->path.append_str (" m\n"); }
|
|
|
|
static void hb_vector_draw_pdf_line_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->append_xy_pdf (x, y); d->path.append_str (" l\n"); }
|
|
|
|
/* No quadratic_to — null fallback auto-promotes to cubic. */
|
|
|
|
static void hb_vector_draw_pdf_cubic_to (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, float c1x, float c1y, float c2x, float c2y, float x, float y, void *)
|
|
{ auto *d = (hb_vector_draw_t *) dd; d->append_xy_pdf (c1x, c1y); d->path.append_c (' '); d->append_xy_pdf (c2x, c2y); d->path.append_c (' '); d->append_xy_pdf (x, y); d->path.append_str (" c\n"); }
|
|
|
|
static void hb_vector_draw_pdf_close_path (hb_draw_funcs_t *, void *dd, hb_draw_state_t *, void *)
|
|
{ ((hb_vector_draw_t *) dd)->path.append_str ("h\n"); }
|
|
|
|
|
|
/* ---- Lazy loaders ---- */
|
|
|
|
static inline void free_static_vector_draw_svg_funcs ();
|
|
static struct hb_vector_draw_svg_funcs_lazy_loader_t
|
|
: hb_draw_funcs_lazy_loader_t<hb_vector_draw_svg_funcs_lazy_loader_t>
|
|
{
|
|
static hb_draw_funcs_t *create ()
|
|
{
|
|
hb_draw_funcs_t *funcs = hb_draw_funcs_create ();
|
|
hb_draw_funcs_set_move_to_func (funcs, (hb_draw_move_to_func_t) hb_vector_draw_svg_move_to, nullptr, nullptr);
|
|
hb_draw_funcs_set_line_to_func (funcs, (hb_draw_line_to_func_t) hb_vector_draw_svg_line_to, nullptr, nullptr);
|
|
hb_draw_funcs_set_quadratic_to_func (funcs, (hb_draw_quadratic_to_func_t) hb_vector_draw_svg_quadratic_to, nullptr, nullptr);
|
|
hb_draw_funcs_set_cubic_to_func (funcs, (hb_draw_cubic_to_func_t) hb_vector_draw_svg_cubic_to, nullptr, nullptr);
|
|
hb_draw_funcs_set_close_path_func (funcs, (hb_draw_close_path_func_t) hb_vector_draw_svg_close_path, nullptr, nullptr);
|
|
hb_draw_funcs_make_immutable (funcs);
|
|
hb_atexit (free_static_vector_draw_svg_funcs);
|
|
return funcs;
|
|
}
|
|
} static_vector_draw_svg_funcs;
|
|
static inline void free_static_vector_draw_svg_funcs () { static_vector_draw_svg_funcs.free_instance (); }
|
|
|
|
static inline void free_static_vector_draw_pdf_funcs ();
|
|
static struct hb_vector_draw_pdf_funcs_lazy_loader_t
|
|
: hb_draw_funcs_lazy_loader_t<hb_vector_draw_pdf_funcs_lazy_loader_t>
|
|
{
|
|
static hb_draw_funcs_t *create ()
|
|
{
|
|
hb_draw_funcs_t *funcs = hb_draw_funcs_create ();
|
|
hb_draw_funcs_set_move_to_func (funcs, (hb_draw_move_to_func_t) hb_vector_draw_pdf_move_to, nullptr, nullptr);
|
|
hb_draw_funcs_set_line_to_func (funcs, (hb_draw_line_to_func_t) hb_vector_draw_pdf_line_to, nullptr, nullptr);
|
|
/* No quadratic_to: null fallback auto-promotes to cubic. */
|
|
hb_draw_funcs_set_cubic_to_func (funcs, (hb_draw_cubic_to_func_t) hb_vector_draw_pdf_cubic_to, nullptr, nullptr);
|
|
hb_draw_funcs_set_close_path_func (funcs, (hb_draw_close_path_func_t) hb_vector_draw_pdf_close_path, nullptr, nullptr);
|
|
hb_draw_funcs_make_immutable (funcs);
|
|
hb_atexit (free_static_vector_draw_pdf_funcs);
|
|
return funcs;
|
|
}
|
|
} static_vector_draw_pdf_funcs;
|
|
static inline void free_static_vector_draw_pdf_funcs () { static_vector_draw_pdf_funcs.free_instance (); }
|
|
|
|
|
|
|
|
/**
|
|
* hb_vector_draw_create_or_fail:
|
|
* @format: output format.
|
|
*
|
|
* Creates a new draw context for vector output.
|
|
*
|
|
* Return value: (nullable): a newly allocated #hb_vector_draw_t, or `NULL` on failure.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
hb_vector_draw_t *
|
|
hb_vector_draw_create_or_fail (hb_vector_format_t format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case HB_VECTOR_FORMAT_SVG:
|
|
case HB_VECTOR_FORMAT_PDF:
|
|
break;
|
|
case HB_VECTOR_FORMAT_INVALID: default:
|
|
return nullptr;
|
|
}
|
|
|
|
hb_vector_draw_t *draw = hb_object_create<hb_vector_draw_t> ();
|
|
if (unlikely (!draw))
|
|
return nullptr;
|
|
draw->format = format;
|
|
draw->defs.alloc (2048);
|
|
draw->body.alloc (8192);
|
|
draw->path.alloc (2048);
|
|
return draw;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_reference:
|
|
* @draw: a draw context.
|
|
*
|
|
* Increases the reference count of @draw.
|
|
*
|
|
* Return value: (transfer full): referenced @draw.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
hb_vector_draw_t *
|
|
hb_vector_draw_reference (hb_vector_draw_t *draw)
|
|
{
|
|
return hb_object_reference (draw);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_destroy:
|
|
* @draw: a draw context.
|
|
*
|
|
* Decreases the reference count of @draw and destroys it when it reaches zero.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_destroy (hb_vector_draw_t *draw)
|
|
{
|
|
if (!hb_object_should_destroy (draw))
|
|
return;
|
|
|
|
hb_blob_destroy (draw->recycled_blob);
|
|
hb_object_actually_destroy (draw);
|
|
hb_free (draw);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_user_data:
|
|
* @draw: a draw context.
|
|
* @key: user-data key.
|
|
* @data: user-data value.
|
|
* @destroy: (nullable): destroy callback for @data.
|
|
* @replace: whether to replace an existing value for @key.
|
|
*
|
|
* Attaches user data to @draw.
|
|
*
|
|
* Return value: `true` on success, `false` otherwise.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
hb_bool_t
|
|
hb_vector_draw_set_user_data (hb_vector_draw_t *draw,
|
|
hb_user_data_key_t *key,
|
|
void *data,
|
|
hb_destroy_func_t destroy,
|
|
hb_bool_t replace)
|
|
{
|
|
return hb_object_set_user_data (draw, key, data, destroy, replace);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_user_data:
|
|
* @draw: a draw context.
|
|
* @key: user-data key.
|
|
*
|
|
* Gets previously attached user data from @draw.
|
|
*
|
|
* Return value: (nullable): user-data value associated with @key.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void *
|
|
hb_vector_draw_get_user_data (const hb_vector_draw_t *draw,
|
|
hb_user_data_key_t *key)
|
|
{
|
|
return hb_object_get_user_data (draw, key);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_transform:
|
|
* @draw: a draw context.
|
|
* @xx: transform xx component.
|
|
* @yx: transform yx component.
|
|
* @xy: transform xy component.
|
|
* @yy: transform yy component.
|
|
* @dx: transform x translation.
|
|
* @dy: transform y translation.
|
|
*
|
|
* Sets the affine transform used when drawing glyphs.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_set_transform (hb_vector_draw_t *draw,
|
|
float xx, float yx,
|
|
float xy, float yy,
|
|
float dx, float dy)
|
|
{
|
|
draw->transform = {xx, yx, xy, yy, dx, dy};
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_transform:
|
|
* @draw: a draw context.
|
|
* @xx: (out) (nullable): transform xx component.
|
|
* @yx: (out) (nullable): transform yx component.
|
|
* @xy: (out) (nullable): transform xy component.
|
|
* @yy: (out) (nullable): transform yy component.
|
|
* @dx: (out) (nullable): transform x translation.
|
|
* @dy: (out) (nullable): transform y translation.
|
|
*
|
|
* Gets the affine transform used when drawing glyphs.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_get_transform (const hb_vector_draw_t *draw,
|
|
float *xx, float *yx,
|
|
float *xy, float *yy,
|
|
float *dx, float *dy)
|
|
{
|
|
if (xx) *xx = draw->transform.xx;
|
|
if (yx) *yx = draw->transform.yx;
|
|
if (xy) *xy = draw->transform.xy;
|
|
if (yy) *yy = draw->transform.yy;
|
|
if (dx) *dx = draw->transform.x0;
|
|
if (dy) *dy = draw->transform.y0;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_scale_factor:
|
|
* @draw: a draw context.
|
|
* @x_scale_factor: x scale factor.
|
|
* @y_scale_factor: y scale factor.
|
|
*
|
|
* Sets additional output scaling factors.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_set_scale_factor (hb_vector_draw_t *draw,
|
|
float x_scale_factor,
|
|
float y_scale_factor)
|
|
{
|
|
draw->x_scale_factor = x_scale_factor > 0.f ? x_scale_factor : 1.f;
|
|
draw->y_scale_factor = y_scale_factor > 0.f ? y_scale_factor : 1.f;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_scale_factor:
|
|
* @draw: a draw context.
|
|
* @x_scale_factor: (out) (nullable): x scale factor.
|
|
* @y_scale_factor: (out) (nullable): y scale factor.
|
|
*
|
|
* Gets additional output scaling factors.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_get_scale_factor (const hb_vector_draw_t *draw,
|
|
float *x_scale_factor,
|
|
float *y_scale_factor)
|
|
{
|
|
if (x_scale_factor) *x_scale_factor = draw->x_scale_factor;
|
|
if (y_scale_factor) *y_scale_factor = draw->y_scale_factor;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_extents:
|
|
* @draw: a draw context.
|
|
* @extents: (nullable): output extents to set or expand.
|
|
*
|
|
* Sets or expands output extents on @draw. Passing `NULL` clears extents.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_set_extents (hb_vector_draw_t *draw,
|
|
const hb_vector_extents_t *extents)
|
|
{
|
|
if (!extents)
|
|
{
|
|
draw->extents = {0, 0, 0, 0};
|
|
draw->has_extents = false;
|
|
return;
|
|
}
|
|
|
|
if (extents->width == 0.f || extents->height == 0.f)
|
|
return;
|
|
|
|
/* Caller-supplied extents are in input-space; divide by
|
|
* scale_factor so they end up in output-space, matching
|
|
* the per-glyph extents accumulated via
|
|
* hb_vector_set_glyph_extents_common (which applies the
|
|
* same divide). Normalize so origin is the min corner and
|
|
* width/height are positive — callers may pass a
|
|
* glyph-extents-style box with negative height. */
|
|
float x0 = extents->x / draw->x_scale_factor;
|
|
float y0 = extents->y / draw->y_scale_factor;
|
|
float x1 = x0 + extents->width / draw->x_scale_factor;
|
|
float y1 = y0 + extents->height / draw->y_scale_factor;
|
|
hb_vector_extents_t e = {
|
|
hb_min (x0, x1), hb_min (y0, y1),
|
|
fabsf (x1 - x0), fabsf (y1 - y0),
|
|
};
|
|
|
|
if (draw->has_extents)
|
|
{
|
|
float x0 = hb_min (draw->extents.x, e.x);
|
|
float y0 = hb_min (draw->extents.y, e.y);
|
|
float x1 = hb_max (draw->extents.x + draw->extents.width,
|
|
e.x + e.width);
|
|
float y1 = hb_max (draw->extents.y + draw->extents.height,
|
|
e.y + e.height);
|
|
draw->extents = {x0, y0, x1 - x0, y1 - y0};
|
|
}
|
|
else
|
|
{
|
|
draw->extents = e;
|
|
draw->has_extents = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_extents:
|
|
* @draw: a draw context.
|
|
* @extents: (out) (nullable): where to store current output extents.
|
|
*
|
|
* Gets current output extents from @draw.
|
|
*
|
|
* Return value: `true` if extents are set, `false` otherwise.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
hb_bool_t
|
|
hb_vector_draw_get_extents (const hb_vector_draw_t *draw,
|
|
hb_vector_extents_t *extents)
|
|
{
|
|
if (!draw->has_extents)
|
|
return false;
|
|
|
|
if (extents)
|
|
*extents = draw->extents;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_glyph_extents:
|
|
* @draw: a draw context.
|
|
* @glyph_extents: glyph extents in font units.
|
|
*
|
|
* Expands @draw extents using @glyph_extents under the current transform.
|
|
*
|
|
* Return value: `true` on success, `false` otherwise.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
hb_bool_t
|
|
hb_vector_draw_set_glyph_extents (hb_vector_draw_t *draw,
|
|
const hb_glyph_extents_t *glyph_extents)
|
|
{
|
|
hb_bool_t has_extents = draw->has_extents;
|
|
hb_bool_t ret = hb_vector_set_glyph_extents_common (draw->transform,
|
|
draw->x_scale_factor,
|
|
draw->y_scale_factor,
|
|
glyph_extents,
|
|
&draw->extents,
|
|
&has_extents);
|
|
draw->has_extents = has_extents;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_format:
|
|
* @draw: a vector draw context.
|
|
*
|
|
* Gets the output format @draw was created with.
|
|
*
|
|
* Return value: the output format.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
hb_vector_format_t
|
|
hb_vector_draw_get_format (const hb_vector_draw_t *draw)
|
|
{
|
|
return draw->format;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_funcs:
|
|
* @draw: a vector draw context.
|
|
*
|
|
* Gets draw callbacks for feeding outline data into @draw.
|
|
* Pass @draw as the @draw_data argument when calling them.
|
|
*
|
|
* Return value: (transfer none): immutable #hb_draw_funcs_t.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
hb_draw_funcs_t *
|
|
hb_vector_draw_get_funcs (const hb_vector_draw_t *draw)
|
|
{
|
|
switch (draw ? draw->format : HB_VECTOR_FORMAT_INVALID)
|
|
{
|
|
case HB_VECTOR_FORMAT_SVG: return static_vector_draw_svg_funcs.get_unconst ();
|
|
case HB_VECTOR_FORMAT_PDF: return static_vector_draw_pdf_funcs.get_unconst ();
|
|
case HB_VECTOR_FORMAT_INVALID: default: return nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_new_path:
|
|
* @draw: a draw context.
|
|
*
|
|
* Flushes any pending path and starts a new one. Call this
|
|
* between glyphs to separate their outlines so fill rules
|
|
* don't interact across glyphs.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
void
|
|
hb_vector_draw_new_path (hb_vector_draw_t *draw)
|
|
{
|
|
draw->new_path ();
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_glyph_or_fail:
|
|
* @draw: a draw context.
|
|
* @font: font object.
|
|
* @glyph: glyph ID.
|
|
* @extents_mode: extents update mode.
|
|
*
|
|
* Convenience to draw one glyph into @draw. Equivalent to:
|
|
*
|
|
* |[<!-- language="plain" -->
|
|
* // extend extents if requested
|
|
* hb_vector_draw_new_path (draw);
|
|
* hb_font_draw_glyph_or_fail (font, glyph,
|
|
* hb_vector_draw_get_funcs (draw), draw);
|
|
* ]|
|
|
*
|
|
* Return value: `true` if glyph data was emitted, `false` otherwise.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
hb_bool_t
|
|
hb_vector_draw_glyph_or_fail (hb_vector_draw_t *draw,
|
|
hb_font_t *font,
|
|
hb_codepoint_t glyph,
|
|
hb_vector_extents_mode_t extents_mode)
|
|
{
|
|
|
|
if (extents_mode == HB_VECTOR_EXTENTS_MODE_EXPAND)
|
|
{
|
|
hb_glyph_extents_t ge;
|
|
if (hb_font_get_glyph_extents (font, glyph, &ge))
|
|
{
|
|
hb_bool_t has_extents = draw->has_extents;
|
|
hb_vector_set_glyph_extents_common (draw->transform,
|
|
draw->x_scale_factor,
|
|
draw->y_scale_factor,
|
|
&ge,
|
|
&draw->extents,
|
|
&has_extents);
|
|
draw->has_extents = has_extents;
|
|
}
|
|
}
|
|
|
|
draw->new_path ();
|
|
return hb_font_draw_glyph_or_fail (font, glyph, hb_vector_draw_get_funcs (draw), draw);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_glyph:
|
|
* @draw: a draw context.
|
|
* @font: font object.
|
|
* @glyph: glyph ID.
|
|
* @extents_mode: extents update mode.
|
|
*
|
|
* Draws one glyph into @draw. Equivalent to
|
|
* hb_vector_draw_glyph_or_fail() with the return value ignored.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
void
|
|
hb_vector_draw_glyph (hb_vector_draw_t *draw,
|
|
hb_font_t *font,
|
|
hb_codepoint_t glyph,
|
|
hb_vector_extents_mode_t extents_mode)
|
|
{
|
|
hb_vector_draw_glyph_or_fail (draw, font, glyph, extents_mode);
|
|
}
|
|
|
|
|
|
/**
|
|
* hb_vector_draw_set_precision:
|
|
* @draw: a draw context.
|
|
* @precision: decimal precision.
|
|
*
|
|
* Sets numeric output precision for draw output.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
void
|
|
hb_vector_draw_set_precision (hb_vector_draw_t *draw,
|
|
unsigned precision)
|
|
{
|
|
draw->set_precision (precision);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_precision:
|
|
* @draw: a draw context.
|
|
*
|
|
* Returns the numeric output precision previously set on @draw,
|
|
* or the default if none was set.
|
|
*
|
|
* Return value: the precision.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
unsigned
|
|
hb_vector_draw_get_precision (const hb_vector_draw_t *draw)
|
|
{
|
|
return draw->get_precision ();
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_foreground:
|
|
* @draw: a draw context.
|
|
* @foreground: foreground fill color.
|
|
*
|
|
* Sets the fill color for drawn glyph outlines.
|
|
* Default is opaque black.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
void
|
|
hb_vector_draw_set_foreground (hb_vector_draw_t *draw,
|
|
hb_color_t foreground)
|
|
{
|
|
draw->flush_path ();
|
|
draw->foreground = foreground;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_foreground:
|
|
* @draw: a draw context.
|
|
*
|
|
* Returns the foreground fill color.
|
|
*
|
|
* Return value: the foreground color.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
hb_color_t
|
|
hb_vector_draw_get_foreground (const hb_vector_draw_t *draw)
|
|
{
|
|
return draw->foreground;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_set_background:
|
|
* @draw: a draw context.
|
|
* @background: background color.
|
|
*
|
|
* Sets the background color. If non-transparent, a filled
|
|
* rectangle covering the extents is emitted behind all content.
|
|
* Default is transparent (no background).
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
void
|
|
hb_vector_draw_set_background (hb_vector_draw_t *draw,
|
|
hb_color_t background)
|
|
{
|
|
draw->background = background;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_get_background:
|
|
* @draw: a draw context.
|
|
*
|
|
* Returns the background color.
|
|
*
|
|
* Return value: the background color.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
hb_color_t
|
|
hb_vector_draw_get_background (const hb_vector_draw_t *draw)
|
|
{
|
|
return draw->background;
|
|
}
|
|
|
|
static hb_blob_t *
|
|
hb_vector_draw_render_pdf (hb_vector_draw_t *draw)
|
|
{
|
|
draw->flush_path ();
|
|
if (!draw->has_extents)
|
|
return nullptr;
|
|
|
|
/* Collect the content stream. The path coordinates are in
|
|
* SVG space (Y-down). Prepend a CTM that flips Y so the
|
|
* PDF page (Y-up) renders correctly. */
|
|
float ex = draw->extents.x;
|
|
float ey = draw->extents.y;
|
|
float ew = draw->extents.width;
|
|
float eh = draw->extents.height;
|
|
|
|
hb_vector_buf_t stream;
|
|
stream.alloc (draw->body.length + draw->path.length + 256);
|
|
|
|
/* Background rect. */
|
|
if (hb_color_get_alpha (draw->background))
|
|
{
|
|
float a = hb_color_get_alpha (draw->background) / 255.f;
|
|
if (a < 1.f - 1.f / 512.f)
|
|
{
|
|
stream.append_num (a, 4);
|
|
stream.append_str (" ca gs\n");
|
|
}
|
|
stream.append_num (hb_color_get_red (draw->background) / 255.f, 4);
|
|
stream.append_c (' ');
|
|
stream.append_num (hb_color_get_green (draw->background) / 255.f, 4);
|
|
stream.append_c (' ');
|
|
stream.append_num (hb_color_get_blue (draw->background) / 255.f, 4);
|
|
stream.append_str (" rg\n");
|
|
stream.append_num (ex);
|
|
stream.append_c (' ');
|
|
stream.append_num (-(ey + eh));
|
|
stream.append_c (' ');
|
|
stream.append_num (ew);
|
|
stream.append_c (' ');
|
|
stream.append_num (eh);
|
|
stream.append_str (" re f\n");
|
|
}
|
|
|
|
draw->flush_path ();
|
|
if (draw->body.length)
|
|
stream.append_len (draw->body.arrayZ, draw->body.length);
|
|
|
|
/* Build PDF objects, tracking byte offsets for xref. */
|
|
hb_vector_buf_t out;
|
|
hb_buf_recover_recycled (draw->recycled_blob, &out);
|
|
out.alloc (stream.length + 512);
|
|
|
|
unsigned offsets[5]; /* objects 1-4, plus end */
|
|
|
|
out.append_str ("%PDF-1.4\n%\xC0\xC1\xC2\xC3\n");
|
|
|
|
/* Object 1: Catalog */
|
|
offsets[0] = out.length;
|
|
out.append_str ("1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
|
|
|
|
/* Object 2: Pages */
|
|
offsets[1] = out.length;
|
|
out.append_str ("2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
|
|
|
|
/* Object 3: Page. Extents are in SVG space (y = -font_y).
|
|
* Convert back: font Y range = [-(ey+eh) .. -ey]. */
|
|
offsets[2] = out.length;
|
|
out.append_str ("3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [");
|
|
out.append_num (ex);
|
|
out.append_c (' ');
|
|
out.append_num (-(ey + eh));
|
|
out.append_c (' ');
|
|
out.append_num (ex + ew);
|
|
out.append_c (' ');
|
|
out.append_num (-ey);
|
|
out.append_str ("] /Contents 4 0 R");
|
|
if (draw->pdf_extgstate_dict.length)
|
|
{
|
|
out.append_str (" /Resources << /ExtGState << ");
|
|
out.append_len (draw->pdf_extgstate_dict.arrayZ, draw->pdf_extgstate_dict.length);
|
|
out.append_str (">> >>");
|
|
}
|
|
out.append_str (" >>\nendobj\n");
|
|
|
|
/* Object 4: Content stream */
|
|
offsets[3] = out.length;
|
|
out.append_str ("4 0 obj\n<< /Length ");
|
|
out.append_unsigned (stream.length);
|
|
out.append_str (" >>\nstream\n");
|
|
out.append_len (stream.arrayZ, stream.length);
|
|
out.append_str ("endstream\nendobj\n");
|
|
|
|
/* Cross-reference table */
|
|
unsigned xref_offset = out.length;
|
|
out.append_str ("xref\n0 5\n");
|
|
out.append_str ("0000000000 65535 f \n");
|
|
for (unsigned i = 0; i < 4; i++)
|
|
{
|
|
char tmp[21];
|
|
snprintf (tmp, sizeof (tmp), "%010u 00000 n \n", offsets[i]);
|
|
out.append_len (tmp, 20);
|
|
}
|
|
|
|
/* Trailer */
|
|
out.append_str ("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n");
|
|
out.append_unsigned (xref_offset);
|
|
out.append_str ("\n%%EOF\n");
|
|
|
|
hb_blob_t *blob = hb_buf_blob_from (&draw->recycled_blob, &out);
|
|
|
|
hb_vector_draw_clear (draw);
|
|
|
|
return blob;
|
|
}
|
|
|
|
static hb_blob_t *
|
|
hb_vector_draw_render_svg (hb_vector_draw_t *draw)
|
|
{
|
|
draw->flush_path ();
|
|
if (!draw->has_extents)
|
|
return nullptr;
|
|
|
|
hb_vector_buf_t out;
|
|
hb_buf_recover_recycled (draw->recycled_blob, &out);
|
|
unsigned estimated = draw->defs.length +
|
|
(draw->body.length ? draw->body.length : draw->path.length) +
|
|
256;
|
|
out.alloc (estimated);
|
|
/* Extents are in Y-up (font) space. SVG is Y-down.
|
|
* The global scale(1,-1) wrapper flips content; the
|
|
* viewBox maps the flipped range. */
|
|
float vb_x = draw->extents.x;
|
|
float vb_y = -(draw->extents.y + draw->extents.height);
|
|
float vb_w = draw->extents.width;
|
|
float vb_h = draw->extents.height;
|
|
out.append_str ("<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"");
|
|
out.append_num (vb_x);
|
|
out.append_c (' ');
|
|
out.append_num (vb_y);
|
|
out.append_c (' ');
|
|
out.append_num (vb_w);
|
|
out.append_c (' ');
|
|
out.append_num (vb_h);
|
|
out.append_str ("\" width=\"");
|
|
out.append_num (vb_w);
|
|
out.append_str ("\" height=\"");
|
|
out.append_num (vb_h);
|
|
out.append_str ("\">\n");
|
|
|
|
if (draw->defs.length)
|
|
{
|
|
out.append_str ("<defs>\n");
|
|
out.append_len (draw->defs.arrayZ, draw->defs.length);
|
|
out.append_str ("</defs>\n");
|
|
}
|
|
|
|
/* Background rect. */
|
|
if (hb_color_get_alpha (draw->background))
|
|
{
|
|
out.append_str ("<rect x=\"");
|
|
out.append_num (vb_x);
|
|
out.append_str ("\" y=\"");
|
|
out.append_num (vb_y);
|
|
out.append_str ("\" width=\"");
|
|
out.append_num (vb_w);
|
|
out.append_str ("\" height=\"");
|
|
out.append_num (vb_h);
|
|
out.append_str ("\" fill=\"rgb(");
|
|
out.append_unsigned (hb_color_get_red (draw->background));
|
|
out.append_c (',');
|
|
out.append_unsigned (hb_color_get_green (draw->background));
|
|
out.append_c (',');
|
|
out.append_unsigned (hb_color_get_blue (draw->background));
|
|
out.append_str (")\"");
|
|
if (hb_color_get_alpha (draw->background) < 255)
|
|
{
|
|
out.append_str (" fill-opacity=\"");
|
|
out.append_num (hb_color_get_alpha (draw->background) / 255.f, 4);
|
|
out.append_c ('"');
|
|
}
|
|
out.append_str ("/>\n");
|
|
}
|
|
|
|
draw->flush_path ();
|
|
if (draw->body.length)
|
|
{
|
|
out.append_str ("<g transform=\"scale(1,-1)\">\n");
|
|
out.append_len (draw->body.arrayZ, draw->body.length);
|
|
out.append_str ("</g>\n");
|
|
}
|
|
|
|
out.append_str ("</svg>\n");
|
|
|
|
hb_blob_t *blob = hb_buf_blob_from (&draw->recycled_blob, &out);
|
|
|
|
hb_vector_draw_clear (draw);
|
|
|
|
return blob;
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_render:
|
|
* @draw: a draw context.
|
|
*
|
|
* Renders accumulated draw content to an output blob.
|
|
*
|
|
* Return value: (transfer full) (nullable): output blob, or `NULL` if rendering cannot proceed.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
hb_blob_t *
|
|
hb_vector_draw_render (hb_vector_draw_t *draw)
|
|
{
|
|
switch (draw->format)
|
|
{
|
|
case HB_VECTOR_FORMAT_SVG:
|
|
return hb_vector_draw_render_svg (draw);
|
|
|
|
case HB_VECTOR_FORMAT_PDF:
|
|
return hb_vector_draw_render_pdf (draw);
|
|
|
|
case HB_VECTOR_FORMAT_INVALID: default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_clear:
|
|
* @draw: a draw context.
|
|
*
|
|
* Discards accumulated draw output so @draw can be reused for
|
|
* another render. User configuration (transform, scale factors,
|
|
* precision) is preserved. Call hb_vector_draw_reset() to
|
|
* also reset user configuration to defaults.
|
|
*
|
|
* Since: 14.2.0
|
|
*/
|
|
void
|
|
hb_vector_draw_clear (hb_vector_draw_t *draw)
|
|
{
|
|
draw->extents = {0, 0, 0, 0};
|
|
draw->has_extents = false;
|
|
draw->defs.clear ();
|
|
draw->body.clear ();
|
|
draw->path.clear ();
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_reset:
|
|
* @draw: a draw context.
|
|
*
|
|
* Resets @draw state and clears accumulated content.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_reset (hb_vector_draw_t *draw)
|
|
{
|
|
draw->transform = {1, 0, 0, 1, 0, 0};
|
|
draw->x_scale_factor = 1.f;
|
|
draw->y_scale_factor = 1.f;
|
|
draw->set_precision (2);
|
|
hb_vector_draw_clear (draw);
|
|
}
|
|
|
|
/**
|
|
* hb_vector_draw_recycle_blob:
|
|
* @draw: a draw context.
|
|
* @blob: (nullable): previously rendered blob to recycle.
|
|
*
|
|
* Provides a blob for internal buffer reuse by later render calls.
|
|
*
|
|
* Since: 13.0.0
|
|
*/
|
|
void
|
|
hb_vector_draw_recycle_blob (hb_vector_draw_t *draw,
|
|
hb_blob_t *blob)
|
|
{
|
|
hb_blob_destroy (draw->recycled_blob);
|
|
draw->recycled_blob = nullptr;
|
|
if (!blob || blob == hb_blob_get_empty ())
|
|
return;
|
|
draw->recycled_blob = blob;
|
|
}
|