| /* |
| * 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 |
| */ |
| |
| #ifndef HB_NO_RASTER_SVG |
| |
| #include "hb.hh" |
| |
| #include "hb-raster-svg-base.hh" |
| #include "hb-raster-svg-parse.hh" |
| |
| void |
| svg_parse_style_props (hb_svg_str_t style, hb_svg_style_props_t *out) |
| { |
| if (style.is_null ()) return; |
| const char *p = style.data; |
| const char *end = style.data + style.len; |
| while (p < end) |
| { |
| while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || *p == ';')) |
| p++; |
| if (p >= end) break; |
| const char *name_start = p; |
| while (p < end && *p != ':' && *p != ';') |
| p++; |
| const char *name_end = p; |
| while (name_end > name_start && |
| (name_end[-1] == ' ' || name_end[-1] == '\t' || name_end[-1] == '\n' || name_end[-1] == '\r')) |
| name_end--; |
| if (p >= end || *p != ':') |
| { |
| while (p < end && *p != ';') p++; |
| continue; |
| } |
| p++; /* skip ':' */ |
| const char *value_start = p; |
| while (p < end && *p != ';') |
| p++; |
| const char *value_end = p; |
| while (value_start < value_end && |
| (*value_start == ' ' || *value_start == '\t' || *value_start == '\n' || *value_start == '\r')) |
| value_start++; |
| while (value_end > value_start && |
| (value_end[-1] == ' ' || value_end[-1] == '\t' || value_end[-1] == '\n' || value_end[-1] == '\r')) |
| value_end--; |
| |
| hb_svg_str_t prop_name = {name_start, (unsigned) (name_end - name_start)}; |
| hb_svg_str_t prop_value = {value_start, (unsigned) (value_end - value_start)}; |
| if (prop_name.len) |
| { |
| switch (hb_svg_ascii_lower (prop_name.data[0])) |
| { |
| case 'c': |
| if (prop_name.len == 9 && prop_name.eq_ascii_ci ("clip-path")) out->clip_path = prop_value; |
| else if (prop_name.len == 5 && prop_name.eq_ascii_ci ("color")) out->color = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("cx")) out->cx = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("cy")) out->cy = prop_value; |
| break; |
| case 'd': |
| if (prop_name.len == 7 && prop_name.eq_ascii_ci ("display")) out->display = prop_value; |
| else if (prop_name.len == 1 && prop_name.eq_ascii_ci ("d")) out->d = prop_value; |
| break; |
| case 'f': |
| if (prop_name.len == 4 && prop_name.eq_ascii_ci ("fill")) out->fill = prop_value; |
| else if (prop_name.len == 12 && prop_name.eq_ascii_ci ("fill-opacity")) out->fill_opacity = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("fx")) out->fx = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("fy")) out->fy = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("fr")) out->fr = prop_value; |
| break; |
| case 'g': |
| if ((prop_name.len == 13 && prop_name.eq_ascii_ci ("gradientunits")) || |
| (prop_name.len == 14 && prop_name.eq_ascii_ci ("gradient-units"))) out->gradient_units = prop_value; |
| else if ((prop_name.len == 17 && prop_name.eq_ascii_ci ("gradienttransform")) || |
| (prop_name.len == 18 && prop_name.eq_ascii_ci ("gradient-transform"))) out->gradient_transform = prop_value; |
| break; |
| case 'h': |
| if (prop_name.len == 6 && prop_name.eq_ascii_ci ("height")) out->height = prop_value; |
| break; |
| case 'o': |
| if (prop_name.len == 7 && prop_name.eq_ascii_ci ("opacity")) out->opacity = prop_value; |
| else if (prop_name.len == 6 && prop_name.eq_ascii_ci ("offset")) out->offset = prop_value; |
| break; |
| case 'p': |
| if (prop_name.len == 6 && prop_name.eq_ascii_ci ("points")) out->points = prop_value; |
| break; |
| case 'r': |
| if (prop_name.len == 1 && prop_name.eq_ascii_ci ("r")) out->r = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("rx")) out->rx = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("ry")) out->ry = prop_value; |
| break; |
| case 's': |
| if (prop_name.len == 10 && prop_name.eq_ascii_ci ("stop-color")) out->stop_color = prop_value; |
| else if (prop_name.len == 12 && prop_name.eq_ascii_ci ("stop-opacity")) out->stop_opacity = prop_value; |
| else if ((prop_name.len == 12 && prop_name.eq_ascii_ci ("spreadmethod")) || |
| (prop_name.len == 13 && prop_name.eq_ascii_ci ("spread-method"))) out->spread_method = prop_value; |
| break; |
| case 't': |
| if (prop_name.len == 9 && prop_name.eq_ascii_ci ("transform")) out->transform = prop_value; |
| break; |
| case 'v': |
| if (prop_name.len == 10 && prop_name.eq_ascii_ci ("visibility")) out->visibility = prop_value; |
| break; |
| case 'w': |
| if (prop_name.len == 5 && prop_name.eq_ascii_ci ("width")) out->width = prop_value; |
| break; |
| case 'x': |
| if (prop_name.len == 1 && prop_name.eq_ascii_ci ("x")) out->x = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("x1")) out->x1 = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("x2")) out->x2 = prop_value; |
| break; |
| case 'y': |
| if (prop_name.len == 1 && prop_name.eq_ascii_ci ("y")) out->y = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("y1")) out->y1 = prop_value; |
| else if (prop_name.len == 2 && prop_name.eq_ascii_ci ("y2")) out->y2 = prop_value; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| if (p < end && *p == ';') p++; |
| } |
| } |
| |
| float |
| svg_parse_number_or_percent (hb_svg_str_t s, bool *is_percent) |
| { |
| if (is_percent) *is_percent = false; |
| s = s.trim (); |
| if (!s.len) return 0.f; |
| if (s.data[s.len - 1] == '%') |
| { |
| if (is_percent) *is_percent = true; |
| hb_svg_str_t n = {s.data, s.len - 1}; |
| return n.to_float () / 100.f; |
| } |
| return s.to_float (); |
| } |
| |
| hb_svg_str_t |
| hb_raster_svg_find_href_attr (const hb_svg_xml_parser_t &parser) |
| { |
| hb_svg_str_t href = parser.find_attr ("href"); |
| if (href.is_null ()) |
| href = parser.find_attr ("xlink:href"); |
| return href; |
| } |
| |
| bool |
| hb_raster_svg_parse_id_ref (hb_svg_str_t s, |
| hb_svg_str_t *out_id, |
| hb_svg_str_t *out_tail) |
| { |
| if (out_id) *out_id = {}; |
| if (out_tail) *out_tail = {}; |
| s = s.trim (); |
| |
| if (s.len && s.data[0] == '#') |
| { |
| hb_svg_str_t id = {s.data + 1, s.len - 1}; |
| id = id.trim (); |
| if (!id.len) |
| return false; |
| if (out_id) *out_id = id; |
| return true; |
| } |
| |
| if (!s.starts_with_ascii_ci ("url(")) |
| return false; |
| |
| const char *p = s.data + 4; |
| const char *end = s.data + s.len; |
| while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++; |
| |
| const char *q = p; |
| char quote = 0; |
| while (q < end) |
| { |
| char c = *q; |
| if (quote) |
| { |
| if (c == quote) quote = 0; |
| } |
| else |
| { |
| if (c == '"' || c == '\'') quote = c; |
| else if (c == ')') break; |
| } |
| q++; |
| } |
| if (q >= end || *q != ')') |
| return false; |
| |
| hb_svg_str_t id = {(const char *) p, (unsigned) (q - p)}; |
| id = id.trim (); |
| if (id.len >= 2 && |
| ((id.data[0] == '\'' && id.data[id.len - 1] == '\'') || |
| (id.data[0] == '"' && id.data[id.len - 1] == '"'))) |
| { |
| id.data++; |
| id.len -= 2; |
| } |
| id = id.trim (); |
| if (id.len && id.data[0] == '#') |
| { |
| id.data++; |
| id.len--; |
| } |
| id = id.trim (); |
| if (!id.len) |
| return false; |
| |
| if (out_id) *out_id = id; |
| if (out_tail) |
| { |
| const char *tail = q + 1; |
| while (tail < end && (*tail == ' ' || *tail == '\t' || *tail == '\n' || *tail == '\r')) tail++; |
| *out_tail = {(const char *) tail, (unsigned) (end - tail)}; |
| } |
| return true; |
| } |
| |
| bool |
| hb_raster_svg_parse_local_id_ref (hb_svg_str_t s, |
| hb_svg_str_t *out_id, |
| hb_svg_str_t *out_tail) |
| { |
| if (out_id) *out_id = {}; |
| if (out_tail) *out_tail = {}; |
| s = s.trim (); |
| |
| if (s.len && s.data[0] == '#') |
| { |
| hb_svg_str_t id = {s.data + 1, s.len - 1}; |
| id = id.trim (); |
| if (!id.len) |
| return false; |
| if (out_id) *out_id = id; |
| return true; |
| } |
| |
| if (!s.starts_with_ascii_ci ("url(")) |
| return false; |
| |
| hb_svg_str_t id; |
| if (!hb_raster_svg_parse_id_ref (s, &id, out_tail)) |
| return false; |
| |
| const char *p = s.data + 4; |
| const char *end = s.data + s.len; |
| while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++; |
| if (p < end && (*p == '\'' || *p == '"')) |
| { |
| p++; |
| while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++; |
| if (p >= end || *p != '#') |
| return false; |
| } |
| else if (p >= end || *p != '#') |
| return false; |
| |
| if (out_id) *out_id = id; |
| return true; |
| } |
| |
| bool |
| hb_raster_svg_find_element_by_id (const char *doc_start, |
| unsigned doc_len, |
| const OT::SVG::accelerator_t *svg_accel, |
| const OT::SVG::svg_doc_cache_t *doc_cache, |
| hb_svg_str_t id, |
| const char **found) |
| { |
| *found = nullptr; |
| if (!doc_start || !doc_len || !id.len) |
| return false; |
| |
| if (doc_cache && svg_accel) |
| { |
| unsigned start = 0, end = 0; |
| OT::SVG::svg_id_span_t key = {id.data, id.len}; |
| if (svg_accel->doc_cache_find_id_span (doc_cache, key, &start, &end)) |
| { |
| if (start < doc_len && end <= doc_len && start < end) |
| { |
| *found = doc_start + start; |
| return true; |
| } |
| } |
| } |
| |
| hb_svg_xml_parser_t search (doc_start, doc_len); |
| while (true) |
| { |
| hb_svg_token_type_t tok = search.next (); |
| if (tok == SVG_TOKEN_EOF) break; |
| if (tok != SVG_TOKEN_OPEN_TAG && tok != SVG_TOKEN_SELF_CLOSE_TAG) continue; |
| hb_svg_str_t attr_id = search.find_attr ("id"); |
| if (attr_id.len == id.len && 0 == memcmp (attr_id.data, id.data, id.len)) |
| { |
| *found = search.tag_start; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool |
| hb_raster_svg_parse_viewbox (hb_svg_str_t viewbox_str, |
| float *x, |
| float *y, |
| float *w, |
| float *h) |
| { |
| if (!viewbox_str.len) |
| return false; |
| hb_svg_float_parser_t vb_fp (viewbox_str); |
| float vb_x = vb_fp.next_float (); |
| float vb_y = vb_fp.next_float (); |
| float vb_w = vb_fp.next_float (); |
| float vb_h = vb_fp.next_float (); |
| if (vb_w <= 0.f || vb_h <= 0.f) |
| return false; |
| if (x) *x = vb_x; |
| if (y) *y = vb_y; |
| if (w) *w = vb_w; |
| if (h) *h = vb_h; |
| return true; |
| } |
| |
| static inline float |
| svg_align_offset (hb_svg_str_t align, |
| float leftover, |
| char axis) |
| { |
| if (leftover <= 0.f) return 0.f; |
| if ((axis == 'x' && align.starts_with_ascii_ci ("xMin")) || |
| (axis == 'y' && (align.eq_ascii_ci ("xMinYMin") || |
| align.eq_ascii_ci ("xMidYMin") || |
| align.eq_ascii_ci ("xMaxYMin")))) |
| return 0.f; |
| if ((axis == 'x' && align.starts_with_ascii_ci ("xMax")) || |
| (axis == 'y' && (align.eq_ascii_ci ("xMinYMax") || |
| align.eq_ascii_ci ("xMidYMax") || |
| align.eq_ascii_ci ("xMaxYMax")))) |
| return leftover; |
| return leftover * 0.5f; |
| } |
| |
| bool |
| hb_raster_svg_compute_viewbox_transform (float viewport_w, |
| float viewport_h, |
| float vb_x, |
| float vb_y, |
| float vb_w, |
| float vb_h, |
| hb_svg_str_t preserve_aspect_ratio, |
| hb_svg_transform_t *out) |
| { |
| if (!(viewport_w > 0.f && viewport_h > 0.f && vb_w > 0.f && vb_h > 0.f)) |
| return false; |
| |
| hb_svg_str_t par = preserve_aspect_ratio.trim (); |
| if (par.starts_with_ascii_ci ("defer")) |
| { |
| const char *p = par.data + 5; |
| const char *end = par.data + par.len; |
| while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++; |
| par = hb_svg_str_t (p, (unsigned) (end - p)); |
| } |
| if (!par.len) |
| par = hb_svg_str_t ("xMidYMid meet", 12); |
| |
| bool is_none = false; |
| bool is_slice = false; |
| hb_svg_str_t align = par; |
| const char *p = par.data; |
| const char *end = par.data + par.len; |
| while (p < end && *p != ' ' && *p != '\t' && *p != '\n' && *p != '\r') p++; |
| align = hb_svg_str_t (par.data, (unsigned) (p - par.data)).trim (); |
| |
| if (par.starts_with_ascii_ci ("none")) |
| is_none = true; |
| else if (align.starts_with_ascii_ci ("x")) |
| { |
| const char *mode = p; |
| while (mode < end && (*mode == ' ' || *mode == '\t' || *mode == '\n' || *mode == '\r')) mode++; |
| if (mode < end && hb_svg_str_t (mode, (unsigned) (end - mode)).starts_with_ascii_ci ("slice")) |
| is_slice = true; |
| } |
| |
| hb_svg_transform_t t; |
| if (is_none) |
| { |
| t.xx = viewport_w / vb_w; |
| t.yy = viewport_h / vb_h; |
| t.dx = -vb_x * t.xx; |
| t.dy = -vb_y * t.yy; |
| *out = t; |
| return true; |
| } |
| |
| float sx = viewport_w / vb_w; |
| float sy = viewport_h / vb_h; |
| float s = is_slice ? hb_max (sx, sy) : hb_min (sx, sy); |
| float scaled_w = vb_w * s; |
| float scaled_h = vb_h * s; |
| float leftover_x = viewport_w - scaled_w; |
| float leftover_y = viewport_h - scaled_h; |
| |
| if (!align.starts_with_ascii_ci ("x")) |
| align = hb_svg_str_t ("xMidYMid", 8); |
| |
| t.xx = s; |
| t.yy = s; |
| t.dx = svg_align_offset (align, leftover_x, 'x') - vb_x * s; |
| t.dy = svg_align_offset (align, leftover_y, 'y') - vb_y * s; |
| *out = t; |
| return true; |
| } |
| |
| bool |
| hb_raster_svg_compute_use_target_viewbox_transform (hb_svg_xml_parser_t &target_parser, |
| float use_w, |
| float use_h, |
| hb_svg_transform_t *out) |
| { |
| if (!(target_parser.tag_name.eq ("svg") || target_parser.tag_name.eq ("symbol"))) |
| return false; |
| |
| float viewport_w = use_w; |
| float viewport_h = use_h; |
| hb_svg_style_props_t target_style_props; |
| svg_parse_style_props (target_parser.find_attr ("style"), &target_style_props); |
| if (viewport_w <= 0.f) |
| viewport_w = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (target_parser, target_style_props.width, "width")); |
| if (viewport_h <= 0.f) |
| viewport_h = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (target_parser, target_style_props.height, "height")); |
| |
| float vb_x = 0.f, vb_y = 0.f, vb_w = 0.f, vb_h = 0.f; |
| if (!hb_raster_svg_parse_viewbox (target_parser.find_attr ("viewBox"), &vb_x, &vb_y, &vb_w, &vb_h)) |
| return false; |
| |
| if (!(viewport_w > 0.f && viewport_h > 0.f)) |
| { |
| viewport_w = vb_w; |
| viewport_h = vb_h; |
| } |
| |
| return hb_raster_svg_compute_viewbox_transform (viewport_w, viewport_h, vb_x, vb_y, vb_w, vb_h, |
| target_parser.find_attr ("preserveAspectRatio"), |
| out); |
| } |
| |
| void |
| hb_raster_svg_parse_use_geometry (hb_svg_xml_parser_t &parser, |
| float *x, |
| float *y, |
| float *w, |
| float *h) |
| { |
| hb_svg_style_props_t style_props; |
| svg_parse_style_props (parser.find_attr ("style"), &style_props); |
| |
| if (x) *x = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, style_props.x, "x")); |
| if (y) *y = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, style_props.y, "y")); |
| if (w) *w = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, style_props.width, "width")); |
| if (h) *h = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, style_props.height, "height")); |
| } |
| |
| float |
| hb_raster_svg_parse_non_percent_length (hb_svg_str_t s) |
| { |
| bool is_percent = false; |
| float v = svg_parse_number_or_percent (s, &is_percent); |
| return is_percent ? 0.f : v; |
| } |
| |
| #endif /* !HB_NO_RASTER_SVG */ |
