| /* |
| * Copyright © 2026 Google, Inc. |
| * |
| * 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. |
| */ |
| |
| #ifndef HB_VECTOR_OUTPUT_HH |
| #define HB_VECTOR_OUTPUT_HH |
| |
| #include <algorithm> |
| #include <math.h> |
| #include <string> |
| #include <vector> |
| |
| #include "output-options.hh" |
| #include "view-options.hh" |
| #include "hb-vector.h" |
| #include "hb-ot.h" |
| |
| |
| struct vector_output_t : output_options_t<>, view_options_t |
| { |
| static const bool repeat_shape = false; |
| |
| ~vector_output_t () |
| { |
| hb_font_destroy (font); |
| hb_font_destroy (upem_font); |
| } |
| |
| void add_options (option_parser_t *parser) |
| { |
| parser->set_summary ("Draw text with given font."); |
| parser->set_description ("Shows shaped glyph outlines as SVG."); |
| |
| output_options_t::add_options (parser); |
| view_options_t::add_options (parser); |
| |
| GOptionEntry entries[] = |
| { |
| {"flat", 0, 0, G_OPTION_ARG_NONE, &this->flat, "Flatten geometry and disable reuse", nullptr}, |
| {"precision", 0, 0, G_OPTION_ARG_INT, &this->precision, "Decimal precision (default: 2)", "N"}, |
| {nullptr} |
| }; |
| parser->add_group (entries, |
| "vector", |
| "Vector options:", |
| "Options for vector output", |
| this); |
| } |
| |
| void post_parse (GError **error) |
| { |
| view_options_t::post_parse (error); |
| if (error && *error) |
| return; |
| |
| if (precision < 0) |
| { |
| g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, |
| "precision must be non-negative"); |
| return; |
| } |
| |
| foreground = HB_COLOR (foreground_color.b, |
| foreground_color.g, |
| foreground_color.r, |
| foreground_color.a); |
| background = HB_COLOR (background_color.b, |
| background_color.g, |
| background_color.r, |
| background_color.a); |
| |
| load_custom_palette_overrides_from_view (); |
| } |
| |
| template <typename app_t> |
| void init (hb_buffer_t *buffer HB_UNUSED, const app_t *font_opts) |
| { |
| lines.clear (); |
| direction = HB_DIRECTION_INVALID; |
| |
| font = hb_font_reference (font_opts->font); |
| subpixel_bits = font_opts->subpixel_bits; |
| hb_font_get_scale (font, &x_scale, &y_scale); |
| upem = hb_face_get_upem (hb_font_get_face (font)); |
| normalized_stroke_width = get_normalized_stroke_width (); |
| |
| upem_font = hb_font_create (hb_font_get_face (font)); |
| hb_font_set_scale (upem_font, upem, upem); |
| #ifndef HB_NO_VAR |
| unsigned int coords_length = 0; |
| const float *coords = hb_font_get_var_coords_design (font, &coords_length); |
| if (coords_length) |
| hb_font_set_var_coords_design (upem_font, coords, coords_length); |
| #endif |
| } |
| |
| void new_line () |
| { |
| lines.emplace_back (); |
| } |
| |
| void consume_text (hb_buffer_t * HB_UNUSED, |
| const char * HB_UNUSED, |
| unsigned int HB_UNUSED, |
| hb_bool_t HB_UNUSED) |
| {} |
| |
| void error (const char *message) |
| { |
| g_printerr ("%s: %s\n", g_get_prgname (), message); |
| } |
| |
| void consume_glyphs (hb_buffer_t *buffer, |
| const char * HB_UNUSED, |
| unsigned int HB_UNUSED, |
| hb_bool_t HB_UNUSED) |
| { |
| if (lines.empty ()) |
| lines.emplace_back (); |
| |
| line_t &line = lines.back (); |
| hb_direction_t line_direction = hb_buffer_get_direction (buffer); |
| if (line_direction == HB_DIRECTION_INVALID) |
| line_direction = HB_DIRECTION_LTR; |
| if (direction == HB_DIRECTION_INVALID) |
| direction = line_direction; |
| |
| unsigned int count = 0; |
| const hb_glyph_info_t *infos = hb_buffer_get_glyph_infos (buffer, &count); |
| const hb_glyph_position_t *positions = hb_buffer_get_glyph_positions (buffer, &count); |
| |
| hb_position_t pen_x = 0; |
| hb_position_t pen_y = 0; |
| |
| line.glyphs.reserve (line.glyphs.size () + count); |
| for (unsigned i = 0; i < count; i++) |
| { |
| line.glyphs.push_back ({ |
| infos[i].codepoint, |
| scale_to_upem_x (pen_x + positions[i].x_offset), |
| scale_to_upem_y (pen_y + positions[i].y_offset), |
| scale_to_upem_x (positions[i].x_advance), |
| scale_to_upem_y (positions[i].y_advance), |
| }); |
| |
| pen_x += positions[i].x_advance; |
| pen_y += positions[i].y_advance; |
| } |
| |
| line.advance_x = scale_to_upem_x (pen_x); |
| line.advance_y = scale_to_upem_y (pen_y); |
| } |
| |
| template <typename app_t> |
| void finish (hb_buffer_t *buffer HB_UNUSED, const app_t *app HB_UNUSED) |
| { |
| hb_vector_extents_t extents = {}; |
| if (!compute_extents (&extents)) |
| return; |
| final_extents = extents; |
| |
| hb_vector_draw_t *draw = hb_vector_draw_create_or_fail (HB_VECTOR_FORMAT_SVG); |
| hb_vector_paint_t *paint = hb_vector_paint_create_or_fail (HB_VECTOR_FORMAT_SVG); |
| |
| hb_vector_draw_set_scale_factor (draw, 1.f, 1.f); |
| hb_vector_draw_set_extents (draw, &extents); |
| hb_vector_svg_set_precision (draw, precision); |
| hb_vector_svg_set_flat (draw, flat); |
| |
| hb_vector_paint_set_scale_factor (paint, 1.f, 1.f); |
| hb_vector_paint_set_extents (paint, &extents); |
| hb_vector_paint_set_foreground (paint, foreground); |
| hb_vector_paint_set_palette (paint, this->palette); |
| apply_custom_palette (paint); |
| init_palette_color_cache (); |
| hb_vector_svg_paint_set_precision (paint, precision); |
| hb_vector_svg_paint_set_flat (paint, flat); |
| |
| bool had_draw = false; |
| bool had_paint = false; |
| hb_vector_extents_mode_t extents_mode = HB_VECTOR_EXTENTS_MODE_NONE; |
| const bool use_foreground_palette = |
| foreground_use_palette && foreground_palette && foreground_palette->len; |
| unsigned palette_glyph_index = 0; |
| |
| hb_direction_t dir = direction; |
| if (dir == HB_DIRECTION_INVALID) |
| dir = HB_DIRECTION_LTR; |
| bool vertical = HB_DIRECTION_IS_VERTICAL (dir); |
| |
| float asc = 0.f, desc = 0.f, gap = 0.f; |
| get_line_metrics (dir, &asc, &desc, &gap); |
| float step = fabsf (asc - desc + gap + (float) line_space); |
| if (!(step > 0.f)) |
| step = (float) upem; |
| line_step = step; |
| |
| for (unsigned li = 0; li < lines.size (); li++) |
| { |
| float off_x = vertical ? -(step * (float) li) : 0.f; |
| float off_y = vertical ? 0.f : -(step * (float) li); |
| |
| for (const auto &g : lines[li].glyphs) |
| { |
| float pen_x = g.x + off_x; |
| float pen_y = g.y + off_y; |
| |
| if (use_foreground_palette) |
| { |
| const rgba_color_t &c = |
| g_array_index (foreground_palette, rgba_color_t, |
| palette_glyph_index++ % foreground_palette->len); |
| hb_vector_paint_set_foreground (paint, HB_COLOR (c.b, c.g, c.r, c.a)); |
| } |
| |
| hb_vector_paint_set_transform (paint, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f); |
| if (hb_vector_paint_glyph (paint, upem_font, g.gid, pen_x, pen_y, |
| extents_mode)) |
| { |
| had_paint = true; |
| continue; |
| } |
| |
| if (hb_vector_draw_glyph (draw, upem_font, g.gid, pen_x, pen_y, |
| extents_mode)) |
| had_draw = true; |
| } |
| } |
| |
| hb_blob_t *draw_blob = had_draw ? hb_vector_draw_render (draw) : nullptr; |
| hb_blob_t *paint_blob = had_paint ? hb_vector_paint_render (paint) : nullptr; |
| |
| if (draw_blob && draw_blob != hb_blob_get_empty () && |
| paint_blob && paint_blob != hb_blob_get_empty ()) |
| write_combined_svg (draw_blob, paint_blob); |
| else if (paint_blob && paint_blob != hb_blob_get_empty ()) |
| write_blob (paint_blob, false); |
| else if (draw_blob && draw_blob != hb_blob_get_empty ()) |
| write_blob (draw_blob, true); |
| |
| hb_blob_destroy (draw_blob); |
| hb_blob_destroy (paint_blob); |
| hb_vector_draw_destroy (draw); |
| hb_vector_paint_destroy (paint); |
| |
| hb_font_destroy (upem_font); |
| upem_font = nullptr; |
| hb_font_destroy (font); |
| font = nullptr; |
| lines.clear (); |
| } |
| |
| private: |
| |
| struct glyph_instance_t |
| { |
| hb_codepoint_t gid; |
| float x; |
| float y; |
| float ax; |
| float ay; |
| }; |
| |
| struct line_t |
| { |
| float advance_x = 0.f; |
| float advance_y = 0.f; |
| std::vector<glyph_instance_t> glyphs; |
| }; |
| |
| struct slice_t |
| { |
| const char *p = nullptr; |
| unsigned len = 0; |
| }; |
| |
| bool compute_extents (hb_vector_extents_t *extents) |
| { |
| if (lines.empty ()) |
| { |
| extents->x = 0; |
| extents->y = 0; |
| extents->width = 1; |
| extents->height = 1; |
| return true; |
| } |
| |
| hb_direction_t dir = direction; |
| if (dir == HB_DIRECTION_INVALID) |
| dir = HB_DIRECTION_LTR; |
| bool vertical = HB_DIRECTION_IS_VERTICAL (dir); |
| |
| float asc = 0.f, desc = 0.f, gap = 0.f; |
| get_line_metrics (dir, &asc, &desc, &gap); |
| float step = fabsf (asc - desc + gap + (float) line_space); |
| if (!(step > 0.f)) |
| step = (float) upem; |
| |
| bool valid = false; |
| float x1 = 0, y1 = 0, x2 = 0, y2 = 0; |
| bool include_logical = include_logical_extents (); |
| bool include_ink = include_ink_extents (); |
| |
| auto include_point = [&] (float x, float y) |
| { |
| y = -y; |
| if (!valid) |
| { |
| x1 = x2 = x; |
| y1 = y2 = y; |
| valid = true; |
| return; |
| } |
| x1 = hb_min (x1, x); |
| y1 = hb_min (y1, y); |
| x2 = hb_max (x2, x); |
| y2 = hb_max (y2, y); |
| }; |
| |
| for (unsigned li = 0; li < lines.size (); li++) |
| { |
| float off_x = vertical ? -(step * (float) li) : 0.f; |
| float off_y = vertical ? 0.f : -(step * (float) li); |
| |
| const line_t &line = lines[li]; |
| |
| if (include_logical) |
| { |
| float log_min = hb_min (desc, asc); |
| float log_max = hb_max (desc, asc); |
| if (vertical) |
| { |
| include_point (off_x + log_min, hb_min (0.f, line.advance_y)); |
| include_point (off_x + log_max, hb_max (0.f, line.advance_y)); |
| } |
| else |
| { |
| include_point (hb_min (0.f, line.advance_x), off_y + log_min); |
| include_point (hb_max (0.f, line.advance_x), off_y + log_max); |
| } |
| } |
| |
| if (include_ink) |
| for (const auto &g : line.glyphs) |
| { |
| hb_glyph_extents_t ge; |
| if (!hb_font_get_glyph_extents (upem_font, g.gid, &ge)) |
| continue; |
| |
| float gx = g.x + off_x; |
| float gy = g.y + off_y; |
| |
| float xa = gx + ge.x_bearing; |
| float ya = gy + ge.y_bearing; |
| float xb = xa + ge.width; |
| float yb = ya + ge.height; |
| |
| include_point (xa, ya); |
| include_point (xb, yb); |
| } |
| } |
| |
| if (!valid) |
| { |
| extents->x = 0; |
| extents->y = 0; |
| extents->width = 1; |
| extents->height = 1; |
| return true; |
| } |
| |
| if (x2 <= x1) |
| x2 = x1 + 1; |
| if (y2 <= y1) |
| y2 = y1 + 1; |
| |
| x1 -= (float) margin.l; |
| y1 -= (float) margin.t; |
| x2 += (float) margin.r; |
| y2 += (float) margin.b; |
| |
| extents->x = x1; |
| extents->y = y1; |
| extents->width = x2 - x1; |
| extents->height = y2 - y1; |
| return true; |
| } |
| |
| float scale_to_upem_x (hb_position_t v) const |
| { |
| return (float) v * upem / x_scale; |
| } |
| |
| float scale_to_upem_y (hb_position_t v) const |
| { |
| return (float) v * upem / y_scale; |
| } |
| |
| static bool slice_svg (const char *data, unsigned len, |
| slice_t *defs, slice_t *body) |
| { |
| defs->p = nullptr; |
| defs->len = 0; |
| body->p = nullptr; |
| body->len = 0; |
| |
| const char *data_end = data + len; |
| const char *start = (const char *) memchr (data, '>', len); |
| if (!start) |
| return false; |
| start += 1; |
| |
| if (len < 6) |
| return false; |
| |
| const char *end = nullptr; |
| for (const char *p = data_end - 6; p >= data; p--) |
| { |
| if (memcmp (p, "</svg>", 6) == 0) |
| { |
| end = p; |
| break; |
| } |
| if (p == data) |
| break; |
| } |
| if (!end || end <= start) |
| return false; |
| |
| const char *defs_start = start; |
| while (defs_start < end && |
| (*defs_start == ' ' || *defs_start == '\t' || |
| *defs_start == '\r' || *defs_start == '\n')) |
| defs_start++; |
| if (!(defs_start + 6 <= end && memcmp (defs_start, "<defs>", 6) == 0)) |
| defs_start = nullptr; |
| |
| const char *defs_end = nullptr; |
| if (defs_start) |
| for (const char *p = defs_start + 6; p + 7 <= end; p++) |
| if (memcmp (p, "</defs>", 7) == 0) |
| { |
| defs_end = p; |
| break; |
| } |
| |
| if (defs_start && defs_end && defs_start < end && defs_end < end) |
| { |
| defs->p = defs_start + strlen ("<defs>"); |
| defs->len = (unsigned) (defs_end - defs->p); |
| |
| const char *body_start = defs_end + strlen ("</defs>"); |
| if (body_start < end) |
| { |
| body->p = body_start; |
| body->len = (unsigned) (end - body_start); |
| } |
| } |
| else |
| { |
| body->p = start; |
| body->len = (unsigned) (end - start); |
| } |
| |
| return true; |
| } |
| |
| void emit_fill_group_open () |
| { |
| const bool has_fill_override = fore || foreground_use_palette; |
| const bool has_stroke = stroke_enabled && stroke_width > 0.; |
| if (!has_fill_override && !has_stroke) |
| return; |
| |
| fputs ("<g", out_fp); |
| |
| if (has_fill_override) |
| { |
| unsigned r = hb_color_get_red (foreground); |
| unsigned g = hb_color_get_green (foreground); |
| unsigned b = hb_color_get_blue (foreground); |
| unsigned a = hb_color_get_alpha (foreground); |
| fprintf (out_fp, " fill=\"#%02X%02X%02X\"", r, g, b); |
| if (a != 255) |
| fprintf (out_fp, " fill-opacity=\"%.3f\"", (double) a / 255.); |
| } |
| else |
| fputs (" fill=\"none\"", out_fp); |
| |
| if (has_stroke) |
| emit_stroke_attrs (); |
| |
| fprintf (out_fp, ">\n"); |
| } |
| |
| void emit_fill_group_close () |
| { |
| if (!(fore || foreground_use_palette || (stroke_enabled && stroke_width > 0.))) |
| return; |
| fputs ("</g>\n", out_fp); |
| } |
| |
| void emit_fill_stroke_attrs_for_color (hb_color_t color) |
| { |
| unsigned r = hb_color_get_red (color); |
| unsigned g = hb_color_get_green (color); |
| unsigned b = hb_color_get_blue (color); |
| unsigned a = hb_color_get_alpha (color); |
| fprintf (out_fp, " fill=\"#%02X%02X%02X\"", r, g, b); |
| if (a != 255) |
| fprintf (out_fp, " fill-opacity=\"%.3f\"", (double) a / 255.); |
| |
| } |
| |
| void emit_draw_body_with_palette (slice_t body) |
| { |
| if (!foreground_palette || !foreground_palette->len || !body.p || !body.len) |
| return; |
| |
| const char *p = body.p; |
| const char *end = body.p + body.len; |
| unsigned palette_i = 0; |
| const bool has_stroke = stroke_enabled && stroke_width > 0.; |
| if (has_stroke) |
| { |
| fputs ("<g", out_fp); |
| emit_stroke_attrs (); |
| fputs (">\n", out_fp); |
| } |
| while (p < end) |
| { |
| const char *line_end = (const char *) memchr (p, '\n', (size_t) (end - p)); |
| if (!line_end) |
| line_end = end; |
| |
| const char *s = p; |
| while (s < line_end && (*s == ' ' || *s == '\t' || *s == '\r')) |
| s++; |
| bool is_elem = s < line_end && *s == '<' && (s + 1 < line_end && s[1] != '/'); |
| |
| if (is_elem) |
| { |
| const rgba_color_t &c = |
| g_array_index (foreground_palette, rgba_color_t, |
| palette_i++ % foreground_palette->len); |
| hb_color_t col = HB_COLOR (c.b, c.g, c.r, c.a); |
| fputs ("<g", out_fp); |
| emit_fill_stroke_attrs_for_color (col); |
| fputs (">", out_fp); |
| fwrite (p, 1, (size_t) (line_end - p), out_fp); |
| fputs ("</g>\n", out_fp); |
| } |
| else |
| { |
| fwrite (p, 1, (size_t) (line_end - p), out_fp); |
| fputc ('\n', out_fp); |
| } |
| |
| p = line_end; |
| if (p < end && *p == '\n') |
| p++; |
| } |
| if (has_stroke) |
| fputs ("</g>\n", out_fp); |
| } |
| |
| void emit_stroke_attrs () |
| { |
| fprintf (out_fp, " stroke=\"#%02X%02X%02X\"", |
| stroke_color.r, stroke_color.g, stroke_color.b); |
| if (stroke_color.a != 255) |
| fprintf (out_fp, " stroke-opacity=\"%.3f\"", (double) stroke_color.a / 255.); |
| fprintf (out_fp, " stroke-width=\"%.*g\" stroke-linecap=\"round\" stroke-linejoin=\"round\"", |
| precision + 4, normalized_stroke_width); |
| } |
| |
| double get_normalized_stroke_width () const |
| { |
| if (!stroke_enabled || stroke_width <= 0. || !upem || !x_scale || !y_scale) |
| return stroke_width; |
| |
| /* hb-vector emits geometry in upem space; convert user stroke width |
| * from the requested font scale back into that normalized coordinate system. |
| */ |
| double norm_x = stroke_width * scalbn ((double) upem, (int) subpixel_bits) / fabs ((double) x_scale); |
| double norm_y = stroke_width * scalbn ((double) upem, (int) subpixel_bits) / fabs ((double) y_scale); |
| return 0.5 * (norm_x + norm_y); |
| } |
| |
| bool lookup_palette_color (unsigned idx, hb_color_t *color) const |
| { |
| if (idx < custom_palette_has_value.size () && custom_palette_has_value[idx]) |
| { |
| *color = custom_palette_values[idx]; |
| return true; |
| } |
| |
| if (!palette_lookup_enabled) |
| return false; |
| |
| if (palette_cache_state.size () <= idx) |
| { |
| palette_cache_state.resize (idx + 1, 0); |
| palette_cache_values.resize (idx + 1, HB_COLOR (0, 0, 0, 255)); |
| } |
| |
| if (palette_cache_state[idx] == 1) |
| { |
| *color = palette_cache_values[idx]; |
| return true; |
| } |
| if (palette_cache_state[idx] == 2) |
| return false; |
| |
| hb_color_t fetched = HB_COLOR (0, 0, 0, 255); |
| unsigned n = 1; |
| if (hb_ot_color_palette_get_colors (palette_face, palette_lookup_index, |
| idx, &n, &fetched) && n) |
| { |
| palette_cache_values[idx] = fetched; |
| palette_cache_state[idx] = 1; |
| *color = fetched; |
| return true; |
| } |
| |
| palette_cache_state[idx] = 2; |
| return false; |
| } |
| |
| static inline const char * |
| skip_ascii_ws (const char *p, const char *end) |
| { |
| while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) |
| p++; |
| return p; |
| } |
| |
| static inline const char * |
| trim_ascii_ws_right (const char *begin, const char *end) |
| { |
| while (end > begin && |
| (end[-1] == ' ' || end[-1] == '\t' || end[-1] == '\n' || end[-1] == '\r')) |
| end--; |
| return end; |
| } |
| |
| struct parsed_var_color_expr_t |
| { |
| const char *expr_end = nullptr; |
| const char *fallback_begin = nullptr; |
| const char *fallback_end = nullptr; |
| unsigned idx = 0; |
| bool parse_ok = false; |
| bool have_digits = false; |
| bool has_fallback = false; |
| }; |
| |
| static inline const char * |
| find_next_var_expr (const char *p, const char *end) |
| { |
| for (const char *q = p; q + 4 <= end; q++) |
| if (memcmp (q, "var(", 4) == 0) |
| return q; |
| return nullptr; |
| } |
| |
| static inline const char * |
| find_matching_paren (const char *inside, const char *end) |
| { |
| unsigned depth = 1; |
| for (const char *q = inside; q < end; q++) |
| { |
| if (*q == '(') depth++; |
| else if (*q == ')') |
| { |
| depth--; |
| if (!depth) |
| return q; |
| } |
| } |
| return nullptr; |
| } |
| |
| static inline parsed_var_color_expr_t |
| parse_var_color_expr (const char *match, const char *end) |
| { |
| parsed_var_color_expr_t parsed; |
| const char *expr_close = find_matching_paren (match + 4, end); |
| if (!expr_close) |
| return parsed; |
| |
| parsed.expr_end = expr_close + 1; |
| const char *inside = match + 4; |
| const char *inside_end = expr_close; |
| const char *q = skip_ascii_ws (inside, inside_end); |
| parsed.parse_ok = true; |
| |
| if (!(q + 7 <= inside_end && memcmp (q, "--color", 7) == 0)) |
| parsed.parse_ok = false; |
| if (parsed.parse_ok) |
| q += 7; |
| |
| while (parsed.parse_ok && q < inside_end && *q >= '0' && *q <= '9') |
| { |
| parsed.have_digits = true; |
| parsed.idx = parsed.idx * 10 + (unsigned) (*q - '0'); |
| q++; |
| } |
| q = skip_ascii_ws (q, inside_end); |
| |
| if (parsed.parse_ok && q < inside_end && *q == ',') |
| { |
| parsed.has_fallback = true; |
| q++; |
| parsed.fallback_begin = skip_ascii_ws (q, inside_end); |
| parsed.fallback_end = trim_ascii_ws_right (parsed.fallback_begin, inside_end); |
| q = inside_end; |
| } |
| |
| if (parsed.parse_ok && q != inside_end) |
| parsed.parse_ok = false; |
| |
| return parsed; |
| } |
| |
| void emit_css_color (hb_color_t color) |
| { |
| unsigned r = hb_color_get_red (color); |
| unsigned g = hb_color_get_green (color); |
| unsigned b = hb_color_get_blue (color); |
| unsigned a = hb_color_get_alpha (color); |
| if (a == 255) |
| fprintf (out_fp, "#%02X%02X%02X", r, g, b); |
| else |
| fprintf (out_fp, "rgba(%u,%u,%u,%.6g)", r, g, b, (double) a / 255.); |
| } |
| |
| void write_slice_resolving_palette_vars (slice_t s) |
| { |
| if (!s.p || !s.len) |
| return; |
| |
| const char *p = s.p; |
| const char *end = s.p + s.len; |
| while (p < end) |
| { |
| const char *match = find_next_var_expr (p, end); |
| |
| if (!match) |
| { |
| fwrite (p, 1, (size_t) (end - p), out_fp); |
| return; |
| } |
| |
| if (match > p) |
| fwrite (p, 1, (size_t) (match - p), out_fp); |
| |
| parsed_var_color_expr_t parsed = parse_var_color_expr (match, end); |
| if (!parsed.expr_end) |
| { |
| fwrite (match, 1, (size_t) (end - match), out_fp); |
| return; |
| } |
| |
| hb_color_t color; |
| if (parsed.parse_ok && parsed.have_digits && lookup_palette_color (parsed.idx, &color)) |
| { |
| emit_css_color (color); |
| } |
| else if (parsed.has_fallback && parsed.fallback_begin && |
| parsed.fallback_end >= parsed.fallback_begin) |
| { |
| fwrite (parsed.fallback_begin, 1, |
| (size_t) (parsed.fallback_end - parsed.fallback_begin), out_fp); |
| } |
| else |
| { |
| fwrite (match, 1, (size_t) (parsed.expr_end - match), out_fp); |
| } |
| |
| p = parsed.expr_end; |
| } |
| } |
| |
| void write_blob (hb_blob_t *blob, |
| hb_bool_t is_draw_blob) |
| { |
| unsigned in_len = 0; |
| const char *in_data = hb_blob_get_data (blob, &in_len); |
| if (!in_data || !in_len) |
| return; |
| |
| const char *hdr_end = (const char *) memchr (in_data, '>', in_len); |
| if (!hdr_end) |
| return; |
| |
| slice_t defs, body; |
| if (!slice_svg (in_data, in_len, &defs, &body)) |
| return; |
| |
| fwrite (in_data, 1, (hdr_end - in_data + 1), out_fp); |
| fputc ('\n', out_fp); |
| |
| if (defs.len) |
| { |
| fputs ("<defs>\n", out_fp); |
| write_slice_resolving_palette_vars (defs); |
| fputs ("</defs>\n", out_fp); |
| } |
| |
| emit_background_rect (); |
| |
| if (is_draw_blob && foreground_use_palette && foreground_palette && foreground_palette->len) |
| emit_draw_body_with_palette (body); |
| else if (is_draw_blob) |
| emit_fill_group_open (); |
| |
| if (body.len && !(is_draw_blob && foreground_use_palette && foreground_palette && foreground_palette->len)) |
| write_slice_resolving_palette_vars (body); |
| |
| if (is_draw_blob && !(foreground_use_palette && foreground_palette && foreground_palette->len)) |
| emit_fill_group_close (); |
| |
| if (show_extents) |
| emit_extents_overlay (direction == HB_DIRECTION_INVALID ? HB_DIRECTION_LTR : direction, line_step); |
| |
| fputs ("</svg>\n", out_fp); |
| } |
| |
| void write_combined_svg (hb_blob_t *draw_blob, |
| hb_blob_t *paint_blob) |
| { |
| unsigned draw_len = 0, paint_len = 0; |
| const char *draw_data = hb_blob_get_data (draw_blob, &draw_len); |
| const char *paint_data = hb_blob_get_data (paint_blob, &paint_len); |
| if (!draw_data || !paint_data) |
| return; |
| |
| const char *draw_hdr_end = (const char *) memchr (draw_data, '>', draw_len); |
| if (!draw_hdr_end) |
| return; |
| |
| slice_t draw_defs, draw_body; |
| slice_t paint_defs, paint_body; |
| if (!slice_svg (draw_data, draw_len, &draw_defs, &draw_body) || |
| !slice_svg (paint_data, paint_len, &paint_defs, &paint_body)) |
| return; |
| |
| fwrite (draw_data, 1, (draw_hdr_end - draw_data + 1), out_fp); |
| fputc ('\n', out_fp); |
| |
| if (draw_defs.len || paint_defs.len) |
| { |
| fputs ("<defs>\n", out_fp); |
| if (draw_defs.len) |
| write_slice_resolving_palette_vars (draw_defs); |
| if (paint_defs.len) |
| write_slice_resolving_palette_vars (paint_defs); |
| fputs ("</defs>\n", out_fp); |
| } |
| |
| emit_background_rect (); |
| |
| if (foreground_use_palette && foreground_palette && foreground_palette->len) |
| emit_draw_body_with_palette (draw_body); |
| else |
| { |
| emit_fill_group_open (); |
| if (draw_body.len) |
| fwrite (draw_body.p, 1, draw_body.len, out_fp); |
| emit_fill_group_close (); |
| } |
| if (paint_body.len) |
| write_slice_resolving_palette_vars (paint_body); |
| |
| if (show_extents) |
| emit_extents_overlay (direction == HB_DIRECTION_INVALID ? HB_DIRECTION_LTR : direction, line_step); |
| |
| fputs ("</svg>\n", out_fp); |
| } |
| |
| void emit_background_rect () |
| { |
| if (!has_background) |
| return; |
| unsigned r = hb_color_get_red (background); |
| unsigned g = hb_color_get_green (background); |
| unsigned b = hb_color_get_blue (background); |
| unsigned a = hb_color_get_alpha (background); |
| fprintf (out_fp, "<rect x=\"%.*g\" y=\"%.*g\" width=\"%.*g\" height=\"%.*g\" fill=\"#%02X%02X%02X\"", |
| precision + 4, (double) final_extents.x, |
| precision + 4, (double) final_extents.y, |
| precision + 4, (double) final_extents.width, |
| precision + 4, (double) final_extents.height, |
| r, g, b); |
| if (a != 255) |
| fprintf (out_fp, " fill-opacity=\"%.3f\"", (double) a / 255.); |
| fputs ("/>\n", out_fp); |
| } |
| |
| void apply_custom_palette (hb_vector_paint_t *paint) |
| { |
| hb_vector_paint_clear_custom_palette_colors (paint); |
| for (unsigned idx = 0; idx < custom_palette_values.size (); idx++) |
| if (idx < custom_palette_has_value.size () && custom_palette_has_value[idx]) |
| hb_vector_paint_set_custom_palette_color (paint, idx, custom_palette_values[idx]); |
| } |
| |
| void init_palette_color_cache () |
| { |
| palette_cache_values.clear (); |
| palette_cache_state.clear (); |
| palette_face = nullptr; |
| palette_lookup_index = 0; |
| palette_lookup_enabled = false; |
| |
| hb_face_t *face = hb_font_get_face (upem_font ? upem_font : font); |
| if (!face) |
| return; |
| |
| unsigned palette_count = hb_ot_color_palette_get_count (face); |
| if (!palette_count) |
| return; |
| |
| unsigned palette_index = palette >= 0 ? (unsigned) palette : 0u; |
| if (palette_index >= palette_count) |
| palette_index = 0; |
| |
| palette_face = face; |
| palette_lookup_index = palette_index; |
| palette_lookup_enabled = true; |
| } |
| |
| void load_custom_palette_overrides_from_view () |
| { |
| custom_palette_values.clear (); |
| custom_palette_has_value.clear (); |
| if (!custom_palette_entries) |
| return; |
| |
| for (unsigned i = 0; i < custom_palette_entries->len; i++) |
| { |
| const custom_palette_entry_t &entry = |
| g_array_index (custom_palette_entries, custom_palette_entry_t, i); |
| unsigned idx = entry.index; |
| if (custom_palette_values.size () <= idx) |
| { |
| custom_palette_values.resize (idx + 1, HB_COLOR (0, 0, 0, 255)); |
| custom_palette_has_value.resize (idx + 1, false); |
| } |
| custom_palette_values[idx] = HB_COLOR (entry.color.b, |
| entry.color.g, |
| entry.color.r, |
| entry.color.a); |
| custom_palette_has_value[idx] = true; |
| } |
| } |
| |
| void emit_extents_overlay (hb_direction_t dir, float step) |
| { |
| const bool vertical = HB_DIRECTION_IS_VERTICAL (dir); |
| const float dot_r = hb_max (1.f, step * 0.01f); |
| fputs ("<g fill=\"#FF0000\" fill-opacity=\"0.502\" stroke=\"none\">\n", out_fp); |
| for (unsigned li = 0; li < lines.size (); li++) |
| { |
| float off_x = vertical ? -(step * (float) li) : 0.f; |
| float off_y = vertical ? 0.f : -(step * (float) li); |
| const line_t &line = lines[li]; |
| for (const auto &g : line.glyphs) |
| { |
| fprintf (out_fp, "<circle cx=\"%.*g\" cy=\"%.*g\" r=\"%.*g\"/>\n", |
| precision + 4, (double) (g.x + off_x), |
| precision + 4, (double) (-(g.y + off_y)), |
| precision + 4, (double) dot_r); |
| } |
| } |
| fputs ("</g>\n", out_fp); |
| |
| fprintf (out_fp, "<g fill=\"none\" stroke=\"#FF00FF\" stroke-opacity=\"0.502\" stroke-width=\"%.*g\">\n", |
| precision + 4, normalized_stroke_width); |
| for (unsigned li = 0; li < lines.size (); li++) |
| { |
| float off_x = vertical ? -(step * (float) li) : 0.f; |
| float off_y = vertical ? 0.f : -(step * (float) li); |
| const line_t &line = lines[li]; |
| for (const auto &g : line.glyphs) |
| { |
| hb_glyph_extents_t ge; |
| if (!hb_font_get_glyph_extents (upem_font, g.gid, &ge)) |
| continue; |
| float x = g.x + off_x + ge.x_bearing; |
| float y = g.y + off_y + ge.y_bearing; |
| float w = ge.width; |
| float h = ge.height; |
| if (!w || !h) |
| continue; |
| fprintf (out_fp, "<rect x=\"%.*g\" y=\"%.*g\" width=\"%.*g\" height=\"%.*g\"/>\n", |
| precision + 4, (double) x, |
| precision + 4, (double) (-y), |
| precision + 4, (double) w, |
| precision + 4, (double) (-h)); |
| } |
| } |
| fputs ("</g>\n", out_fp); |
| } |
| |
| void get_line_metrics (hb_direction_t dir, float *asc, float *desc, float *gap) const |
| { |
| if (have_font_extents) |
| { |
| if (asc) *asc = (float) font_extents.ascent; |
| if (desc) *desc = (float) (-font_extents.descent); |
| if (gap) *gap = (float) font_extents.line_gap; |
| return; |
| } |
| |
| hb_font_extents_t fext = {0, 0, 0}; |
| hb_font_get_extents_for_direction (upem_font, dir, &fext); |
| if (asc) *asc = (float) fext.ascender; |
| if (desc) *desc = (float) fext.descender; |
| if (gap) *gap = (float) fext.line_gap; |
| } |
| |
| hb_bool_t flat = false; |
| int precision = 2; |
| hb_color_t background = HB_COLOR (255, 255, 255, 255); |
| hb_color_t foreground = HB_COLOR (0, 0, 0, 255); |
| |
| hb_font_t *font = nullptr; |
| hb_font_t *upem_font = nullptr; |
| std::vector<line_t> lines; |
| hb_direction_t direction = HB_DIRECTION_INVALID; |
| |
| int x_scale = 0; |
| int y_scale = 0; |
| unsigned upem = 0; |
| unsigned subpixel_bits = 0; |
| double normalized_stroke_width = DEFAULT_STROKE_WIDTH; |
| float line_step = 0.f; |
| hb_vector_extents_t final_extents = {0, 0, 1, 1}; |
| std::vector<hb_color_t> custom_palette_values; |
| std::vector<bool> custom_palette_has_value; |
| mutable std::vector<hb_color_t> palette_cache_values; |
| mutable std::vector<unsigned char> palette_cache_state; |
| hb_face_t *palette_face = nullptr; |
| unsigned palette_lookup_index = 0; |
| bool palette_lookup_enabled = false; |
| }; |
| |
| #endif |
