mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-09 20:54:40 +00:00
520 lines
19 KiB
Diff
520 lines
19 KiB
Diff
|
# HG changeset patch
|
||
|
# User Robert O'Callahan <robert@ocallahan.org>
|
||
|
# Date 1294019288 -46800
|
||
|
# Node ID 8857392e37aea7475ed6d8ee4b45023e1233bcec
|
||
|
# Parent c53f60831c43cca397dfed8adf8d350aeec7d3ca
|
||
|
Bug 363861. Part 2: Introduce cairo_surface_get/set_subpixel_antialiasing. r=jrmuizel,sr=vlad,a=blocking
|
||
|
|
||
|
diff --git a/gfx/cairo/cairo/src/cairo-quartz-surface.c b/gfx/cairo/cairo/src/cairo-quartz-surface.c
|
||
|
--- a/gfx/cairo/cairo/src/cairo-quartz-surface.c
|
||
|
+++ b/gfx/cairo/cairo/src/cairo-quartz-surface.c
|
||
|
@@ -2473,16 +2473,17 @@ _cairo_quartz_surface_show_glyphs (void
|
||
|
cairo_int_status_t rv = CAIRO_STATUS_SUCCESS;
|
||
|
cairo_quartz_drawing_state_t state;
|
||
|
float xprev, yprev;
|
||
|
int i;
|
||
|
CGFontRef cgfref = NULL;
|
||
|
|
||
|
cairo_bool_t isClipping = FALSE;
|
||
|
cairo_bool_t didForceFontSmoothing = FALSE;
|
||
|
+ cairo_antialias_t effective_antialiasing;
|
||
|
|
||
|
if (IS_EMPTY(surface))
|
||
|
return CAIRO_STATUS_SUCCESS;
|
||
|
|
||
|
if (num_glyphs <= 0)
|
||
|
return CAIRO_STATUS_SUCCESS;
|
||
|
|
||
|
if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_QUARTZ)
|
||
|
@@ -2514,16 +2515,22 @@ _cairo_quartz_surface_show_glyphs (void
|
||
|
goto BAIL;
|
||
|
}
|
||
|
|
||
|
/* this doesn't addref */
|
||
|
cgfref = _cairo_quartz_scaled_font_get_cg_font_ref (scaled_font);
|
||
|
CGContextSetFont (state.context, cgfref);
|
||
|
CGContextSetFontSize (state.context, 1.0);
|
||
|
|
||
|
+ effective_antialiasing = scaled_font->options.antialias;
|
||
|
+ if (effective_antialiasing == CAIRO_ANTIALIAS_SUBPIXEL &&
|
||
|
+ !surface->base.permit_subpixel_antialiasing) {
|
||
|
+ effective_antialiasing = CAIRO_ANTIALIAS_GRAY;
|
||
|
+ }
|
||
|
+
|
||
|
switch (scaled_font->options.antialias) {
|
||
|
case CAIRO_ANTIALIAS_SUBPIXEL:
|
||
|
CGContextSetShouldAntialias (state.context, TRUE);
|
||
|
CGContextSetShouldSmoothFonts (state.context, TRUE);
|
||
|
if (CGContextSetAllowsFontSmoothingPtr &&
|
||
|
!CGContextGetAllowsFontSmoothingPtr (state.context))
|
||
|
{
|
||
|
didForceFontSmoothing = TRUE;
|
||
|
diff --git a/gfx/cairo/cairo/src/cairo-surface-private.h b/gfx/cairo/cairo/src/cairo-surface-private.h
|
||
|
--- a/gfx/cairo/cairo/src/cairo-surface-private.h
|
||
|
+++ b/gfx/cairo/cairo/src/cairo-surface-private.h
|
||
|
@@ -58,16 +58,17 @@ struct _cairo_surface {
|
||
|
|
||
|
cairo_reference_count_t ref_count;
|
||
|
cairo_status_t status;
|
||
|
unsigned int unique_id;
|
||
|
|
||
|
unsigned finished : 1;
|
||
|
unsigned is_clear : 1;
|
||
|
unsigned has_font_options : 1;
|
||
|
+ unsigned permit_subpixel_antialiasing : 1;
|
||
|
|
||
|
cairo_user_data_array_t user_data;
|
||
|
cairo_user_data_array_t mime_data;
|
||
|
|
||
|
cairo_matrix_t device_transform;
|
||
|
cairo_matrix_t device_transform_inverse;
|
||
|
|
||
|
/* The actual resolution of the device, in dots per inch. */
|
||
|
diff --git a/gfx/cairo/cairo/src/cairo-surface.c b/gfx/cairo/cairo/src/cairo-surface.c
|
||
|
--- a/gfx/cairo/cairo/src/cairo-surface.c
|
||
|
+++ b/gfx/cairo/cairo/src/cairo-surface.c
|
||
|
@@ -49,17 +49,18 @@ const cairo_surface_t name = { \
|
||
|
NULL, /* backend */ \
|
||
|
CAIRO_SURFACE_TYPE_IMAGE, /* type */ \
|
||
|
CAIRO_CONTENT_COLOR, /* content */ \
|
||
|
CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ \
|
||
|
status, /* status */ \
|
||
|
0, /* unique id */ \
|
||
|
FALSE, /* finished */ \
|
||
|
TRUE, /* is_clear */ \
|
||
|
- FALSE, /* has_font_options */ \
|
||
|
+ FALSE, /* has_font_options */ \
|
||
|
+ FALSE, /* permit_subpixel_antialiasing */ \
|
||
|
{ 0, 0, 0, NULL, }, /* user_data */ \
|
||
|
{ 0, 0, 0, NULL, }, /* mime_data */ \
|
||
|
{ 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 }, /* device_transform */ \
|
||
|
{ 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 }, /* device_transform_inverse */ \
|
||
|
0.0, /* x_resolution */ \
|
||
|
0.0, /* y_resolution */ \
|
||
|
0.0, /* x_fallback_resolution */ \
|
||
|
0.0, /* y_fallback_resolution */ \
|
||
|
@@ -342,46 +343,48 @@ _cairo_surface_init (cairo_surface_t *
|
||
|
surface->content = content;
|
||
|
surface->type = backend->type;
|
||
|
|
||
|
CAIRO_REFERENCE_COUNT_INIT (&surface->ref_count, 1);
|
||
|
surface->status = CAIRO_STATUS_SUCCESS;
|
||
|
surface->unique_id = _cairo_surface_allocate_unique_id ();
|
||
|
surface->finished = FALSE;
|
||
|
surface->is_clear = FALSE;
|
||
|
+ surface->has_font_options = FALSE;
|
||
|
+ surface->permit_subpixel_antialiasing = TRUE;
|
||
|
|
||
|
_cairo_user_data_array_init (&surface->user_data);
|
||
|
_cairo_user_data_array_init (&surface->mime_data);
|
||
|
|
||
|
cairo_matrix_init_identity (&surface->device_transform);
|
||
|
cairo_matrix_init_identity (&surface->device_transform_inverse);
|
||
|
|
||
|
surface->x_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT;
|
||
|
surface->y_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT;
|
||
|
|
||
|
surface->x_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT;
|
||
|
surface->y_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT;
|
||
|
|
||
|
_cairo_array_init (&surface->snapshots, sizeof (cairo_surface_t *));
|
||
|
surface->snapshot_of = NULL;
|
||
|
-
|
||
|
- surface->has_font_options = FALSE;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
_cairo_surface_copy_similar_properties (cairo_surface_t *surface,
|
||
|
cairo_surface_t *other)
|
||
|
{
|
||
|
if (other->has_font_options || other->backend != surface->backend) {
|
||
|
cairo_font_options_t options;
|
||
|
|
||
|
cairo_surface_get_font_options (other, &options);
|
||
|
_cairo_surface_set_font_options (surface, &options);
|
||
|
}
|
||
|
|
||
|
+ surface->permit_subpixel_antialiasing = other->permit_subpixel_antialiasing;
|
||
|
+
|
||
|
cairo_surface_set_fallback_resolution (surface,
|
||
|
other->x_fallback_resolution,
|
||
|
other->y_fallback_resolution);
|
||
|
}
|
||
|
|
||
|
cairo_surface_t *
|
||
|
_cairo_surface_create_similar_scratch (cairo_surface_t *other,
|
||
|
cairo_content_t content,
|
||
|
@@ -2482,16 +2485,67 @@ cairo_surface_has_show_text_glyphs (cair
|
||
|
|
||
|
if (surface->backend->has_show_text_glyphs)
|
||
|
return surface->backend->has_show_text_glyphs (surface);
|
||
|
else
|
||
|
return surface->backend->show_text_glyphs != NULL;
|
||
|
}
|
||
|
slim_hidden_def (cairo_surface_has_show_text_glyphs);
|
||
|
|
||
|
+/**
|
||
|
+ * cairo_surface_set_subpixel_antialiasing:
|
||
|
+ * @surface: a #cairo_surface_t
|
||
|
+ *
|
||
|
+ * Sets whether the surface permits subpixel antialiasing. By default,
|
||
|
+ * surfaces permit subpixel antialiasing.
|
||
|
+ *
|
||
|
+ * Enabling subpixel antialiasing for CONTENT_COLOR_ALPHA surfaces generally
|
||
|
+ * requires that the pixels in the areas under a subpixel antialiasing
|
||
|
+ * operation already be opaque.
|
||
|
+ *
|
||
|
+ * Since: 1.12
|
||
|
+ **/
|
||
|
+void
|
||
|
+cairo_surface_set_subpixel_antialiasing (cairo_surface_t *surface,
|
||
|
+ cairo_subpixel_antialiasing_t enabled)
|
||
|
+{
|
||
|
+ if (surface->status)
|
||
|
+ return;
|
||
|
+
|
||
|
+ if (surface->finished) {
|
||
|
+ _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
|
||
|
+ return;
|
||
|
+ }
|
||
|
+
|
||
|
+ surface->permit_subpixel_antialiasing =
|
||
|
+ enabled == CAIRO_SUBPIXEL_ANTIALIASING_ENABLED;
|
||
|
+}
|
||
|
+slim_hidden_def (cairo_surface_set_subpixel_antialiasing);
|
||
|
+
|
||
|
+/**
|
||
|
+ * cairo_surface_get_subpixel_antialiasing:
|
||
|
+ * @surface: a #cairo_surface_t
|
||
|
+ *
|
||
|
+ * Gets whether the surface supports subpixel antialiasing. By default,
|
||
|
+ * CAIRO_CONTENT_COLOR surfaces support subpixel antialiasing but other
|
||
|
+ * surfaces do not.
|
||
|
+ *
|
||
|
+ * Since: 1.12
|
||
|
+ **/
|
||
|
+cairo_subpixel_antialiasing_t
|
||
|
+cairo_surface_get_subpixel_antialiasing (cairo_surface_t *surface)
|
||
|
+{
|
||
|
+ if (surface->status)
|
||
|
+ return CAIRO_SUBPIXEL_ANTIALIASING_DISABLED;
|
||
|
+
|
||
|
+ return surface->permit_subpixel_antialiasing ?
|
||
|
+ CAIRO_SUBPIXEL_ANTIALIASING_ENABLED : CAIRO_SUBPIXEL_ANTIALIASING_DISABLED;
|
||
|
+}
|
||
|
+slim_hidden_def (cairo_surface_get_subpixel_antialiasing);
|
||
|
+
|
||
|
/* Note: the backends may modify the contents of the glyph array as long as
|
||
|
* they do not return %CAIRO_INT_STATUS_UNSUPPORTED. This makes it possible to
|
||
|
* avoid copying the array again and again, and edit it in-place.
|
||
|
* Backends are in fact free to use the array as a generic buffer as they
|
||
|
* see fit.
|
||
|
*
|
||
|
* For show_glyphs backend method, and NOT for show_text_glyphs method,
|
||
|
* when they do return UNSUPPORTED, they may adjust remaining_glyphs to notify
|
||
|
diff --git a/gfx/cairo/cairo/src/cairo-win32-font.c b/gfx/cairo/cairo/src/cairo-win32-font.c
|
||
|
--- a/gfx/cairo/cairo/src/cairo-win32-font.c
|
||
|
+++ b/gfx/cairo/cairo/src/cairo-win32-font.c
|
||
|
@@ -1380,16 +1380,17 @@ _cairo_win32_scaled_font_show_glyphs (vo
|
||
|
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)generic_surface;
|
||
|
cairo_status_t status;
|
||
|
|
||
|
if (width == 0 || height == 0)
|
||
|
return CAIRO_STATUS_SUCCESS;
|
||
|
|
||
|
if (_cairo_surface_is_win32 (generic_surface) &&
|
||
|
surface->format == CAIRO_FORMAT_RGB24 &&
|
||
|
+ (generic_surface->permit_subpixel_antialiasing || scaled_font->quality != CLEARTYPE_QUALITY) &&
|
||
|
op == CAIRO_OPERATOR_OVER &&
|
||
|
_cairo_pattern_is_opaque_solid (pattern)) {
|
||
|
|
||
|
cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)pattern;
|
||
|
|
||
|
/* When compositing OVER on a GDI-understood surface, with a
|
||
|
* solid opaque color, we can just call ExtTextOut directly.
|
||
|
*/
|
||
|
@@ -1411,16 +1412,18 @@ _cairo_win32_scaled_font_show_glyphs (vo
|
||
|
* surface by drawing the the glyphs onto a DIB, black-on-white then
|
||
|
* inverting. GDI outputs gamma-corrected images so inverted black-on-white
|
||
|
* is very different from white-on-black. We favor the more common
|
||
|
* case where the final output is dark-on-light.
|
||
|
*/
|
||
|
cairo_win32_surface_t *tmp_surface;
|
||
|
cairo_surface_t *mask_surface;
|
||
|
cairo_surface_pattern_t mask;
|
||
|
+ cairo_bool_t use_subpixel_antialiasing =
|
||
|
+ scaled_font->quality == CLEARTYPE_QUALITY && generic_surface->permit_subpixel_antialiasing;
|
||
|
RECT r;
|
||
|
|
||
|
tmp_surface = (cairo_win32_surface_t *)cairo_win32_surface_create_with_dib (CAIRO_FORMAT_ARGB32, width, height);
|
||
|
if (tmp_surface->base.status)
|
||
|
return tmp_surface->base.status;
|
||
|
|
||
|
r.left = 0;
|
||
|
r.top = 0;
|
||
|
@@ -1432,17 +1435,17 @@ _cairo_win32_scaled_font_show_glyphs (vo
|
||
|
scaled_font, RGB (0, 0, 0),
|
||
|
dest_x, dest_y,
|
||
|
glyphs, num_glyphs);
|
||
|
if (status) {
|
||
|
cairo_surface_destroy (&tmp_surface->base);
|
||
|
return status;
|
||
|
}
|
||
|
|
||
|
- if (scaled_font->quality == CLEARTYPE_QUALITY) {
|
||
|
+ if (use_subpixel_antialiasing) {
|
||
|
/* For ClearType, we need a 4-channel mask. If we are compositing on
|
||
|
* a surface with alpha, we need to compute the alpha channel of
|
||
|
* the mask (we just copy the green channel). But for a destination
|
||
|
* surface without alpha the alpha channel of the mask is ignored
|
||
|
*/
|
||
|
|
||
|
if (surface->format != CAIRO_FORMAT_RGB24)
|
||
|
_compute_argb32_mask_alpha (tmp_surface);
|
||
|
@@ -1460,17 +1463,17 @@ _cairo_win32_scaled_font_show_glyphs (vo
|
||
|
|
||
|
/* For op == OVER, no-cleartype, a possible optimization here is to
|
||
|
* draw onto an intermediate ARGB32 surface and alpha-blend that with the
|
||
|
* destination
|
||
|
*/
|
||
|
_cairo_pattern_init_for_surface (&mask, mask_surface);
|
||
|
cairo_surface_destroy (mask_surface);
|
||
|
|
||
|
- if (scaled_font->quality == CLEARTYPE_QUALITY)
|
||
|
+ if (use_subpixel_antialiasing)
|
||
|
mask.base.has_component_alpha = TRUE;
|
||
|
|
||
|
status = _cairo_surface_composite (op, pattern,
|
||
|
&mask.base,
|
||
|
&surface->base,
|
||
|
source_x, source_y,
|
||
|
0, 0,
|
||
|
dest_x, dest_y,
|
||
|
diff --git a/gfx/cairo/cairo/src/cairo-xlib-surface.c b/gfx/cairo/cairo/src/cairo-xlib-surface.c
|
||
|
--- a/gfx/cairo/cairo/src/cairo-xlib-surface.c
|
||
|
+++ b/gfx/cairo/cairo/src/cairo-xlib-surface.c
|
||
|
@@ -3570,16 +3570,17 @@ typedef struct _cairo_xlib_font_glyphset
|
||
|
GlyphSet glyphset;
|
||
|
cairo_format_t format;
|
||
|
XRenderPictFormat *xrender_format;
|
||
|
cairo_xlib_font_glyphset_free_glyphs_t *pending_free_glyphs;
|
||
|
} cairo_xlib_font_glyphset_info_t;
|
||
|
|
||
|
typedef struct _cairo_xlib_surface_font_private {
|
||
|
cairo_scaled_font_t *scaled_font;
|
||
|
+ cairo_scaled_font_t *grayscale_font;
|
||
|
cairo_xlib_hook_t close_display_hook;
|
||
|
cairo_xlib_display_t *display;
|
||
|
cairo_xlib_font_glyphset_info_t glyphset_info[NUM_GLYPHSETS];
|
||
|
} cairo_xlib_surface_font_private_t;
|
||
|
|
||
|
/* callback from CloseDisplay */
|
||
|
static void
|
||
|
_cairo_xlib_surface_remove_scaled_font (cairo_xlib_display_t *display,
|
||
|
@@ -3599,16 +3600,20 @@ _cairo_xlib_surface_remove_scaled_font (
|
||
|
|
||
|
_cairo_scaled_font_reset_cache (scaled_font);
|
||
|
CAIRO_MUTEX_UNLOCK (scaled_font->mutex);
|
||
|
|
||
|
if (font_private != NULL) {
|
||
|
Display *dpy;
|
||
|
int i;
|
||
|
|
||
|
+ if (font_private->grayscale_font) {
|
||
|
+ cairo_scaled_font_destroy (font_private->grayscale_font);
|
||
|
+ }
|
||
|
+
|
||
|
dpy = _cairo_xlib_display_get_dpy (display);
|
||
|
for (i = 0; i < NUM_GLYPHSETS; i++) {
|
||
|
cairo_xlib_font_glyphset_info_t *glyphset_info;
|
||
|
|
||
|
glyphset_info = &font_private->glyphset_info[i];
|
||
|
if (glyphset_info->glyphset)
|
||
|
XRenderFreeGlyphSet (dpy, glyphset_info->glyphset);
|
||
|
|
||
|
@@ -3629,16 +3634,17 @@ _cairo_xlib_surface_font_init (Display
|
||
|
cairo_status_t status;
|
||
|
int i;
|
||
|
|
||
|
font_private = malloc (sizeof (cairo_xlib_surface_font_private_t));
|
||
|
if (unlikely (font_private == NULL))
|
||
|
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
|
||
|
|
||
|
font_private->scaled_font = scaled_font;
|
||
|
+ font_private->grayscale_font = NULL;
|
||
|
status = _cairo_xlib_display_get (dpy, &font_private->display);
|
||
|
if (unlikely (status)) {
|
||
|
free (font_private);
|
||
|
return status;
|
||
|
}
|
||
|
|
||
|
/* initialize and hook into the CloseDisplay callback */
|
||
|
font_private->close_display_hook.func =
|
||
|
@@ -3671,16 +3677,20 @@ _cairo_xlib_surface_scaled_font_fini (ca
|
||
|
{
|
||
|
cairo_xlib_surface_font_private_t *font_private;
|
||
|
|
||
|
font_private = scaled_font->surface_private;
|
||
|
if (font_private != NULL) {
|
||
|
cairo_xlib_display_t *display;
|
||
|
int i;
|
||
|
|
||
|
+ if (font_private->grayscale_font) {
|
||
|
+ cairo_scaled_font_destroy (font_private->grayscale_font);
|
||
|
+ }
|
||
|
+
|
||
|
display = font_private->display;
|
||
|
_cairo_xlib_remove_close_display_hook (display,
|
||
|
&font_private->close_display_hook);
|
||
|
|
||
|
for (i = 0; i < NUM_GLYPHSETS; i++) {
|
||
|
cairo_xlib_font_glyphset_info_t *glyphset_info;
|
||
|
|
||
|
glyphset_info = &font_private->glyphset_info[i];
|
||
|
@@ -4417,16 +4427,62 @@ _cairo_xlib_surface_owns_font (cairo_xli
|
||
|
(font_private != NULL && font_private->display != dst->display))
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
+/* Gets a grayscale version of scaled_font. The grayscale version is cached
|
||
|
+ * in our surface_private data.
|
||
|
+ */
|
||
|
+static cairo_scaled_font_t *
|
||
|
+_cairo_xlib_get_grayscale_font (cairo_xlib_surface_t *dst,
|
||
|
+ cairo_scaled_font_t *scaled_font)
|
||
|
+{
|
||
|
+ cairo_xlib_surface_font_private_t *font_private = scaled_font->surface_private;
|
||
|
+ cairo_bool_t needs_font;
|
||
|
+
|
||
|
+ if (font_private == NULL) {
|
||
|
+ cairo_status_t status = _cairo_xlib_surface_font_init (dst->dpy, scaled_font);
|
||
|
+ if (unlikely (status))
|
||
|
+ return _cairo_scaled_font_create_in_error (status);
|
||
|
+ font_private = scaled_font->surface_private;
|
||
|
+ }
|
||
|
+
|
||
|
+ CAIRO_MUTEX_LOCK (scaled_font->mutex);
|
||
|
+ needs_font = !font_private->grayscale_font;
|
||
|
+ CAIRO_MUTEX_UNLOCK (scaled_font->mutex);
|
||
|
+
|
||
|
+ if (needs_font) {
|
||
|
+ cairo_font_options_t options;
|
||
|
+ cairo_scaled_font_t *new_font;
|
||
|
+
|
||
|
+ options = scaled_font->options;
|
||
|
+ options.antialias = CAIRO_ANTIALIAS_GRAY;
|
||
|
+ new_font = cairo_scaled_font_create (scaled_font->font_face,
|
||
|
+ &scaled_font->font_matrix,
|
||
|
+ &scaled_font->ctm, &options);
|
||
|
+
|
||
|
+ CAIRO_MUTEX_LOCK (scaled_font->mutex);
|
||
|
+ if (!font_private->grayscale_font) {
|
||
|
+ font_private->grayscale_font = new_font;
|
||
|
+ new_font = NULL;
|
||
|
+ }
|
||
|
+ CAIRO_MUTEX_UNLOCK (scaled_font->mutex);
|
||
|
+
|
||
|
+ if (new_font) {
|
||
|
+ cairo_scaled_font_destroy (new_font);
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+ return font_private->grayscale_font;
|
||
|
+}
|
||
|
+
|
||
|
static cairo_int_status_t
|
||
|
_cairo_xlib_surface_show_glyphs (void *abstract_dst,
|
||
|
cairo_operator_t op,
|
||
|
const cairo_pattern_t *src_pattern,
|
||
|
cairo_glyph_t *glyphs,
|
||
|
int num_glyphs,
|
||
|
cairo_scaled_font_t *scaled_font,
|
||
|
cairo_clip_t *clip,
|
||
|
@@ -4475,16 +4531,21 @@ _cairo_xlib_surface_show_glyphs (void
|
||
|
|
||
|
operation = _categorize_composite_operation (dst, op, src_pattern, TRUE);
|
||
|
if (operation == DO_UNSUPPORTED)
|
||
|
return UNSUPPORTED ("unsupported op");
|
||
|
|
||
|
if (! _cairo_xlib_surface_owns_font (dst, scaled_font))
|
||
|
return UNSUPPORTED ("unowned font");
|
||
|
|
||
|
+ if (!dst->base.permit_subpixel_antialiasing &&
|
||
|
+ scaled_font->options.antialias == CAIRO_ANTIALIAS_SUBPIXEL) {
|
||
|
+ scaled_font = _cairo_xlib_get_grayscale_font (dst, scaled_font);
|
||
|
+ }
|
||
|
+
|
||
|
X_DEBUG ((dst->dpy, "show_glyphs (dst=%x)", (unsigned int) dst->drawable));
|
||
|
|
||
|
if (clip_region != NULL &&
|
||
|
cairo_region_num_rectangles (clip_region) == 1)
|
||
|
{
|
||
|
cairo_rectangle_int_t glyph_extents;
|
||
|
const cairo_rectangle_int_t *clip_extents;
|
||
|
|
||
|
diff --git a/gfx/cairo/cairo/src/cairo.h b/gfx/cairo/cairo/src/cairo.h
|
||
|
--- a/gfx/cairo/cairo/src/cairo.h
|
||
|
+++ b/gfx/cairo/cairo/src/cairo.h
|
||
|
@@ -2101,16 +2101,35 @@ cairo_public void
|
||
|
cairo_surface_copy_page (cairo_surface_t *surface);
|
||
|
|
||
|
cairo_public void
|
||
|
cairo_surface_show_page (cairo_surface_t *surface);
|
||
|
|
||
|
cairo_public cairo_bool_t
|
||
|
cairo_surface_has_show_text_glyphs (cairo_surface_t *surface);
|
||
|
|
||
|
+/**
|
||
|
+ * _cairo_subpixel_antialiasing_t:
|
||
|
+ * @CAIRO_SUBPIXEL_ANTIALIASING_ENABLED: subpixel antialiasing is enabled
|
||
|
+ * for this surface.
|
||
|
+ * @CAIRO_SUBPIXEL_ANTIALIASING_DISABLED: subpixel antialiasing is disabled
|
||
|
+ * for this surface.
|
||
|
+ */
|
||
|
+typedef enum _cairo_subpixel_antialiasing_t {
|
||
|
+ CAIRO_SUBPIXEL_ANTIALIASING_ENABLED,
|
||
|
+ CAIRO_SUBPIXEL_ANTIALIASING_DISABLED
|
||
|
+} cairo_subpixel_antialiasing_t;
|
||
|
+
|
||
|
+cairo_public void
|
||
|
+cairo_surface_set_subpixel_antialiasing (cairo_surface_t *surface,
|
||
|
+ cairo_subpixel_antialiasing_t enabled);
|
||
|
+
|
||
|
+cairo_public cairo_subpixel_antialiasing_t
|
||
|
+cairo_surface_get_subpixel_antialiasing (cairo_surface_t *surface);
|
||
|
+
|
||
|
/* Image-surface functions */
|
||
|
|
||
|
/**
|
||
|
* cairo_format_t:
|
||
|
* @CAIRO_FORMAT_ARGB32: each pixel is a 32-bit quantity, with
|
||
|
* alpha in the upper 8 bits, then red, then green, then blue.
|
||
|
* The 32-bit quantities are stored native-endian. Pre-multiplied
|
||
|
* alpha is used. (That is, 50% transparent red is 0x80800000,
|
||
|
diff --git a/gfx/cairo/cairo/src/cairoint.h b/gfx/cairo/cairo/src/cairoint.h
|
||
|
--- a/gfx/cairo/cairo/src/cairoint.h
|
||
|
+++ b/gfx/cairo/cairo/src/cairoint.h
|
||
|
@@ -2750,16 +2750,18 @@ slim_hidden_proto (cairo_surface_destroy
|
||
|
slim_hidden_proto (cairo_surface_finish);
|
||
|
slim_hidden_proto (cairo_surface_flush);
|
||
|
slim_hidden_proto (cairo_surface_get_content);
|
||
|
slim_hidden_proto (cairo_surface_get_device_offset);
|
||
|
slim_hidden_proto (cairo_surface_get_font_options);
|
||
|
slim_hidden_proto (cairo_surface_get_mime_data);
|
||
|
slim_hidden_proto (cairo_surface_get_type);
|
||
|
slim_hidden_proto (cairo_surface_has_show_text_glyphs);
|
||
|
+slim_hidden_proto (cairo_surface_set_subpixel_antialiasing);
|
||
|
+slim_hidden_proto (cairo_surface_get_subpixel_antialiasing);
|
||
|
slim_hidden_proto (cairo_surface_mark_dirty_rectangle);
|
||
|
slim_hidden_proto_no_warn (cairo_surface_reference);
|
||
|
slim_hidden_proto (cairo_surface_set_device_offset);
|
||
|
slim_hidden_proto (cairo_surface_set_fallback_resolution);
|
||
|
slim_hidden_proto (cairo_surface_set_mime_data);
|
||
|
slim_hidden_proto (cairo_surface_show_page);
|
||
|
slim_hidden_proto (cairo_surface_status);
|
||
|
slim_hidden_proto (cairo_text_cluster_allocate);
|