if (!hatch_color) {

hatch_color = to_rgba(rc_param("hatch.color"));

}

return *hatch_color;

if (!hatch_linewidth) {

hatch_linewidth = rc_param("hatch.linewidth").cast<double>();

}

return *hatch_linewidth;

{

return py::dict(

"cairo_circles"_a=bool(detail::UNIT_CIRCLE),

"collection_threads"_a=detail::COLLECTION_THREADS,

"image_format"_a=detail::IMAGE_FORMAT,

"miter_limit"_a=detail::MITER_LIMIT,

"raqm"_a=has_raqm(),

"_debug"_a=detail::DEBUG);

{

auto estack = py::module::import("contextlib").attr("ExitStack")();

estack.attr("callback")(py::cpp_function{set_options}, **get_options());

auto const& pop_option =

[&](std::string key, auto dummy) -> std::optional<decltype(dummy)> {

return

kwargs.attr("pop")(key, py::none())

.cast<std::optional<decltype(dummy)>>();

};

if (auto const& cairo_circles = pop_option("cairo_circles", bool{})) {

if (*cairo_circles) {

detail::UNIT_CIRCLE =

py::module::import("matplotlib.path").attr("Path")

.attr("unit_circle")();

} else {

Py_XDECREF(detail::UNIT_CIRCLE.release().ptr());

}

}

if (auto const& image_format =

pop_option("image_format",

std::variant<cairo_format_t, std::string>{})) {

auto fmt = std::visit(overloaded {

[](cairo_format_t fmt) {

return fmt;

},

[](std::string fmt) { // operator[]() doesn't support std::string

return

py::module::import("mplcairo").attr("format_t")[fmt.c_str()]

.cast<cairo_format_t>();

}

}, *image_format);

if (fmt > CAIRO_FORMAT_RGB30

&& cairo_version() < CAIRO_VERSION_ENCODE(1, 17, 2)) {

throw std::invalid_argument{"float surfaces require cairo>=1.17.2"};

}

detail::IMAGE_FORMAT = fmt;

}

if (auto const& threads = pop_option("collection_threads", int{})) {

detail::COLLECTION_THREADS = *threads;

}

if (auto const& miter_limit = pop_option("miter_limit", double{})) {

detail::MITER_LIMIT = *miter_limit;

}

if (auto const& raqm = pop_option("raqm", bool{})) {

if (*raqm) {

load_raqm();

} else {

unload_raqm();

}

}

if (auto const& debug = pop_option("_debug", bool{})) {

detail::DEBUG = *debug;

}

if (py::bool_(kwargs)) {

throw std::runtime_error{

"unknown options passed to set_options: {}"_format(kwargs)

.cast<std::string>()};

}

return estack;

{

return py::reinterpret_borrow<py::object>( // Use a faster path.

PyDict_GetItemString(detail::RC_PARAMS.ptr(), key.data()));

{

return

py::module::import("matplotlib.colors")

.attr("to_rgba")(color, alpha).cast<rgba_t>();

{

if (!py::bool_(py::getattr(transform, "is_affine", py::bool_(true)))) {

throw std::invalid_argument{"only affine transforms are handled"};

}

auto const& py_matrix = transform.cast<py::array_t<double>>().unchecked<2>();

if (py_matrix.shape(0) != 3 || py_matrix.shape(1) != 3) {

throw std::invalid_argument{

"transformation matrix must have shape (3, 3), "

"not {.shape}"_format(transform).cast<std::string>()};

}

return cairo_matrix_t{

py_matrix(0, 0), -py_matrix(1, 0),

py_matrix(0, 1), -py_matrix(1, 1),

py_matrix(0, 2), y0 - py_matrix(1, 2)};

py::object transform, cairo_matrix_t const* master_matrix)

{

if (!py::bool_(py::getattr(transform, "is_affine", py::bool_(true)))) {

throw std::invalid_argument{"only affine transforms are handled"};

}

auto const& py_matrix = transform.cast<py::array_t<double>>().unchecked<2>();

if (py_matrix.shape(0) != 3 || py_matrix.shape(1) != 3) {

throw std::invalid_argument{

"transformation matrix must have shape (3, 3), "

"not {.shape}"_format(transform).cast<std::string>()};

}

// The y flip is already handled by the master matrix.

auto mtx = cairo_matrix_t{

py_matrix(0, 0), py_matrix(1, 0),

py_matrix(0, 1), py_matrix(1, 1),

py_matrix(0, 2), py_matrix(1, 2)};

cairo_matrix_multiply(&mtx, &mtx, master_matrix);

return mtx;

{

switch (auto const& type = cairo_surface_get_type(cairo_get_target(cr))) {

case CAIRO_SURFACE_TYPE_IMAGE:

case CAIRO_SURFACE_TYPE_XLIB:

return false;

case CAIRO_SURFACE_TYPE_PDF:

case CAIRO_SURFACE_TYPE_PS:

case CAIRO_SURFACE_TYPE_SVG:

case CAIRO_SURFACE_TYPE_RECORDING:

return true;

case CAIRO_SURFACE_TYPE_SCRIPT:

switch (detail::MPLCAIRO_SCRIPT_SURFACE) {

case detail::MplcairoScriptSurface::Raster:

return false;

case detail::MplcairoScriptSurface::Vector:

return true;

default: ;

}

default:

throw std::invalid_argument{

"unexpected surface type: " + std::to_string(type)};

}

{

auto const mtx = static_cast<cairo_matrix_t*>(

cairo_get_user_data(cr, &detail::INIT_MATRIX_KEY));

if (!mtx) {

cairo_identity_matrix(cr);

} else {

cairo_set_matrix(cr, mtx);

}

cairo_t* const cr;

cairo_matrix_t ctm;

bool const snap;

double (*snapper)(double);

public:

LoadPathContext(cairo_t* cr) :

cr{cr},

snap{!has_vector_surface(cr) && get_additional_state(cr).snap}

{

cairo_get_matrix(cr, &ctm);

restore_init_matrix(cr);

cairo_new_path(cr);

auto const& lw = cairo_get_line_width(cr);

snapper =

snap

? (0 < lw && (lw < 1 || std::lround(lw) % 2 == 1)

// MSVC doesn't support lambdas in ternary branches.

? static_cast<decltype(snapper)>(

[](double x) -> double { return std::floor(x) + .5; })

: static_cast<decltype(snapper)>(&std::round))

// Snap between pixels if lw is exactly zero 0 (in which case the edge is

// defined by the fill) or if lw rounds to an even value other than 0

// (minimizing the alpha due to antialiasing).

: static_cast<decltype(snapper)>([](double x) -> double { return x; });

}

~LoadPathContext()

{

cairo_set_matrix(cr, &ctm);

}

cairo_t* cr, py::handle path, cairo_matrix_t const* matrix)

{

[[maybe_unused]] auto const& gil = py::gil_scoped_acquire{};

auto const& min = double(-(1 << 22)), max = double(1 << 22);

auto const& lpc = LoadPathContext{cr};

auto const& vertices_keepref =

path.attr("vertices").cast<py::array_t<double>>();

auto const& codes_keepref =

path.attr("codes").cast<std::optional<py::array_t<uint8_t>>>();

auto const& n = vertices_keepref.shape(0);

if (vertices_keepref.shape(1) != 2) {

throw std::invalid_argument{

"vertices must have shape (n, 2), not {.shape}"_format(

path.attr("vertices")).cast<std::string>()};

}

if (!codes_keepref) {

load_path_exact(cr, vertices_keepref, 0, n, matrix);

return;

}

auto const& vertices = vertices_keepref.unchecked<2>();

auto const& codes = codes_keepref->unchecked<1>();

if (codes.shape(0) != n) {

throw std::invalid_argument{

"lengths of vertices ({}) and codes ({}) are mistached "_format(

n, codes.shape(0)).cast<std::string>()};

}

auto force_snap_next_lineto = bool{};

auto const& snapper = lpc.snapper;

// Main loop.

for (auto i = 0; i < n; ++i) {

auto x0 = vertices(i, 0), y0 = vertices(i, 1);

cairo_matrix_transform_point(matrix, &x0, &y0);

auto const& is_finite = std::isfinite(x0) && std::isfinite(y0);

// Better(?) than nothing.

x0 = std::clamp(x0, min, max);

y0 = std::clamp(y0, min, max);

switch (static_cast<PathCode>(codes(i))) {

case PathCode::STOP:

break;

case PathCode::MOVETO:

if (is_finite) {

// See comments re: snapping in the codeless path.

if (lpc.snap && i + 1 < n

&& static_cast<PathCode>(codes(i + 1)) == PathCode::LINETO) {

auto x1 = vertices(i + 1, 0), y1 = vertices(i + 1, 1);

cairo_matrix_transform_point(matrix, &x1, &y1);

if (x1 == x0 || y1 == y0) {

x0 = snapper(x0);

y0 = snapper(y0);

force_snap_next_lineto = true;

}

}

cairo_move_to(cr, x0, y0);

} else {

cairo_new_sub_path(cr);

}

break;

case PathCode::LINETO:

if (is_finite) {

auto x00 = x0, y00 = y0;

if (force_snap_next_lineto) {

x0 = snapper(x0);

y0 = snapper(y0);

}

force_snap_next_lineto = false;

if (lpc.snap && i + 1 < n

&& static_cast<PathCode>(codes(i + 1)) == PathCode::LINETO) {

auto x1 = vertices(i + 1, 0), y1 = vertices(i + 1, 1);

cairo_matrix_transform_point(matrix, &x1, &y1);

if (x1 == x00 || y1 == y00) {

x0 = snapper(x0);

y0 = snapper(y0);

force_snap_next_lineto = true;

}

}

cairo_line_to(cr, x0, y0);

} else {

cairo_new_sub_path(cr);

}

break;

// The semantics of nonfinite control points are tested in

// :mpltest:`test_simplification.test_simplify_curve`: if the last point

// is finite, it sets the current point for the next curve; otherwise, a

// new sub-path is created.

case PathCode::CURVE3: {

auto x1 = vertices(i + 1, 0), y1 = vertices(i + 1, 1);

cairo_matrix_transform_point(matrix, &x1, &y1);

i += 1;

auto const& last_finite = std::isfinite(x1) && std::isfinite(y1);

if (last_finite) {

auto const& x10 = x1, y10 = y1;

x1 = std::clamp(x1, min, max);

y1 = std::clamp(y1, min, max);

if (lpc.snap && i + 1 < n

&& static_cast<PathCode>(codes(i + 1)) == PathCode::LINETO) {

auto x2 = vertices(i + 1, 0), y2 = vertices(i + 1, 1);

cairo_matrix_transform_point(matrix, &x2, &y2);

if (x2 == x10 || y2 == y10) {

x1 = snapper(x1);

y1 = snapper(y1);

force_snap_next_lineto = true;

}

}

if (is_finite && cairo_has_current_point(cr)) {

double x_prev, y_prev;

cairo_get_current_point(cr, &x_prev, &y_prev);

cairo_curve_to(cr,

(x_prev + 2 * x0) / 3, (y_prev + 2 * y0) / 3,

(2 * x0 + x1) / 3, (2 * y0 + y1) / 3,

x1, y1);

} else {

cairo_move_to(cr, x1, y1);

}

} else {

cairo_new_sub_path(cr);

}

break;

}

case PathCode::CURVE4: {

auto x1 = vertices(i + 1, 0), y1 = vertices(i + 1, 1),

x2 = vertices(i + 2, 0), y2 = vertices(i + 2, 1);

cairo_matrix_transform_point(matrix, &x1, &y1);

cairo_matrix_transform_point(matrix, &x2, &y2);

i += 2;

auto const& last_finite = std::isfinite(x2) && std::isfinite(y2);

if (last_finite) {

auto const& x20 = x2, y20 = y2;

x1 = std::clamp(x1, min, max);

y1 = std::clamp(y1, min, max);

x2 = std::clamp(x2, min, max);

y2 = std::clamp(y2, min, max);

if (lpc.snap && i + 1 < n

&& static_cast<PathCode>(codes(i + 1)) == PathCode::LINETO) {

auto x3 = vertices(i + 1, 0), y3 = vertices(i + 1, 1);

cairo_matrix_transform_point(matrix, &x3, &y3);

if (x3 == x20 || y3 == y20) {

x2 = snapper(x2);

y2 = snapper(y2);

force_snap_next_lineto = true;

}

}

if (is_finite && std::isfinite(x1) && std::isfinite(y1)

&& cairo_has_current_point(cr)) {

cairo_curve_to(cr, x0, y0, x1, y1, x2, y2);

} else {

cairo_move_to(cr, x2, y2);

}

} else {

cairo_new_sub_path(cr);

}

break;

}

case PathCode::CLOSEPOLY:

cairo_close_path(cr);

break;

}

}

cairo_t* cr, py::array_t<double> vertices_keepref,

ssize_t start, ssize_t stop, cairo_matrix_t const* matrix)

{

[[maybe_unused]] auto const& gil = py::gil_scoped_acquire{};

auto const min = double(-(1 << 22)), max = double(1 << 22);

auto const& lpc = LoadPathContext{cr};

auto const& vertices = vertices_keepref.unchecked<2>();

auto const& n = vertices.shape(0);

if (!(0 <= start && start <= stop && stop <= n)) {

throw std::invalid_argument{

"invalid sub-path bounds ({}, {}) for path of size {}"_format(

start, stop, n).cast<std::string>()};

}

auto const& snapper = lpc.snapper;

auto path_data = std::vector<cairo_path_data_t>{};

path_data.reserve(2 * (stop - start));

auto const LEFT = 1 << 0, RIGHT = 1 << 1, BOTTOM = 1 << 2, TOP = 1 << 3;

auto const& outcode = [&](double x, double y) -> int {

auto code = 0;

if (x < min) {

code |= LEFT;

} else if (x > max) {

code |= RIGHT;

}

if (y < min) {

code |= BOTTOM;

} else if (y > max) {

code |= TOP;

}

return code;

};

// The previous point, if any, before clipping and snapping.

auto prev = std::optional<std::tuple<double, double>>{};

// Main loop.

for (auto i = start; i < stop; ++i) {

auto x = vertices(i, 0), y = vertices(i, 1);

cairo_matrix_transform_point(matrix, &x, &y);

if (std::isfinite(x) && std::isfinite(y)) {

cairo_path_data_t header, point;

if (prev) {

header.header = {CAIRO_PATH_LINE_TO, 2};

auto [x_prev, y_prev] = *prev;

prev = {x, y};

// Cohen-Sutherland clipping: we expect most segments to be within

// the 1 << 22 by 1 << 22 box.

auto code0 = outcode(x_prev, y_prev);

auto code1 = outcode(x, y);

auto accept = false, update_prev = false;

while (true) {

if (!(code0 | code1)) {

accept = true;

break;

} else if (code0 & code1) {

break;

} else {

auto xc = 0., yc = 0.;

auto code = code0 ? code0 : code1;

if (code & TOP) {

xc = x_prev + (x - x_prev) * (max - y_prev) / (y - y_prev);

yc = max;

} else if (code & BOTTOM) {

xc = x_prev + (x - x_prev) * (min - y_prev) / (y - y_prev);

yc = min;

} else if (code & RIGHT) {

yc = y_prev + (y - y_prev) * (max - x_prev) / (x - x_prev);

xc = max;

} else if (code & LEFT) {

yc = y_prev + (y - y_prev) * (min - x_prev) / (x - x_prev);

xc = min;

}

if (code == code0) {

update_prev = true;

x_prev = xc;

y_prev = yc;

code0 = outcode(x_prev, y_prev);

} else {

x = xc;

y = yc;

code1 = outcode(x, y);

}

}

}

if (accept) {

// If we accept the segment, but the previous point moved, record

// a MOVE_TO the new previous point (which will be followed by a

// LINE_TO the current point).

if (update_prev) {

cairo_path_data_t header_prev, point_prev;

header_prev.header = {CAIRO_PATH_MOVE_TO, 2};

point_prev.point = {x_prev, y_prev};

path_data.push_back(header_prev);

path_data.push_back(point_prev);

}

} else {

// If we don't accept the segment, still record a MOVE_TO the raw

// destination, as the next point may involve snapping.

header.header = {CAIRO_PATH_MOVE_TO, 2};

}

// Snapping.

if (lpc.snap && (x == x_prev || y == y_prev)) {

// If we have a horizontal or a vertical line, snap both coordinates.

// While it may make sense to only snap in the direction orthogonal

// to the displacement, this would cause e.g. axes spines to not line

// up properly, as they are drawn as independent segments.

path_data.back().point = {snapper(x_prev), snapper(y_prev)};

point.point = {snapper(x), snapper(y)};

} else {

point.point = {x, y};

}

// Record the point.

path_data.push_back(header);

path_data.push_back(point);

} else {

prev = {x, y};

header.header = {CAIRO_PATH_MOVE_TO, 2};

point.point = {x, y};

path_data.push_back(header);

path_data.push_back(point);

}

} else {

prev = {};

}

}

auto const& path =

cairo_path_t{

CAIRO_STATUS_SUCCESS, path_data.data(), int(path_data.size())};

cairo_append_path(cr, &path);

cairo_t* cr, py::handle path, cairo_matrix_t const* matrix,

std::optional<rgba_t> fill, std::optional<rgba_t> stroke)

{

cairo_save(cr);

auto path_loaded = false;

if (fill) {

auto const& [r, g, b, a] = *fill;

cairo_set_source_rgba(cr, r, g, b, a);

if (path.is(detail::UNIT_CIRCLE) && !has_vector_surface(cr)) {

// Abuse the degenerate-segment handling by cairo to rasterize

// circles efficiently. Don't do this on vector backends both

// because the user may technically want the actual path, and because

// Inkscape does not render circle markers on zero-sized paths

// (FIXME[inkscape] https://bugs.launchpad.net/inkscape/+bug/689562).

cairo_save(cr);

cairo_new_path(cr);

cairo_move_to(cr, matrix->x0, matrix->y0);

cairo_close_path(cr);

cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);

cairo_set_line_width(cr, 2);

cairo_set_matrix(cr, matrix);

cairo_stroke(cr);

cairo_restore(cr);

} else {

if (!path_loaded) {

load_path_exact(cr, path, matrix);

path_loaded = true;

}

cairo_fill_preserve(cr);

}

}

if (stroke) {

auto const& [r, g, b, a] = *stroke;

cairo_set_source_rgba(cr, r, g, b, a);

if (!path_loaded) {

load_path_exact(cr, path, matrix);

path_loaded = true;

}

restore_init_matrix(cr); // Dashes are interpreted using the CTM.

cairo_stroke_preserve(cr);

}

cairo_restore(cr);

// Possible outputs:

// ARGB32 -> uint8, (h, w, 4)

// RGB24 -> uint8, (h, w, 3) (non-contiguous)

// A8 -> uint8, (h, w)

// A1 -> ("V{w}", void(ceil(w/8))), (h,)

// RGB16_565 -> uint16, (h, w)

// RGB30 -> uint32, (h, w)

// RGB96F -> float, (h, w, 3)

// RGB128F -> float, (h, w, 4)

if (auto const& type = cairo_surface_get_type(surface);

type != CAIRO_SURFACE_TYPE_IMAGE) {

throw std::runtime_error{

"_get_buffer only supports image surfaces, not {}"_format(type)

.cast<std::string>()};

}

cairo_surface_reference(surface);

cairo_surface_flush(surface);

auto const& h = cairo_image_surface_get_height(surface),

& w = cairo_image_surface_get_width(surface),

& stride = cairo_image_surface_get_stride(surface);

auto const& data = cairo_image_surface_get_data(surface);

auto const& capsule = py::capsule(

surface,

[](void* surface) -> void {

cairo_surface_destroy(static_cast<cairo_surface_t*>(surface));

});

switch (auto const& fmt = cairo_image_surface_get_format(surface);

// Avoid "not in enumerated type" warning with CAIRO_FORMAT_RGBA_128F.

static_cast<int>(fmt)) {

case static_cast<int>(CAIRO_FORMAT_ARGB32):

return py::array_t<uint8_t>{{h, w, 4}, {stride, 4, 1}, data, capsule};

case static_cast<int>(CAIRO_FORMAT_RGB24):

return py::array_t<uint8_t>{{h, w, 3}, {stride, 4, 1}, data, capsule};

case static_cast<int>(CAIRO_FORMAT_A8):

return py::array_t<uint8_t>{{h, w}, {stride, 1}, data, capsule};

case static_cast<int>(CAIRO_FORMAT_A1): {

auto dtype_args = py::list{};

dtype_args.append(py::make_tuple(

"V" + std::to_string(w), "V" + std::to_string((w + 7) / 8)));

return py::array{

py::dtype::from_args(dtype_args), {h}, {stride}, data, capsule};

}

case static_cast<int>(CAIRO_FORMAT_RGB16_565):

return py::array_t<uint16_t>{

{h, w}, {stride, 2}, reinterpret_cast<uint16_t*>(data), capsule};

case static_cast<int>(CAIRO_FORMAT_RGB30):

return py::array_t<uint32_t>{

{h, w}, {stride, 4}, reinterpret_cast<uint32_t*>(data), capsule};

case 6: // CAIRO_FORMAT_RGB96F.

return py::array_t<float>{

{h, w, 3}, {stride, 12, 4}, reinterpret_cast<float*>(data), capsule};

case 7: // CAIRO_FORMAT_RGBA128F.

return py::array_t<float>{

{h, w, 4}, {stride, 16, 4}, reinterpret_cast<float*>(data), capsule};

default:

throw std::invalid_argument{

"_get_buffer does not support image surfaces with format "

"{}"_format(fmt).cast<std::string>()};

}

{

struct parse_t {

std::string path;

int face_index;

std::vector<std::string> features;

std::vector<std::tuple<std::string, int, int>> langs;

std::string variations;

};

auto match = std::smatch{};

if (!std::regex_match(pathspec, match,

std::regex{"(.*?)(#(\\d+))?(\\|([^|]*))?(\\|(.*))?"})) {

throw std::runtime_error{

"Failed to parse pathspec {}"_format(pathspec).cast<std::string>()};

}

auto parse = parse_t{

match.str(1),

std::atoi(match.str(3).c_str()), // 0 if absent.

{}, {}, // Fill below.

match.str(7)

};

auto const& features_s = match.str(5);

if (features_s.size()) {

auto const& comma = std::regex{","};

auto toks = std::sregex_token_iterator{

features_s.begin(), features_s.end(), comma, -1};

while (toks != std::sregex_token_iterator{}) {

auto const& tok = std::string{toks->str()};

if (std::regex_match(

tok,

match,

std::regex{"^language(?:\\[(\\d+)?(?::(\\d+))?\\])?=(.*)$"})) {

auto const& start = std::atoi(match.str(1).c_str()); // 0 if absent.

auto const& stop =

match[2].matched ? std::atoi(match.str(2).c_str()) : -1;

auto const& lang = match.str(3);

parse.langs.emplace_back(lang, start, stop);

} else {

parse.features.emplace_back(tok);

}

++toks;

}

}

return parse;

{

// It is probably not worth implementing an additional layer of caching here

// as findfont already has its cache and object equality needs would also

// need to go through Python anyways.

auto const& fm =

py::module::import("matplotlib.font_manager").attr("fontManager");

if (py::hasattr(fm, "_find_fonts_by_props")) {

auto const& paths =

fm.attr("_find_fonts_by_props")(prop).cast<std::vector<std::string>>();

auto fonts = std::vector<cairo_font_face_t*>{};

for (auto const& path: paths) {

fonts.push_back(font_face_from_path(path));

}

return fonts;

} else {

auto const& path = fm.attr("findfont")(prop);

return {font_face_from_path(path)};

}

{

// FIXME[matplotlib]: Should be moved out of backend_agg.

auto const& hf =

py::module::import("matplotlib.backends.backend_agg")

.attr("get_hinting_flag")();

// Matplotlib 3.10 changed the flag from int to enum.Flag.

return (py::hasattr(hf, "value") ? hf.attr("value") : hf).cast<long>();

{

auto const& font_face = cairo_get_font_face(cr);

auto const& options = cairo_font_options_create();

if (cairo_version() >= CAIRO_VERSION_ENCODE(1, 18, 0)

// cairo#404 (<1.18.0): Don't set antialiasing for color fonts.

|| !cairo_font_face_get_user_data(font_face, &detail::IS_COLOR_FONT_KEY)) {

auto aa = rc_param("text.antialiased"); // Normally *exactly* a bool.

cairo_font_options_set_antialias(

options,

aa.ptr() == Py_True

? (subpixel_antialiased_text_allowed

? CAIRO_ANTIALIAS_SUBPIXEL : CAIRO_ANTIALIAS_GRAY)

: aa.ptr() == Py_False ? CAIRO_ANTIALIAS_NONE

: aa.cast<cairo_antialias_t>());

}

auto const& variations = *static_cast<std::string*>(

cairo_font_face_get_user_data(font_face, &detail::VARIATIONS_KEY));

if (!variations.empty()) {

if (detail::cairo_font_options_set_variations) {

detail::cairo_font_options_set_variations(options, variations.c_str());

} else {

py::module::import("warnings").attr("warn")(

"cairo_font_options_set_variations requires cairo>=1.16.0");

}

}

// The hint style is not set here: it is passed directly as load_flags to

// cairo_ft_font_face_create_for_ft_face.

cairo_set_font_options(cr, options);

cairo_font_options_destroy(options);

{

PY_CHECK(

PyErr_WarnEx,

PyExc_UserWarning,

"Glyph {} missing from current font."_format(s)

.cast<std::string>().c_str(),

1);

{

auto const& scaled_font = cairo_get_scaled_font(cr);

auto gac = GlyphsAndClusters{};

if (has_raqm()) {

auto const& ft_face = cairo_ft_scaled_font_lock_face(scaled_font);

[[maybe_unused]] auto const& scaled_font_unlock_cleanup =

std::unique_ptr<

std::remove_pointer_t<cairo_scaled_font_t>,

decltype(&cairo_ft_scaled_font_unlock_face)>{

scaled_font, cairo_ft_scaled_font_unlock_face};

auto const& rq = raqm::create();

[[maybe_unused]] auto const& rq_cleanup =

std::unique_ptr<std::remove_pointer_t<raqm_t>, decltype(raqm::destroy)>{

rq, raqm::destroy};

if (!rq) {

throw std::runtime_error{"failed to compute text layout"};

}

TRUE_CHECK(raqm::set_text_utf8, rq, s.c_str(), s.size());

TRUE_CHECK(raqm::set_freetype_face, rq, ft_face);

for (auto const& feature:

*static_cast<std::vector<std::string>*>(

cairo_font_face_get_user_data(

cairo_get_font_face(cr), &detail::FEATURES_KEY))) {

TRUE_CHECK(raqm::add_font_feature, rq, feature.c_str(), -1);

}

for (auto const& [lang, start, stop]:

*static_cast<std::vector<std::tuple<std::string, int, int>>*>(

cairo_font_face_get_user_data(

cairo_get_font_face(cr), &detail::LANGS_KEY))) {

TRUE_CHECK(raqm::set_language, rq, lang.c_str(), start, stop);

}

TRUE_CHECK(raqm::layout, rq);

auto num_glyphs = size_t{};

auto const& rq_glyphs = raqm::get_glyphs(rq, &num_glyphs);

// With old versions of FreeType and raqm, glyphs of color fonts end up way

// too big (raqm#123). However, shaping is actually necessary to handle

// various ligature emojis, and if only a single glyph is to be drawn, then

// things are actually OK (even metrics-wise), so allow that case.

if (raqm::bad_color_glyph_spacing

&& num_glyphs > 1

&& cairo_font_face_get_user_data(cairo_get_font_face(cr),

&detail::IS_COLOR_FONT_KEY)) {

goto no_raqm;

}

gac.num_glyphs = num_glyphs;

gac.glyphs = cairo_glyph_allocate(gac.num_glyphs);

auto x = 0., y = 0.;

for (auto i = 0; i < gac.num_glyphs; ++i) {

auto const& rq_glyph = rq_glyphs[i];

gac.glyphs[i].index = rq_glyph.index;

gac.glyphs[i].x = x + rq_glyph.x_offset / 64.;

x += rq_glyph.x_advance / 64.;

gac.glyphs[i].y = -(y + rq_glyph.y_offset / 64.);

y += rq_glyph.y_advance / 64.;

}

// raqm returns glyphs left-to-right but cairo wants them in logical order.

if (num_glyphs