| /* |
| * Copyright © 2022 Matthias Clasen |
| * |
| * 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. |
| */ |
| |
| #include "hb.hh" |
| |
| #ifndef HB_NO_PAINT |
| |
| #include "hb-paint.hh" |
| |
| /** |
| * SECTION: hb-paint |
| * @title: hb-paint |
| * @short_description: Glyph painting |
| * @include: hb.h |
| * |
| * Functions for painting glyphs. |
| * |
| * The main purpose of these functions is to paint (extract) color glyph layers |
| * from the COLRv1 table, but the API works for drawing ordinary outlines and |
| * images as well. |
| * |
| * The #hb_paint_funcs_t struct can be used with hb_font_paint_glyph(). |
| **/ |
| |
| static void |
| hb_paint_push_transform_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| float xx, float yx, |
| float xy, float yy, |
| float dx, float dy, |
| void *user_data) {} |
| |
| static void |
| hb_paint_pop_transform_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| void *user_data) {} |
| |
| static hb_bool_t |
| hb_paint_color_glyph_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_codepoint_t glyph, |
| hb_font_t *font, |
| void *user_data) { return false; } |
| |
| static void |
| hb_paint_fill_glyph_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_codepoint_t glyph, |
| hb_font_t *font, |
| hb_bool_t is_foreground, |
| hb_color_t color, |
| void *user_data) |
| { |
| /* Decompose into the equivalent general sequence. */ |
| funcs->push_clip_glyph (paint_data, glyph, font); |
| funcs->color (paint_data, is_foreground, color); |
| funcs->pop_clip (paint_data); |
| } |
| |
| static void |
| hb_paint_push_clip_glyph_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_codepoint_t glyph, |
| hb_font_t *font, |
| void *user_data) {} |
| |
| static void |
| hb_paint_push_clip_rectangle_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| float xmin, float ymin, float xmax, float ymax, |
| void *user_data) {} |
| |
| static hb_draw_funcs_t * |
| hb_paint_push_clip_path_start_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| void **draw_data, |
| void *user_data) { if (draw_data) *draw_data = nullptr; return nullptr; } |
| |
| static void |
| hb_paint_push_clip_path_end_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| void *user_data) {} |
| |
| static void |
| hb_paint_pop_clip_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| void *user_data) {} |
| |
| static void |
| hb_paint_color_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_bool_t is_foreground, |
| hb_color_t color, |
| void *user_data) {} |
| |
| static hb_bool_t |
| hb_paint_image_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_blob_t *image, |
| unsigned int width, |
| unsigned int height, |
| hb_tag_t format, |
| float slant_xy_deprecated, |
| hb_glyph_extents_t *extents, |
| void *user_data) { return false; } |
| |
| static void |
| hb_paint_linear_gradient_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_color_line_t *color_line, |
| float x0, float y0, |
| float x1, float y1, |
| float x2, float y2, |
| void *user_data) {} |
| |
| static void |
| hb_paint_radial_gradient_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_color_line_t *color_line, |
| float x0, float y0, float r0, |
| float x1, float y1, float r1, |
| void *user_data) {} |
| |
| static void |
| hb_paint_sweep_gradient_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_color_line_t *color_line, |
| float x0, float y0, |
| float start_angle, |
| float end_angle, |
| void *user_data) {} |
| |
| static void |
| hb_paint_push_group_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| void *user_data) {} |
| |
| static void |
| hb_paint_push_group_for_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_paint_composite_mode_t mode, |
| void *user_data) |
| { |
| hb_paint_push_group (funcs, paint_data); |
| } |
| |
| static void |
| hb_paint_pop_group_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_paint_composite_mode_t mode, |
| void *user_data) {} |
| |
| static hb_bool_t |
| hb_paint_custom_palette_color_nil (hb_paint_funcs_t *funcs, void *paint_data, |
| unsigned int color_index, |
| hb_color_t *color, |
| void *user_data) { return false; } |
| |
| static bool |
| _hb_paint_funcs_set_preamble (hb_paint_funcs_t *funcs, |
| bool func_is_null, |
| void **user_data, |
| hb_destroy_func_t *destroy) |
| { |
| if (hb_object_is_immutable (funcs)) |
| { |
| if (*destroy) |
| (*destroy) (*user_data); |
| return false; |
| } |
| |
| if (func_is_null) |
| { |
| if (*destroy) |
| (*destroy) (*user_data); |
| *destroy = nullptr; |
| *user_data = nullptr; |
| } |
| |
| return true; |
| } |
| |
| static bool |
| _hb_paint_funcs_set_middle (hb_paint_funcs_t *funcs, |
| void *user_data, |
| hb_destroy_func_t destroy) |
| { |
| auto destroy_guard = hb_make_scope_guard ([&]() { |
| if (destroy) destroy (user_data); |
| }); |
| |
| if (user_data && !funcs->user_data) |
| { |
| funcs->user_data = (decltype (funcs->user_data)) hb_calloc (1, sizeof (*funcs->user_data)); |
| if (unlikely (!funcs->user_data)) |
| return false; |
| } |
| if (destroy && !funcs->destroy) |
| { |
| funcs->destroy = (decltype (funcs->destroy)) hb_calloc (1, sizeof (*funcs->destroy)); |
| if (unlikely (!funcs->destroy)) |
| return false; |
| } |
| |
| destroy_guard.release (); |
| return true; |
| } |
| |
| #define HB_PAINT_FUNC_IMPLEMENT(name) \ |
| \ |
| void \ |
| hb_paint_funcs_set_##name##_func (hb_paint_funcs_t *funcs, \ |
| hb_paint_##name##_func_t func, \ |
| void *user_data, \ |
| hb_destroy_func_t destroy) \ |
| { \ |
| if (!_hb_paint_funcs_set_preamble (funcs, !func, &user_data, &destroy)) \ |
| return; \ |
| \ |
| if (funcs->destroy && funcs->destroy->name) \ |
| funcs->destroy->name (!funcs->user_data ? nullptr : funcs->user_data->name);\ |
| \ |
| if (!_hb_paint_funcs_set_middle (funcs, user_data, destroy)) \ |
| return; \ |
| \ |
| if (func) \ |
| funcs->func.name = func; \ |
| else \ |
| funcs->func.name = hb_paint_##name##_nil; \ |
| \ |
| if (funcs->user_data) \ |
| funcs->user_data->name = user_data; \ |
| if (funcs->destroy) \ |
| funcs->destroy->name = destroy; \ |
| } |
| |
| HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS |
| #undef HB_PAINT_FUNC_IMPLEMENT |
| |
| /** |
| * hb_paint_funcs_create: |
| * |
| * Creates a new #hb_paint_funcs_t structure of paint functions. |
| * |
| * The initial reference count of 1 should be released with hb_paint_funcs_destroy() |
| * when you are done using the #hb_paint_funcs_t. This function never returns |
| * `NULL`. If memory cannot be allocated, a special singleton #hb_paint_funcs_t |
| * object will be returned. |
| * |
| * Returns value: (transfer full): the paint-functions structure |
| * |
| * Since: 7.0.0 |
| */ |
| hb_paint_funcs_t * |
| hb_paint_funcs_create () |
| { |
| hb_paint_funcs_t *funcs; |
| if (unlikely (!(funcs = hb_object_create<hb_paint_funcs_t> ()))) |
| return const_cast<hb_paint_funcs_t *> (&Null (hb_paint_funcs_t)); |
| |
| funcs->func = Null (hb_paint_funcs_t).func; |
| |
| return funcs; |
| } |
| |
| DEFINE_NULL_INSTANCE (hb_paint_funcs_t) = |
| { |
| HB_OBJECT_HEADER_STATIC, |
| |
| { |
| #define HB_PAINT_FUNC_IMPLEMENT(name) hb_paint_##name##_nil, |
| HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS |
| #undef HB_PAINT_FUNC_IMPLEMENT |
| } |
| }; |
| |
| /** |
| * hb_paint_funcs_get_empty: |
| * |
| * Fetches the singleton empty paint-functions structure. |
| * |
| * Return value: (transfer full): The empty paint-functions structure |
| * |
| * Since: 7.0.0 |
| **/ |
| hb_paint_funcs_t * |
| hb_paint_funcs_get_empty () |
| { |
| return const_cast<hb_paint_funcs_t *> (&Null (hb_paint_funcs_t)); |
| } |
| |
| /** |
| * hb_paint_funcs_reference: (skip) |
| * @funcs: The paint-functions structure |
| * |
| * Increases the reference count on a paint-functions structure. |
| * |
| * This prevents @funcs from being destroyed until a matching |
| * call to hb_paint_funcs_destroy() is made. |
| * |
| * Return value: The paint-functions structure |
| * |
| * Since: 7.0.0 |
| */ |
| hb_paint_funcs_t * |
| hb_paint_funcs_reference (hb_paint_funcs_t *funcs) |
| { |
| return hb_object_reference (funcs); |
| } |
| |
| /** |
| * hb_paint_funcs_destroy: (skip) |
| * @funcs: The paint-functions structure |
| * |
| * Decreases the reference count on a paint-functions structure. |
| * |
| * When the reference count reaches zero, the structure |
| * is destroyed, freeing all memory. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_funcs_destroy (hb_paint_funcs_t *funcs) |
| { |
| if (!hb_object_destroy (funcs)) return; |
| |
| if (funcs->destroy) |
| { |
| #define HB_PAINT_FUNC_IMPLEMENT(name) \ |
| if (funcs->destroy->name) funcs->destroy->name (!funcs->user_data ? nullptr : funcs->user_data->name); |
| HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS |
| #undef HB_PAINT_FUNC_IMPLEMENT |
| } |
| |
| hb_free (funcs->destroy); |
| hb_free (funcs->user_data); |
| hb_free (funcs); |
| } |
| |
| /** |
| * hb_paint_funcs_set_user_data: (skip) |
| * @funcs: The paint-functions structure |
| * @key: The user-data key |
| * @data: A pointer to the user data |
| * @destroy: (nullable): A callback to call when @data is not needed anymore |
| * @replace: Whether to replace an existing data with the same key |
| * |
| * Attaches a user-data key/data pair to the specified paint-functions structure. |
| * |
| * Return value: `true` if success, `false` otherwise |
| * |
| * Since: 7.0.0 |
| **/ |
| hb_bool_t |
| hb_paint_funcs_set_user_data (hb_paint_funcs_t *funcs, |
| hb_user_data_key_t *key, |
| void * data, |
| hb_destroy_func_t destroy, |
| hb_bool_t replace) |
| { |
| return hb_object_set_user_data (funcs, key, data, destroy, replace); |
| } |
| |
| /** |
| * hb_paint_funcs_get_user_data: (skip) |
| * @funcs: The paint-functions structure |
| * @key: The user-data key to query |
| * |
| * Fetches the user-data associated with the specified key, |
| * attached to the specified paint-functions structure. |
| * |
| * Return value: (transfer none): A pointer to the user data |
| * |
| * Since: 7.0.0 |
| **/ |
| void * |
| hb_paint_funcs_get_user_data (const hb_paint_funcs_t *funcs, |
| hb_user_data_key_t *key) |
| { |
| return hb_object_get_user_data (funcs, key); |
| } |
| |
| /** |
| * hb_paint_funcs_make_immutable: |
| * @funcs: The paint-functions structure |
| * |
| * Makes a paint-functions structure immutable. |
| * |
| * After this call, all attempts to set one of the callbacks |
| * on @funcs will fail. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_funcs_make_immutable (hb_paint_funcs_t *funcs) |
| { |
| if (hb_object_is_immutable (funcs)) |
| return; |
| |
| hb_object_make_immutable (funcs); |
| } |
| |
| /** |
| * hb_paint_funcs_is_immutable: |
| * @funcs: The paint-functions structure |
| * |
| * Tests whether a paint-functions structure is immutable. |
| * |
| * Return value: `true` if @funcs is immutable, `false` otherwise |
| * |
| * Since: 7.0.0 |
| */ |
| hb_bool_t |
| hb_paint_funcs_is_immutable (hb_paint_funcs_t *funcs) |
| { |
| return hb_object_is_immutable (funcs); |
| } |
| |
| |
| /** |
| * hb_color_line_get_color_stops: |
| * @color_line: a #hb_color_line_t object |
| * @start: the index of the first color stop to return |
| * @count: (inout) (optional): Input = the maximum number of feature tags to return; |
| * Output = the actual number of feature tags returned (may be zero) |
| * @color_stops: (out) (array length=count) (optional): Array of #hb_color_stop_t to populate |
| * |
| * Fetches a list of color stops from the given color line object. |
| * |
| * Note that due to variations being applied, the returned color stops |
| * may be out of order. It is the callers responsibility to ensure that |
| * color stops are sorted by their offset before they are used. |
| * |
| * Return value: the total number of color stops in @color_line |
| * |
| * Since: 7.0.0 |
| */ |
| unsigned int |
| hb_color_line_get_color_stops (hb_color_line_t *color_line, |
| unsigned int start, |
| unsigned int *count, |
| hb_color_stop_t *color_stops) |
| { |
| return color_line->get_color_stops (color_line, |
| color_line->data, |
| start, count, |
| color_stops, |
| color_line->get_color_stops_user_data); |
| } |
| |
| /** |
| * hb_color_line_get_extend: |
| * @color_line: a #hb_color_line_t object |
| * |
| * Fetches the extend mode of the color line object. |
| * |
| * Return value: the extend mode of @color_line |
| * |
| * Since: 7.0.0 |
| */ |
| hb_paint_extend_t |
| hb_color_line_get_extend (hb_color_line_t *color_line) |
| { |
| return color_line->get_extend (color_line, |
| color_line->data, |
| color_line->get_extend_user_data); |
| } |
| |
| |
| /** |
| * hb_paint_push_transform: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @xx: xx component of the transform matrix |
| * @yx: yx component of the transform matrix |
| * @xy: xy component of the transform matrix |
| * @yy: yy component of the transform matrix |
| * @dx: dx component of the transform matrix |
| * @dy: dy component of the transform matrix |
| * |
| * Perform a "push-transform" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_push_transform (hb_paint_funcs_t *funcs, void *paint_data, |
| float xx, float yx, |
| float xy, float yy, |
| float dx, float dy) |
| { |
| funcs->push_transform (paint_data, xx, yx, xy, yy, dx, dy); |
| } |
| |
| /** |
| * hb_paint_push_font_transform: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @font: a font |
| * |
| * Push the transform reflecting the font's scale and slant |
| * settings onto the paint functions. |
| * |
| * Since: 11.0.0 |
| */ |
| void |
| hb_paint_push_font_transform (hb_paint_funcs_t *funcs, void *paint_data, |
| const hb_font_t *font) |
| { |
| funcs->push_font_transform (paint_data, font); |
| } |
| |
| /** |
| * hb_paint_push_inverse_font_transform: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @font: a font |
| * |
| * Push the inverse of the transform reflecting the font's |
| * scale and slant settings onto the paint functions. |
| * |
| * Since: 11.0.0 |
| */ |
| void |
| hb_paint_push_inverse_font_transform (hb_paint_funcs_t *funcs, void *paint_data, |
| const hb_font_t *font) |
| { |
| funcs->push_inverse_font_transform (paint_data, font); |
| } |
| |
| /** |
| * hb_paint_pop_transform: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * |
| * Perform a "pop-transform" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_pop_transform (hb_paint_funcs_t *funcs, void *paint_data) |
| { |
| funcs->pop_transform (paint_data); |
| } |
| |
| /** |
| * hb_paint_color_glyph: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @glyph: the glyph ID |
| * @font: the font |
| * |
| * Perform a "color-glyph" paint operation. |
| * |
| * Since: 8.2.0 |
| */ |
| hb_bool_t |
| hb_paint_color_glyph (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_codepoint_t glyph, |
| hb_font_t *font) |
| { |
| return funcs->color_glyph (paint_data, glyph, font); |
| } |
| |
| /** |
| * hb_paint_fill_glyph: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @glyph: the glyph ID |
| * @font: the font |
| * @is_foreground: whether the color is the foreground |
| * @color: The color to use |
| * |
| * Perform a "fill-glyph" paint operation: fill the glyph's shape |
| * with a solid color. |
| * |
| * XSince: REPLACEME |
| */ |
| void |
| hb_paint_fill_glyph (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_codepoint_t glyph, |
| hb_font_t *font, |
| hb_bool_t is_foreground, |
| hb_color_t color) |
| { |
| funcs->fill_glyph (paint_data, glyph, font, is_foreground, color); |
| } |
| |
| /** |
| * hb_paint_push_clip_glyph: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @glyph: the glyph ID |
| * @font: the font |
| * |
| * Perform a "push-clip-glyph" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_push_clip_glyph (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_codepoint_t glyph, |
| hb_font_t *font) |
| { |
| funcs->push_clip_glyph (paint_data, glyph, font); |
| } |
| |
| /** |
| * hb_paint_push_clip_rectangle: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @xmin: min X for the rectangle |
| * @ymin: min Y for the rectangle |
| * @xmax: max X for the rectangle |
| * @ymax: max Y for the rectangle |
| * |
| * Perform a "push-clip-rect" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_push_clip_rectangle (hb_paint_funcs_t *funcs, void *paint_data, |
| float xmin, float ymin, float xmax, float ymax) |
| { |
| funcs->push_clip_rectangle (paint_data, xmin, ymin, xmax, ymax); |
| } |
| |
| /** |
| * hb_paint_push_clip_path_start: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @draw_data: (out) (nullable): location to receive the draw data |
| * the caller should pass alongside the returned draw funcs. |
| * |
| * Begin clipping to an arbitrary path. Returns an |
| * #hb_draw_funcs_t owned by the backend (the caller must not |
| * free it) that the caller uses to emit the clip outline via |
| * hb_draw_*() calls, using the returned @draw_data as the |
| * draw data. The returned draw funcs and draw data are only |
| * valid until the matching hb_paint_push_clip_path_end() call; |
| * no other paint calls should be made between start and end |
| * except hb_draw_*() on the returned funcs. Finish the path |
| * with hb_paint_push_clip_path_end(); pop the clip later |
| * with hb_paint_pop_clip(). |
| * |
| * Usage: |
| * |
| * |[<!-- language="plain" --> |
| * hb_draw_funcs_t *df = hb_paint_push_clip_path_start (pf, pd, &dd); |
| * hb_draw_move_to (df, dd, NULL, ...); |
| * hb_draw_line_to (df, dd, NULL, ...); |
| * ... |
| * hb_draw_close_path (df, dd, NULL); |
| * hb_paint_push_clip_path_end (pf, pd); |
| * /* paint ops here are clipped to the emitted path */ |
| * hb_paint_pop_clip (pf, pd); |
| * ]| |
| * |
| * Return value: (transfer none): draw funcs that accumulate |
| * the clip path, or `NULL` if the backend does not implement |
| * arbitrary-path clipping. |
| * |
| * Since: 14.2.0 |
| */ |
| hb_draw_funcs_t * |
| hb_paint_push_clip_path_start (hb_paint_funcs_t *funcs, |
| void *paint_data, |
| void **draw_data) |
| { |
| void *scratch = nullptr; |
| if (!draw_data) draw_data = &scratch; |
| return funcs->push_clip_path_start (paint_data, draw_data); |
| } |
| |
| /** |
| * hb_paint_push_clip_path_end: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * |
| * Signal that the arbitrary-clip path started by |
| * hb_paint_push_clip_path_start() is fully drawn. The |
| * accumulated path now acts as a clip on the paint context |
| * until a matching hb_paint_pop_clip() call. |
| * |
| * Since: 14.2.0 |
| */ |
| void |
| hb_paint_push_clip_path_end (hb_paint_funcs_t *funcs, void *paint_data) |
| { |
| funcs->push_clip_path_end (paint_data); |
| } |
| |
| /** |
| * hb_paint_pop_clip: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * |
| * Perform a "pop-clip" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_pop_clip (hb_paint_funcs_t *funcs, void *paint_data) |
| { |
| funcs->pop_clip (paint_data); |
| } |
| |
| /** |
| * hb_paint_color: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @is_foreground: whether the color is the foreground |
| * @color: The color to use |
| * |
| * Perform a "color" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_color (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_bool_t is_foreground, |
| hb_color_t color) |
| { |
| funcs->color (paint_data, is_foreground, color); |
| } |
| |
| /** |
| * hb_paint_image: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @image: image data |
| * @width: width of the raster image in pixels, or 0 |
| * @height: height of the raster image in pixels, or 0 |
| * @format: the image format as a tag |
| * @slant: Deprecated. set to 0.0 |
| * @extents: (nullable): the extents of the glyph |
| * |
| * Perform a "image" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_image (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_blob_t *image, |
| unsigned int width, |
| unsigned int height, |
| hb_tag_t format, |
| HB_UNUSED float slant, |
| hb_glyph_extents_t *extents) |
| { |
| funcs->image (paint_data, image, width, height, format, 0.f, extents); |
| } |
| |
| /** |
| * hb_paint_linear_gradient: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @color_line: Color information for the gradient |
| * @x0: X coordinate of the first point |
| * @y0: Y coordinate of the first point |
| * @x1: X coordinate of the second point |
| * @y1: Y coordinate of the second point |
| * @x2: X coordinate of the third point |
| * @y2: Y coordinate of the third point |
| * |
| * Perform a "linear-gradient" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_linear_gradient (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_color_line_t *color_line, |
| float x0, float y0, |
| float x1, float y1, |
| float x2, float y2) |
| { |
| funcs->linear_gradient (paint_data, color_line, x0, y0, x1, y1, x2, y2); |
| } |
| |
| /** |
| * hb_paint_radial_gradient: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @color_line: Color information for the gradient |
| * @x0: X coordinate of the first circle's center |
| * @y0: Y coordinate of the first circle's center |
| * @r0: radius of the first circle |
| * @x1: X coordinate of the second circle's center |
| * @y1: Y coordinate of the second circle's center |
| * @r1: radius of the second circle |
| * |
| * Perform a "radial-gradient" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_radial_gradient (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_color_line_t *color_line, |
| float x0, float y0, float r0, |
| float x1, float y1, float r1) |
| { |
| funcs->radial_gradient (paint_data, color_line, x0, y0, r0, x1, y1, r1); |
| } |
| |
| /** |
| * hb_paint_sweep_gradient: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @color_line: Color information for the gradient |
| * @x0: X coordinate of the circle's center |
| * @y0: Y coordinate of the circle's center |
| * @start_angle: the start angle |
| * @end_angle: the end angle |
| * |
| * Perform a "sweep-gradient" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_sweep_gradient (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_color_line_t *color_line, |
| float x0, float y0, |
| float start_angle, float end_angle) |
| { |
| funcs->sweep_gradient (paint_data, color_line, x0, y0, start_angle, end_angle); |
| } |
| |
| /** |
| * hb_paint_push_group: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * |
| * Perform a "push-group" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_push_group (hb_paint_funcs_t *funcs, void *paint_data) |
| { |
| funcs->push_group (paint_data); |
| } |
| |
| /** |
| * hb_paint_push_group_for: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @mode: the compositing mode that will be used when the group is popped |
| * |
| * Perform a "push-group" paint operation, with the compositing |
| * mode known in advance. By default, this calls |
| * hb_paint_push_group(). |
| * |
| * Since: 14.2.0 |
| */ |
| void |
| hb_paint_push_group_for (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_paint_composite_mode_t mode) |
| { |
| funcs->push_group_for (paint_data, mode); |
| } |
| |
| /** |
| * hb_paint_pop_group: |
| * @funcs: paint functions |
| * @paint_data: associated data passed by the caller |
| * @mode: the compositing mode to use |
| * |
| * Perform a "pop-group" paint operation. |
| * |
| * Since: 7.0.0 |
| */ |
| void |
| hb_paint_pop_group (hb_paint_funcs_t *funcs, void *paint_data, |
| hb_paint_composite_mode_t mode) |
| { |
| funcs->pop_group (paint_data, mode); |
| } |
| |
| /** |
| * hb_paint_custom_palette_color: |
| * @funcs: paint functions. |
| * @paint_data: associated data passed by the caller. |
| * @color_index: color index to fetch. |
| * @color: (out): fetched color. |
| * |
| * Gets the custom palette override color for @color_index. |
| * |
| * Return value: `true` if a custom color is provided, `false` otherwise. |
| * |
| * Since: 7.0.0 |
| */ |
| hb_bool_t |
| hb_paint_custom_palette_color (hb_paint_funcs_t *funcs, void *paint_data, |
| unsigned int color_index, |
| hb_color_t *color) |
| { |
| return funcs->custom_palette_color (paint_data, color_index, color); |
| } |
| |
| |
| /** |
| * hb_paint_reduce_linear_anchors: |
| * @x0: x coordinate of P0 (color stop 0). |
| * @y0: y coordinate of P0 (color stop 0). |
| * @x1: x coordinate of P1 (color stop 1). |
| * @y1: y coordinate of P1 (color stop 1). |
| * @x2: x coordinate of P2 (rotation reference). |
| * @y2: y coordinate of P2 (rotation reference). |
| * @xx0: (out): x coordinate of the resulting axis start. |
| * @yy0: (out): y coordinate of the resulting axis start. |
| * @xx1: (out): x coordinate of the resulting axis end. |
| * @yy1: (out): y coordinate of the resulting axis end. |
| * |
| * Reduces a COLRv1 linear gradient's 3-anchor spec (P0=color |
| * stop 0, P1=color stop 1, P2=rotation reference) to the |
| * 2-point axis (P0, P1') used by SVG / cairo / most software |
| * renderers. P1' is the foot of P1 on the line through P0 |
| * perpendicular to (P2 - P0); the resulting axis is the |
| * gradient's actual direction (perpendicular to the rotation |
| * line). Degenerate (P0 == P2) passes through unchanged. |
| * |
| * Since: 14.2.0 |
| **/ |
| void |
| hb_paint_reduce_linear_anchors (float x0, float y0, |
| float x1, float y1, |
| float x2, float y2, |
| float *xx0, float *yy0, |
| float *xx1, float *yy1) |
| { |
| float q2x = x2 - x0, q2y = y2 - y0; |
| float s = q2x * q2x + q2y * q2y; |
| if (s < 1e-6f) |
| { |
| *xx0 = x0; *yy0 = y0; |
| *xx1 = x1; *yy1 = y1; |
| return; |
| } |
| float q1x = x1 - x0, q1y = y1 - y0; |
| float k = (q2x * q1x + q2y * q1y) / s; |
| *xx0 = x0; |
| *yy0 = y0; |
| *xx1 = x1 - k * q2x; |
| *yy1 = y1 - k * q2y; |
| } |
| |
| /** |
| * hb_paint_normalize_color_line: |
| * @stops: (array length=len) (inout): color stops. |
| * @len: number of stops. |
| * @min: (out): original minimum offset. |
| * @max: (out): original maximum offset. |
| * |
| * Sorts @stops by offset and rescales offsets into [0, 1] in |
| * place. Writes the original (min, max) to @min / @max so the |
| * caller can shift the gradient geometry (axis endpoints for |
| * linear, centers+radii for radial, start+end angles for sweep) |
| * to keep the rendered gradient visually unchanged after the |
| * rescale. Empty input is safe: both out-parameters set to 0. |
| * |
| * Since: 14.2.0 |
| **/ |
| void |
| hb_paint_normalize_color_line (hb_color_stop_t *stops, |
| unsigned int len, |
| float *min, |
| float *max) |
| { |
| if (unlikely (!len)) |
| { |
| *min = *max = 0.f; |
| return; |
| } |
| |
| hb_array_t<hb_color_stop_t> (stops, len) |
| .qsort ([] (const hb_color_stop_t &a, const hb_color_stop_t &b) { |
| return (a.offset > b.offset) - (a.offset < b.offset); |
| }); |
| |
| float mn = stops[0].offset, mx = stops[0].offset; |
| for (unsigned i = 1; i < len; i++) |
| { |
| mn = hb_min (mn, stops[i].offset); |
| mx = hb_max (mx, stops[i].offset); |
| } |
| if (mn != mx) |
| for (unsigned i = 0; i < len; i++) |
| stops[i].offset = (stops[i].offset - mn) / (mx - mn); |
| |
| *min = mn; |
| *max = mx; |
| } |
| |
| /** |
| * hb_paint_sweep_gradient_tiles: |
| * @stops: (array length=n_stops) (inout): color stops (sorted, offsets in [0,1]). |
| * @n_stops: number of stops. |
| * @extend: extend mode. |
| * @start_angle: sweep start angle, in radians. |
| * @end_angle: sweep end angle, in radians. |
| * @emit_patch: (scope call): callback invoked once per tile. |
| * @user_data: data passed to @emit_patch. |
| * |
| * Iterates the full 0..2π sweep produced by a color-stop list, |
| * invoking @emit_patch once per (start, end) angular segment. |
| * Handles #HB_PAINT_EXTEND_PAD, #HB_PAINT_EXTEND_REPEAT, and |
| * #HB_PAINT_EXTEND_REFLECT. Stops must be pre-sorted by |
| * offset; use hb_paint_normalize_color_line() first if they |
| * aren't. |
| * |
| * Since: 14.2.0 |
| **/ |
| void |
| hb_paint_sweep_gradient_tiles (hb_color_stop_t *stops, |
| unsigned int n_stops, |
| hb_paint_extend_t extend, |
| float start_angle, |
| float end_angle, |
| hb_paint_sweep_gradient_tile_func_t emit_patch, |
| void *user_data) |
| { |
| if (!n_stops) return; |
| |
| if (start_angle == end_angle) |
| { |
| if (extend == HB_PAINT_EXTEND_PAD) |
| { |
| if (start_angle > 0.f) |
| emit_patch (0.f, stops[0].color, start_angle, stops[0].color, user_data); |
| if (end_angle < HB_2_PI) |
| emit_patch (end_angle, stops[n_stops - 1].color, HB_2_PI, stops[n_stops - 1].color, user_data); |
| } |
| return; |
| } |
| |
| if (end_angle < start_angle) |
| { |
| float tmp = start_angle; start_angle = end_angle; end_angle = tmp; |
| for (unsigned i = 0; i < n_stops - 1 - i; i++) |
| { |
| hb_color_stop_t t = stops[i]; |
| stops[i] = stops[n_stops - 1 - i]; |
| stops[n_stops - 1 - i] = t; |
| } |
| for (unsigned i = 0; i < n_stops; i++) |
| stops[i].offset = 1.f - stops[i].offset; |
| } |
| |
| /* Map stop offsets to angles. */ |
| float angles_buf[16]; |
| hb_color_t colors_buf[16]; |
| float *angles = angles_buf; |
| hb_color_t *colors = colors_buf; |
| bool dynamic = false; |
| |
| if (n_stops > 16) |
| { |
| angles = (float *) hb_malloc (sizeof (float) * n_stops); |
| colors = (hb_color_t *) hb_malloc (sizeof (hb_color_t) * n_stops); |
| if (!angles || !colors) |
| { |
| hb_free (angles); |
| hb_free (colors); |
| return; |
| } |
| dynamic = true; |
| } |
| |
| for (unsigned i = 0; i < n_stops; i++) |
| { |
| angles[i] = start_angle + stops[i].offset * (end_angle - start_angle); |
| colors[i] = stops[i].color; |
| } |
| |
| if (extend == HB_PAINT_EXTEND_PAD) |
| { |
| unsigned pos; |
| hb_color_t color0 = colors[0]; |
| for (pos = 0; pos < n_stops; pos++) |
| { |
| if (angles[pos] >= 0) |
| { |
| if (pos > 0) |
| { |
| float f = (0.f - angles[pos - 1]) / (angles[pos] - angles[pos - 1]); |
| color0 = hb_color_lerp (colors[pos - 1], colors[pos], f); |
| } |
| break; |
| } |
| } |
| if (pos == n_stops) |
| { |
| color0 = colors[n_stops - 1]; |
| emit_patch (0.f, color0, HB_2_PI, color0, user_data); |
| goto done; |
| } |
| emit_patch (0.f, color0, angles[pos], colors[pos], user_data); |
| for (pos++; pos < n_stops; pos++) |
| { |
| if (angles[pos] <= HB_2_PI) |
| emit_patch (angles[pos - 1], colors[pos - 1], angles[pos], colors[pos], user_data); |
| else |
| { |
| float f = (HB_2_PI - angles[pos - 1]) / (angles[pos] - angles[pos - 1]); |
| hb_color_t color1 = hb_color_lerp (colors[pos - 1], colors[pos], f); |
| emit_patch (angles[pos - 1], colors[pos - 1], HB_2_PI, color1, user_data); |
| break; |
| } |
| } |
| if (pos == n_stops) |
| { |
| color0 = colors[n_stops - 1]; |
| emit_patch (angles[n_stops - 1], color0, HB_2_PI, color0, user_data); |
| goto done; |
| } |
| } |
| else |
| { |
| float span = angles[n_stops - 1] - angles[0]; |
| if (fabsf (span) < 1e-6f) |
| goto done; |
| |
| int k = 0; |
| if (angles[0] >= 0) |
| { |
| float ss = angles[0]; |
| while (ss > 0) |
| { |
| if (span > 0) { ss -= span; k--; } |
| else { ss += span; k++; } |
| } |
| } |
| else |
| { |
| float ee = angles[n_stops - 1]; |
| while (ee < 0) |
| { |
| if (span > 0) { ee += span; k++; } |
| else { ee -= span; k--; } |
| } |
| } |
| |
| span = fabsf (span); |
| for (int l = k; l < 1000; l++) |
| { |
| for (unsigned i = 1; i < n_stops; i++) |
| { |
| float a0_l, a1_l; |
| hb_color_t col0, col1; |
| if ((l % 2 != 0) && (extend == HB_PAINT_EXTEND_REFLECT)) |
| { |
| a0_l = angles[0] + angles[n_stops - 1] - angles[n_stops - i] + l * span; |
| a1_l = angles[0] + angles[n_stops - 1] - angles[n_stops - 1 - i] + l * span; |
| col0 = colors[n_stops - i]; |
| col1 = colors[n_stops - 1 - i]; |
| } |
| else |
| { |
| a0_l = angles[i - 1] + l * span; |
| a1_l = angles[i] + l * span; |
| col0 = colors[i - 1]; |
| col1 = colors[i]; |
| } |
| |
| if (a1_l < 0.f) continue; |
| if (a0_l < 0.f) |
| { |
| float f = (0.f - a0_l) / (a1_l - a0_l); |
| hb_color_t c = hb_color_lerp (col0, col1, f); |
| emit_patch (0.f, c, a1_l, col1, user_data); |
| } |
| else if (a1_l >= HB_2_PI) |
| { |
| float f = (HB_2_PI - a0_l) / (a1_l - a0_l); |
| hb_color_t c = hb_color_lerp (col0, col1, f); |
| emit_patch (a0_l, col0, HB_2_PI, c, user_data); |
| goto done; |
| } |
| else |
| emit_patch (a0_l, col0, a1_l, col1, user_data); |
| } |
| } |
| } |
| |
| done: |
| if (dynamic) |
| { |
| hb_free (angles); |
| hb_free (colors); |
| } |
| } |
| |
| #endif |
