mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-19 14:01:10 +01:00
1071 lines
31 KiB
C++
1071 lines
31 KiB
C++
/*
|
|
* 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
|