| /* |
| * 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-gradient.hh" |
| |
| #include "hb-raster-svg-base.hh" |
| |
| static bool |
| svg_parse_gradient_stop (hb_svg_xml_parser_t &parser, |
| hb_svg_gradient_t &grad, |
| hb_paint_funcs_t *pfuncs, |
| void *paint_data, |
| hb_color_t foreground, |
| hb_face_t *face, |
| unsigned palette) |
| { |
| const unsigned SVG_MAX_GRADIENT_STOPS = 1024; |
| if (grad.stops.length >= SVG_MAX_GRADIENT_STOPS) |
| return true; |
| |
| hb_svg_attr_view_t attrs (parser); |
| hb_svg_str_t style = attrs.get ("style"); |
| hb_svg_style_props_t style_props; |
| svg_parse_style_props (style, &style_props); |
| hb_svg_str_t offset_str = svg_pick_attr_or_style (parser, style_props.offset, "offset"); |
| hb_svg_str_t color_str = svg_pick_attr_or_style (parser, style_props.stop_color, "stop-color"); |
| hb_svg_str_t opacity_str = svg_pick_attr_or_style (parser, style_props.stop_opacity, "stop-opacity"); |
| hb_svg_str_t display_str = svg_pick_attr_or_style (parser, style_props.display, "display"); |
| hb_svg_str_t visibility_str = svg_pick_attr_or_style (parser, style_props.visibility, "visibility"); |
| |
| if (display_str.trim ().eq_ascii_ci ("none")) |
| return true; |
| hb_svg_str_t visibility_trim = visibility_str.trim (); |
| if (visibility_trim.eq_ascii_ci ("hidden") || |
| visibility_trim.eq_ascii_ci ("collapse")) |
| return true; |
| |
| float offset = 0; |
| if (offset_str.len) |
| offset = hb_clamp (svg_parse_number_or_percent (offset_str, nullptr), 0.f, 1.f); |
| if (grad.stops.length) |
| offset = hb_max (offset, grad.stops.arrayZ[grad.stops.length - 1].offset); |
| |
| bool is_none = false; |
| hb_color_t color = HB_COLOR (0, 0, 0, 255); |
| bool is_current_color = false; |
| if (color_str.len && !svg_str_is_inherit (color_str)) |
| { |
| is_current_color = color_str.trim ().eq_ascii_ci ("currentColor"); |
| color = hb_raster_svg_parse_color (color_str, pfuncs, paint_data, foreground, face, palette, &is_none); |
| } |
| |
| if (opacity_str.len && !svg_str_is_inherit (opacity_str)) |
| { |
| float opacity = svg_parse_float_clamped01 (opacity_str); |
| color = HB_COLOR (hb_color_get_blue (color), |
| hb_color_get_green (color), |
| hb_color_get_red (color), |
| (uint8_t) (hb_color_get_alpha (color) * opacity + 0.5f)); |
| } |
| |
| hb_svg_gradient_stop_t stop; |
| stop.offset = offset; |
| stop.color = color; |
| stop.is_current_color = is_current_color; |
| return grad.stops.push_or_fail (stop); |
| } |
| |
| static void |
| svg_parse_gradient_attrs (hb_svg_xml_parser_t &parser, |
| hb_svg_gradient_t &grad) |
| { |
| hb_svg_style_props_t style_props; |
| svg_parse_style_props (parser.find_attr ("style"), &style_props); |
| |
| hb_svg_str_t spread_str = svg_pick_attr_or_style (parser, style_props.spread_method, "spreadMethod").trim (); |
| if (spread_str.eq_ascii_ci ("reflect")) |
| { |
| grad.spread = HB_PAINT_EXTEND_REFLECT; |
| grad.has_spread = true; |
| } |
| else if (spread_str.eq_ascii_ci ("repeat")) |
| { |
| grad.spread = HB_PAINT_EXTEND_REPEAT; |
| grad.has_spread = true; |
| } |
| else if (spread_str.eq_ascii_ci ("pad")) |
| { |
| grad.spread = HB_PAINT_EXTEND_PAD; |
| grad.has_spread = true; |
| } |
| |
| hb_svg_str_t units_str = svg_pick_attr_or_style (parser, style_props.gradient_units, "gradientUnits").trim (); |
| if (units_str.eq_ascii_ci ("userSpaceOnUse")) |
| { |
| grad.units_user_space = true; |
| grad.has_units_user_space = true; |
| } |
| else if (units_str.eq_ascii_ci ("objectBoundingBox")) |
| { |
| grad.units_user_space = false; |
| grad.has_units_user_space = true; |
| } |
| |
| hb_svg_str_t transform_str = svg_pick_attr_or_style (parser, style_props.gradient_transform, "gradientTransform"); |
| if (transform_str.len) |
| { |
| grad.has_gradient_transform = true; |
| hb_raster_svg_parse_transform (transform_str, &grad.gradient_transform); |
| } |
| |
| hb_svg_str_t href = hb_raster_svg_find_href_attr (parser); |
| if (href.len) |
| { |
| hb_svg_str_t href_id; |
| if (hb_raster_svg_parse_local_id_ref (href, &href_id, nullptr)) |
| grad.href_id = hb_bytes_t (href_id.data, href_id.len); |
| } |
| } |
| |
| static void |
| svg_parse_gradient_geometry_attrs (hb_svg_xml_parser_t &parser, |
| hb_svg_gradient_t &grad) |
| { |
| hb_svg_style_props_t style_props; |
| svg_parse_style_props (parser.find_attr ("style"), &style_props); |
| if (grad.type == SVG_GRADIENT_LINEAR) |
| { |
| hb_svg_str_t x1_str = svg_pick_attr_or_style (parser, style_props.x1, "x1"); |
| hb_svg_str_t y1_str = svg_pick_attr_or_style (parser, style_props.y1, "y1"); |
| hb_svg_str_t x2_str = svg_pick_attr_or_style (parser, style_props.x2, "x2"); |
| hb_svg_str_t y2_str = svg_pick_attr_or_style (parser, style_props.y2, "y2"); |
| if (x1_str.len) { grad.x1 = svg_parse_number_or_percent (x1_str, nullptr); grad.has_x1 = true; } |
| if (y1_str.len) { grad.y1 = svg_parse_number_or_percent (y1_str, nullptr); grad.has_y1 = true; } |
| if (x2_str.len) { grad.x2 = svg_parse_number_or_percent (x2_str, nullptr); grad.has_x2 = true; } |
| if (y2_str.len) { grad.y2 = svg_parse_number_or_percent (y2_str, nullptr); grad.has_y2 = true; } |
| |
| if (!grad.has_x2) |
| grad.x2 = 1.f; |
| } |
| else |
| { |
| hb_svg_str_t cx_str = svg_pick_attr_or_style (parser, style_props.cx, "cx"); |
| hb_svg_str_t cy_str = svg_pick_attr_or_style (parser, style_props.cy, "cy"); |
| hb_svg_str_t r_str = svg_pick_attr_or_style (parser, style_props.r, "r"); |
| hb_svg_str_t fx_str = svg_pick_attr_or_style (parser, style_props.fx, "fx"); |
| hb_svg_str_t fy_str = svg_pick_attr_or_style (parser, style_props.fy, "fy"); |
| hb_svg_str_t fr_str = svg_pick_attr_or_style (parser, style_props.fr, "fr"); |
| |
| if (cx_str.len) { grad.cx = svg_parse_number_or_percent (cx_str, nullptr); grad.has_cx = true; } |
| if (cy_str.len) { grad.cy = svg_parse_number_or_percent (cy_str, nullptr); grad.has_cy = true; } |
| if (r_str.len) { grad.r = svg_parse_number_or_percent (r_str, nullptr); grad.has_r = true; } |
| if (fx_str.len) { grad.fx = svg_parse_number_or_percent (fx_str, nullptr); grad.has_fx = true; } |
| if (fy_str.len) { grad.fy = svg_parse_number_or_percent (fy_str, nullptr); grad.has_fy = true; } |
| if (fr_str.len) { grad.fr = svg_parse_number_or_percent (fr_str, nullptr); grad.has_fr = true; } |
| } |
| } |
| |
| static void |
| svg_parse_gradient_children (hb_svg_defs_t *defs, |
| hb_svg_xml_parser_t &parser, |
| hb_svg_gradient_t &grad, |
| hb_svg_str_t *id, |
| hb_paint_funcs_t *pfuncs, |
| void *paint_data, |
| hb_color_t foreground, |
| hb_face_t *face, |
| unsigned palette) |
| { |
| int gdepth = 1; |
| bool had_alloc_failure = false; |
| while (gdepth > 0) |
| { |
| hb_svg_token_type_t gt = parser.next (); |
| if (gt == SVG_TOKEN_EOF) break; |
| if (gt == SVG_TOKEN_CLOSE_TAG) { gdepth--; continue; } |
| if ((gt == SVG_TOKEN_OPEN_TAG || gt == SVG_TOKEN_SELF_CLOSE_TAG) && |
| parser.tag_name.eq ("stop")) |
| if (unlikely (!svg_parse_gradient_stop (parser, grad, |
| pfuncs, paint_data, |
| foreground, face, |
| palette))) |
| had_alloc_failure = true; |
| if (gt == SVG_TOKEN_OPEN_TAG && !parser.tag_name.eq ("stop")) |
| gdepth++; |
| } |
| if (had_alloc_failure || defs->gradients.in_error ()) |
| *id = {}; |
| } |
| |
| void |
| hb_raster_svg_process_gradient_def (hb_svg_defs_t *defs, |
| hb_svg_xml_parser_t &parser, |
| hb_svg_token_type_t tok, |
| hb_svg_gradient_type_t type, |
| hb_paint_funcs_t *pfuncs, |
| void *paint_data, |
| hb_color_t foreground, |
| hb_face_t *face, |
| unsigned palette) |
| { |
| hb_svg_gradient_t grad; |
| grad.type = type; |
| svg_parse_gradient_geometry_attrs (parser, grad); |
| svg_parse_gradient_attrs (parser, grad); |
| |
| hb_svg_str_t id = parser.find_attr ("id"); |
| if (tok == SVG_TOKEN_OPEN_TAG) |
| svg_parse_gradient_children (defs, parser, grad, &id, |
| pfuncs, paint_data, |
| foreground, face, |
| palette); |
| |
| if (id.len) |
| (void) defs->add_gradient (hb_bytes_t (id.data, id.len), grad); |
| } |
| |
| #endif /* !HB_NO_RASTER_SVG */ |
