diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:24:48 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:24:48 +0000 |
commit | cca66b9ec4e494c1d919bff0f71a820d8afab1fa (patch) | |
tree | 146f39ded1c938019e1ed42d30923c2ac9e86789 /packaging/macos/modulesets/patches/cairo-pixman_dithering.patch | |
parent | Initial commit. (diff) | |
download | inkscape-12fc8abae6d434cac7670a59ed3a67301cc2eb10.tar.xz inkscape-12fc8abae6d434cac7670a59ed3a67301cc2eb10.zip |
Adding upstream version 1.2.2.upstream/1.2.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | packaging/macos/modulesets/patches/cairo-pixman_dithering.patch | 659 |
1 files changed, 659 insertions, 0 deletions
diff --git a/packaging/macos/modulesets/patches/cairo-pixman_dithering.patch b/packaging/macos/modulesets/patches/cairo-pixman_dithering.patch new file mode 100644 index 0000000..dc92e26 --- /dev/null +++ b/packaging/macos/modulesets/patches/cairo-pixman_dithering.patch @@ -0,0 +1,659 @@ +From e0d713b9bbd6d4a1e27e18c15141fa7f568001c7 Mon Sep 17 00:00:00 2001 +From: Marc Jeanmougin <marc@jeanmougin.fr> +Date: Wed, 29 May 2019 09:44:09 +0200 +Subject: [PATCH 1/3] Enable access to the pixman dithering path Code to choose + between dithering quality is modeled on the filter rendering choice + +--- + src/cairo-gl-gradient.c | 4 +++- + src/cairo-image-source.c | 48 +++++++++++++++++++++++++++++++++++++ + src/cairo-pattern-private.h | 1 + + src/cairo-pattern.c | 45 ++++++++++++++++++++++++++++++++++ + src/cairo.h | 14 +++++++++++ + 5 files changed, 111 insertions(+), 1 deletion(-) + +diff --git a/src/cairo-gl-gradient.c b/src/cairo-gl-gradient.c +index 293d4e30e..a22cca729 100644 +--- a/src/cairo-gl-gradient.c ++++ b/src/cairo-gl-gradient.c +@@ -160,7 +160,9 @@ _cairo_gl_gradient_render (const cairo_gl_context_t *ctx, + + pixman_image_set_filter (gradient, PIXMAN_FILTER_BILINEAR, NULL, 0); + pixman_image_set_repeat (gradient, PIXMAN_REPEAT_PAD); +- ++#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) ++ pixman_image_set_dither (gradient, PIXMAN_DITHER_BEST); ++#endif + image = pixman_image_create_bits (gradient_pixman_format, width, 1, + bytes, sizeof(uint32_t)*width); + if (unlikely (image == NULL)) { +diff --git a/src/cairo-image-source.c b/src/cairo-image-source.c +index c56845ab2..274f43df7 100644 +--- a/src/cairo-image-source.c ++++ b/src/cairo-image-source.c +@@ -383,6 +383,30 @@ _pixman_image_for_gradient (const cairo_gradient_pattern_t *pattern, + + pixman_image_set_repeat (pixman_image, pixman_repeat); + } ++#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) ++ { ++ pixman_dither_t pixman_dither; ++ ++ switch (pattern->base.dither) { ++ default: ++ case CAIRO_DITHER_NONE: ++ case CAIRO_DITHER_DEFAULT: ++ pixman_dither = PIXMAN_DITHER_NONE; ++ break; ++ case CAIRO_DITHER_FAST: ++ pixman_dither = PIXMAN_DITHER_FAST; ++ break; ++ case CAIRO_DITHER_GOOD: ++ pixman_dither = PIXMAN_DITHER_GOOD; ++ break; ++ case CAIRO_DITHER_BEST: ++ pixman_dither = PIXMAN_DITHER_BEST; ++ break; ++ } ++ ++ pixman_image_set_dither (pixman_image, pixman_dither); ++ } ++#endif + + return pixman_image; + } +@@ -1047,6 +1071,30 @@ _pixman_image_set_properties (pixman_image_t *pixman_image, + + pixman_image_set_repeat (pixman_image, pixman_repeat); + } ++#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) ++ { ++ pixman_dither_t pixman_dither; ++ ++ switch (pattern->dither) { ++ default: ++ case CAIRO_DITHER_NONE: ++ case CAIRO_DITHER_DEFAULT: ++ pixman_dither = PIXMAN_DITHER_NONE; ++ break; ++ case CAIRO_DITHER_FAST: ++ pixman_dither = PIXMAN_DITHER_FAST; ++ break; ++ case CAIRO_DITHER_GOOD: ++ pixman_dither = PIXMAN_DITHER_GOOD; ++ break; ++ case CAIRO_DITHER_BEST: ++ pixman_dither = PIXMAN_DITHER_BEST; ++ break; ++ } ++ ++ pixman_image_set_dither (pixman_image, pixman_dither); ++ } ++#endif + + if (pattern->has_component_alpha) + pixman_image_set_component_alpha (pixman_image, TRUE); +diff --git a/src/cairo-pattern-private.h b/src/cairo-pattern-private.h +index f6138fb70..96ae4f615 100644 +--- a/src/cairo-pattern-private.h ++++ b/src/cairo-pattern-private.h +@@ -70,6 +70,7 @@ struct _cairo_pattern { + cairo_pattern_type_t type; + + cairo_filter_t filter; ++ cairo_dither_t dither; + cairo_extend_t extend; + cairo_bool_t has_component_alpha; + cairo_bool_t is_userfont_foreground; +diff --git a/src/cairo-pattern.c b/src/cairo-pattern.c +index 6bd3edfd8..6cf907f36 100644 +--- a/src/cairo-pattern.c ++++ b/src/cairo-pattern.c +@@ -74,6 +74,7 @@ static const cairo_solid_pattern_t _cairo_pattern_nil = { + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_DEFAULT, /* filter */ ++ CAIRO_DITHER_DEFAULT, /* dither */ + CAIRO_EXTEND_GRADIENT_DEFAULT, /* extend */ + FALSE, /* has component alpha */ + FALSE, /* is_userfont_foreground */ +@@ -91,6 +92,7 @@ static const cairo_solid_pattern_t _cairo_pattern_nil_null_pointer = { + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_DEFAULT, /* filter */ ++ CAIRO_DITHER_DEFAULT, /* dither */ + CAIRO_EXTEND_GRADIENT_DEFAULT, /* extend */ + FALSE, /* has component alpha */ + FALSE, /* is_userfont_foreground */ +@@ -108,6 +110,7 @@ const cairo_solid_pattern_t _cairo_pattern_black = { + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_NEAREST, /* filter */ ++ CAIRO_DITHER_DEFAULT, /* dither */ + CAIRO_EXTEND_REPEAT, /* extend */ + FALSE, /* has component alpha */ + FALSE, /* is_userfont_foreground */ +@@ -126,6 +129,7 @@ const cairo_solid_pattern_t _cairo_pattern_clear = { + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_NEAREST, /* filter */ ++ CAIRO_DITHER_DEFAULT, /* dither */ + CAIRO_EXTEND_REPEAT, /* extend */ + FALSE, /* has component alpha */ + FALSE, /* is_userfont_foreground */ +@@ -144,6 +148,7 @@ const cairo_solid_pattern_t _cairo_pattern_white = { + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_NEAREST, /* filter */ ++ CAIRO_DITHER_DEFAULT, /* dither */ + CAIRO_EXTEND_REPEAT, /* extend */ + FALSE, /* has component alpha */ + FALSE, /* is_userfont_foreground */ +@@ -235,6 +240,7 @@ _cairo_pattern_init (cairo_pattern_t *pattern, cairo_pattern_type_t type) + pattern->extend = CAIRO_EXTEND_GRADIENT_DEFAULT; + + pattern->filter = CAIRO_FILTER_DEFAULT; ++ pattern->dither = CAIRO_DITHER_DEFAULT; + pattern->opacity = 1.0; + + pattern->has_component_alpha = FALSE; +@@ -2074,6 +2080,28 @@ cairo_pattern_set_filter (cairo_pattern_t *pattern, cairo_filter_t filter) + _cairo_pattern_notify_observers (pattern, CAIRO_PATTERN_NOTIFY_FILTER); + } + ++/** ++ * cairo_pattern_set_dither: ++ * @pattern: a #cairo_pattern_t ++ * @filter: a #cairo_dither_t describing the dithering to use ++ * ++ * See #cairo_dither_t for details on each algorithm. ++ * ++ * Since: TODO ++ **/ ++void ++cairo_pattern_set_dither (cairo_pattern_t *pattern, cairo_dither_t dither) ++{ ++ if (pattern->status) ++ return; ++ ++ pattern->dither = dither; ++ _cairo_pattern_notify_observers (pattern, CAIRO_PATTERN_NOTIFY_FILTER); ++ /* We probably can notify the same observers as when we notify filter ++ * changes (?) TODO CHECK THAT */ ++} ++ ++ + /** + * cairo_pattern_get_filter: + * @pattern: a #cairo_pattern_t +@@ -2091,6 +2119,23 @@ cairo_pattern_get_filter (cairo_pattern_t *pattern) + return pattern->filter; + } + ++/** ++ * cairo_pattern_get_dither: ++ * @pattern: a #cairo_pattern_t ++ * ++ * Gets the current dithering for a pattern. See #cairo_dither_t ++ * for details. ++ * ++ * Return value: the current dithering algorithm of the pattern ++ * ++ * Since: TODO ++ **/ ++cairo_dither_t ++cairo_pattern_get_dither (cairo_pattern_t *pattern) ++{ ++ return pattern->dither; ++} ++ + /** + * cairo_pattern_set_extend: + * @pattern: a #cairo_pattern_t +diff --git a/src/cairo.h b/src/cairo.h +index fb1da4146..1c911d09d 100644 +--- a/src/cairo.h ++++ b/src/cairo.h +@@ -3003,12 +3003,26 @@ typedef enum _cairo_filter { + CAIRO_FILTER_GAUSSIAN + } cairo_filter_t; + ++typedef enum _cairo_dither { ++ CAIRO_DITHER_NONE, ++ CAIRO_DITHER_DEFAULT, ++ CAIRO_DITHER_FAST, ++ CAIRO_DITHER_GOOD, ++ CAIRO_DITHER_BEST ++} cairo_dither_t; ++ + cairo_public void + cairo_pattern_set_filter (cairo_pattern_t *pattern, cairo_filter_t filter); + + cairo_public cairo_filter_t + cairo_pattern_get_filter (cairo_pattern_t *pattern); + ++cairo_public void ++cairo_pattern_set_dither (cairo_pattern_t *pattern, cairo_dither_t dither); ++ ++cairo_public cairo_dither_t ++cairo_pattern_get_dither (cairo_pattern_t *pattern); ++ + cairo_public cairo_status_t + cairo_pattern_get_rgba (cairo_pattern_t *pattern, + double *red, double *green, +-- +2.25.1 + + +From 659173b4bb01e2de438d894dca9ed01838eaf028 Mon Sep 17 00:00:00 2001 +From: Marc Jeanmougin <marc@jeanmougin.fr> +Date: Sat, 27 Mar 2021 23:53:28 +0100 +Subject: [PATCH 2/3] Expose dithering property at the image surface level. + +Copies the property on push_group +--- + src/cairo-default-context.c | 6 ++- + src/cairo-image-source.c | 40 ++---------------- + src/cairo-image-surface-private.h | 1 + + src/cairo-image-surface.c | 67 +++++++++++++++++++++++++++++++ + src/cairo.h | 22 ++++++---- + src/cairoint.h | 5 +++ + 6 files changed, 96 insertions(+), 45 deletions(-) + +diff --git a/src/cairo-default-context.c b/src/cairo-default-context.c +index 567c5d4d5..24af125da 100644 +--- a/src/cairo-default-context.c ++++ b/src/cairo-default-context.c +@@ -180,7 +180,11 @@ _cairo_default_context_push_group (void *abstract_cr, cairo_content_t content) + if (unlikely (status)) + goto bail; + +- /* Set device offsets on the new surface so that logically it appears at ++ /* copies over the dither property */ ++ cairo_image_surface_set_dither(group_surface, ++ cairo_image_surface_get_dither(parent_surface)); ++ ++ /* Set device offsets on the new surface so that logically it appears at + * the same location on the parent surface -- when we pop_group this, + * the source pattern will get fixed up for the appropriate target surface + * device offsets, so we want to set our own surface offsets from /that/, +diff --git a/src/cairo-image-source.c b/src/cairo-image-source.c +index 274f43df7..93daff3c0 100644 +--- a/src/cairo-image-source.c ++++ b/src/cairo-image-source.c +@@ -385,24 +385,8 @@ _pixman_image_for_gradient (const cairo_gradient_pattern_t *pattern, + } + #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) + { +- pixman_dither_t pixman_dither; +- +- switch (pattern->base.dither) { +- default: +- case CAIRO_DITHER_NONE: +- case CAIRO_DITHER_DEFAULT: +- pixman_dither = PIXMAN_DITHER_NONE; +- break; +- case CAIRO_DITHER_FAST: +- pixman_dither = PIXMAN_DITHER_FAST; +- break; +- case CAIRO_DITHER_GOOD: +- pixman_dither = PIXMAN_DITHER_GOOD; +- break; +- case CAIRO_DITHER_BEST: +- pixman_dither = PIXMAN_DITHER_BEST; +- break; +- } ++ pixman_dither_t pixman_dither = ++ _pixman_dither_from_cairo_dither(pattern->base.dither); + + pixman_image_set_dither (pixman_image, pixman_dither); + } +@@ -1073,24 +1057,8 @@ _pixman_image_set_properties (pixman_image_t *pixman_image, + } + #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) + { +- pixman_dither_t pixman_dither; +- +- switch (pattern->dither) { +- default: +- case CAIRO_DITHER_NONE: +- case CAIRO_DITHER_DEFAULT: +- pixman_dither = PIXMAN_DITHER_NONE; +- break; +- case CAIRO_DITHER_FAST: +- pixman_dither = PIXMAN_DITHER_FAST; +- break; +- case CAIRO_DITHER_GOOD: +- pixman_dither = PIXMAN_DITHER_GOOD; +- break; +- case CAIRO_DITHER_BEST: +- pixman_dither = PIXMAN_DITHER_BEST; +- break; +- } ++ pixman_dither_t pixman_dither = ++ _pixman_dither_from_cairo_dither (pattern->dither); + + pixman_image_set_dither (pixman_image, pixman_dither); + } +diff --git a/src/cairo-image-surface-private.h b/src/cairo-image-surface-private.h +index 2b7921133..c06b9737b 100644 +--- a/src/cairo-image-surface-private.h ++++ b/src/cairo-image-surface-private.h +@@ -78,6 +78,7 @@ struct _cairo_image_surface { + unsigned owns_data : 1; + unsigned transparency : 2; + unsigned color : 2; ++ cairo_dither_t dither : 3; + }; + #define to_image_surface(S) ((cairo_image_surface_t *)(S)) + +diff --git a/src/cairo-image-surface.c b/src/cairo-image-surface.c +index 3b11eb981..977bb48e6 100644 +--- a/src/cairo-image-surface.c ++++ b/src/cairo-image-surface.c +@@ -169,6 +169,7 @@ _cairo_image_surface_init (cairo_image_surface_t *surface, + surface->owns_data = FALSE; + surface->transparency = CAIRO_IMAGE_UNKNOWN; + surface->color = CAIRO_IMAGE_UNKNOWN_COLOR; ++ surface->dither = CAIRO_DITHER_DEFAULT; + + surface->width = pixman_image_get_width (pixman_image); + surface->height = pixman_image_get_height (pixman_image); +@@ -248,6 +249,25 @@ _pixman_format_from_masks (cairo_format_masks_t *masks, + return TRUE; + } + ++#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) ++/* Convenience function to convert cairo_dither_t into pixman_dither_t */ ++pixman_dither_t _pixman_dither_from_cairo_dither(cairo_dither_t dither) ++{ ++ switch(dither) { ++ default: ++ case CAIRO_DITHER_NONE: ++ case CAIRO_DITHER_DEFAULT: ++ return PIXMAN_DITHER_NONE; ++ case CAIRO_DITHER_FAST: ++ return PIXMAN_DITHER_FAST; ++ case CAIRO_DITHER_GOOD: ++ return PIXMAN_DITHER_GOOD; ++ case CAIRO_DITHER_BEST: ++ return PIXMAN_DITHER_BEST; ++ } ++} ++#endif ++ + /* A mask consisting of N bits set to 1. */ + #define MASK(N) ((1UL << (N))-1) + +@@ -631,6 +651,30 @@ cairo_image_surface_get_width (cairo_surface_t *surface) + } + slim_hidden_def (cairo_image_surface_get_width); + ++/** ++ * cairo_image_surface_get_dither: ++ * @surface: a #cairo_image_surface_t ++ * ++ * Get the current dithering method ++ * ++ * Return value: the current dithering method. ++ * ++ * Since: TODO ++ **/ ++cairo_dither_t ++cairo_image_surface_get_dither (cairo_surface_t *surface) ++{ ++ cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; ++ ++ if (! _cairo_surface_is_image (surface)) { ++ _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); ++ return CAIRO_DITHER_DEFAULT; ++ } ++ ++ return image_surface->dither; ++} ++//slim_hidden_def (cairo_image_surface_get_dither); ++ + /** + * cairo_image_surface_get_height: + * @surface: a #cairo_image_surface_t +@@ -792,6 +836,7 @@ _cairo_image_surface_snapshot (void *abstract_surface) + + clone->transparency = image->transparency; + clone->color = image->color; ++ clone->dither = image->dither; + + clone->owns_data = TRUE; + return &clone->base; +@@ -1361,3 +1406,25 @@ error: + cairo_surface_destroy (image); + return to_image_surface (_cairo_surface_create_in_error (status)); + } ++ ++cairo_public int ++cairo_image_surface_set_dither (cairo_surface_t *surface, cairo_dither_t dither) ++{ ++ cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; ++ ++ if (! _cairo_surface_is_image (surface)) { ++ _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); ++ return 0; ++ } ++ ++ image_surface->dither = dither; ++ if (image_surface->pixman_image) { ++#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) ++ pixman_image_set_dither(image_surface->pixman_image, ++ _pixman_dither_from_cairo_dither(dither)); ++#endif ++ } ++ ++} ++//slim_hidden_def (cairo_image_surface_set_dither); ++ +diff --git a/src/cairo.h b/src/cairo.h +index 1c911d09d..76db87d2e 100644 +--- a/src/cairo.h ++++ b/src/cairo.h +@@ -427,6 +427,14 @@ typedef enum _cairo_format { + CAIRO_FORMAT_RGBA128F = 7 + } cairo_format_t; + ++typedef enum _cairo_dither { ++ CAIRO_DITHER_NONE, ++ CAIRO_DITHER_DEFAULT, ++ CAIRO_DITHER_FAST, ++ CAIRO_DITHER_GOOD, ++ CAIRO_DITHER_BEST ++} cairo_dither_t; ++ + + /** + * cairo_write_func_t: +@@ -2607,6 +2615,12 @@ cairo_image_surface_create_for_data (unsigned char *data, + cairo_public unsigned char * + cairo_image_surface_get_data (cairo_surface_t *surface); + ++cairo_public cairo_dither_t ++cairo_image_surface_get_dither (cairo_surface_t *surface); ++ ++cairo_public int ++cairo_image_surface_set_dither (cairo_surface_t *surface, cairo_dither_t dither); ++ + cairo_public cairo_format_t + cairo_image_surface_get_format (cairo_surface_t *surface); + +@@ -3003,14 +3017,6 @@ typedef enum _cairo_filter { + CAIRO_FILTER_GAUSSIAN + } cairo_filter_t; + +-typedef enum _cairo_dither { +- CAIRO_DITHER_NONE, +- CAIRO_DITHER_DEFAULT, +- CAIRO_DITHER_FAST, +- CAIRO_DITHER_GOOD, +- CAIRO_DITHER_BEST +-} cairo_dither_t; +- + cairo_public void + cairo_pattern_set_filter (cairo_pattern_t *pattern, cairo_filter_t filter); + +diff --git a/src/cairoint.h b/src/cairoint.h +index 80b695feb..a8442b5fe 100644 +--- a/src/cairoint.h ++++ b/src/cairoint.h +@@ -1592,6 +1592,11 @@ cairo_private cairo_bool_t + _pixman_format_to_masks (pixman_format_code_t pixman_format, + cairo_format_masks_t *masks); + ++#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) ++cairo_private pixman_dither_t ++_pixman_dither_from_cairo_dither(cairo_dither_t dither); ++#endif ++ + cairo_private void + _cairo_image_scaled_glyph_fini (cairo_scaled_font_t *scaled_font, + cairo_scaled_glyph_t *scaled_glyph); +-- +2.25.1 + + +From edf60824e871d2393136303761135bb49986fa33 Mon Sep 17 00:00:00 2001 +From: Marc Jeanmougin <marc@jeanmougin.fr> +Date: Mon, 29 Mar 2021 12:18:56 +0200 +Subject: [PATCH 3/3] make lint tests pass + +--- + src/cairo-image-surface.c | 20 +++++++++++++++----- + src/cairo-pattern.c | 4 ++-- + src/cairoint.h | 4 +++- + 3 files changed, 20 insertions(+), 8 deletions(-) + +diff --git a/src/cairo-image-surface.c b/src/cairo-image-surface.c +index 977bb48e6..d2f544a68 100644 +--- a/src/cairo-image-surface.c ++++ b/src/cairo-image-surface.c +@@ -250,8 +250,9 @@ _pixman_format_from_masks (cairo_format_masks_t *masks, + } + + #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) +-/* Convenience function to convert cairo_dither_t into pixman_dither_t */ +-pixman_dither_t _pixman_dither_from_cairo_dither(cairo_dither_t dither) ++/* Convenience function to convert #cairo_dither_t into #pixman_dither_t */ ++pixman_dither_t ++_pixman_dither_from_cairo_dither (cairo_dither_t dither) + { + switch(dither) { + default: +@@ -659,7 +660,7 @@ slim_hidden_def (cairo_image_surface_get_width); + * + * Return value: the current dithering method. + * +- * Since: TODO ++ * Since: 1.18 + **/ + cairo_dither_t + cairo_image_surface_get_dither (cairo_surface_t *surface) +@@ -673,7 +674,7 @@ cairo_image_surface_get_dither (cairo_surface_t *surface) + + return image_surface->dither; + } +-//slim_hidden_def (cairo_image_surface_get_dither); ++slim_hidden_def (cairo_image_surface_get_dither); + + /** + * cairo_image_surface_get_height: +@@ -1407,6 +1408,15 @@ error: + return to_image_surface (_cairo_surface_create_in_error (status)); + } + ++/** ++ * cairo_image_surface_set_dither: ++ * @surface: a #cairo_image_surface_t ++ * @dither: a #cairo_dither_t ++ * ++ * Sets the current dithering method ++ * ++ * Since: 1.18 ++ **/ + cairo_public int + cairo_image_surface_set_dither (cairo_surface_t *surface, cairo_dither_t dither) + { +@@ -1426,5 +1436,5 @@ cairo_image_surface_set_dither (cairo_surface_t *surface, cairo_dither_t dither) + } + + } +-//slim_hidden_def (cairo_image_surface_set_dither); ++slim_hidden_def (cairo_image_surface_set_dither); + +diff --git a/src/cairo-pattern.c b/src/cairo-pattern.c +index 6cf907f36..7d05b06a1 100644 +--- a/src/cairo-pattern.c ++++ b/src/cairo-pattern.c +@@ -2087,7 +2087,7 @@ cairo_pattern_set_filter (cairo_pattern_t *pattern, cairo_filter_t filter) + * + * See #cairo_dither_t for details on each algorithm. + * +- * Since: TODO ++ * Since: 1.18 + **/ + void + cairo_pattern_set_dither (cairo_pattern_t *pattern, cairo_dither_t dither) +@@ -2128,7 +2128,7 @@ cairo_pattern_get_filter (cairo_pattern_t *pattern) + * + * Return value: the current dithering algorithm of the pattern + * +- * Since: TODO ++ * Since: 1.18 + **/ + cairo_dither_t + cairo_pattern_get_dither (cairo_pattern_t *pattern) +diff --git a/src/cairoint.h b/src/cairoint.h +index a8442b5fe..274d43556 100644 +--- a/src/cairoint.h ++++ b/src/cairoint.h +@@ -1594,7 +1594,7 @@ _pixman_format_to_masks (pixman_format_code_t pixman_format, + + #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,39,0) + cairo_private pixman_dither_t +-_pixman_dither_from_cairo_dither(cairo_dither_t dither); ++_pixman_dither_from_cairo_dither (cairo_dither_t dither); + #endif + + cairo_private void +@@ -1982,6 +1982,8 @@ slim_hidden_proto (cairo_image_surface_get_format); + slim_hidden_proto (cairo_image_surface_get_height); + slim_hidden_proto (cairo_image_surface_get_stride); + slim_hidden_proto (cairo_image_surface_get_width); ++slim_hidden_proto (cairo_image_surface_get_dither); ++slim_hidden_proto (cairo_image_surface_set_dither); + slim_hidden_proto (cairo_line_to); + slim_hidden_proto (cairo_mask); + slim_hidden_proto (cairo_matrix_init); +-- +2.25.1 + + +From b2e0f1d6f69ad3013dfb8d677f7b3ee9fac0fceb Mon Sep 17 00:00:00 2001 +From: Marc Jeanmougin <marc@jeanmougin.fr> +Date: Mon, 24 Jan 2022 21:28:44 +0100 +Subject: [PATCH] add define to detect patched cairo + +--- + src/cairo.h | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/cairo.h b/src/cairo.h +index 76db87d2e..934bf65d0 100644 +--- a/src/cairo.h ++++ b/src/cairo.h +@@ -2615,6 +2615,7 @@ cairo_image_surface_create_for_data (unsigned char *data, + cairo_public unsigned char * + cairo_image_surface_get_data (cairo_surface_t *surface); + ++#define CAIRO_HAS_DITHER + cairo_public cairo_dither_t + cairo_image_surface_get_dither (cairo_surface_t *surface); + +-- +2.25.1 + |