The Tor Browser / file comparison
comparison: gfx/cairo/disable-subpixel-antialiasing.patch
gfx/cairo/disable-subpixel-antialiasing.patch
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:87fb03d4af9c |
|---|---|
| 1 # HG changeset patch | |
| 2 # User Robert O'Callahan <robert@ocallahan.org> | |
| 3 # Date 1294019288 -46800 | |
| 4 # Node ID 8857392e37aea7475ed6d8ee4b45023e1233bcec | |
| 5 # Parent c53f60831c43cca397dfed8adf8d350aeec7d3ca | |
| 6 Bug 363861. Part 2: Introduce cairo_surface_get/set_subpixel_antialiasing. r=jrmuizel,sr=vlad,a=blocking | |
| 7 | |
| 8 diff --git a/gfx/cairo/cairo/src/cairo-quartz-surface.c b/gfx/cairo/cairo/src/cairo-quartz-surface.c | |
| 9 --- a/gfx/cairo/cairo/src/cairo-quartz-surface.c | |
| 10 +++ b/gfx/cairo/cairo/src/cairo-quartz-surface.c | |
| 11 @@ -2473,16 +2473,17 @@ _cairo_quartz_surface_show_glyphs (void | |
| 12 cairo_int_status_t rv = CAIRO_STATUS_SUCCESS; | |
| 13 cairo_quartz_drawing_state_t state; | |
| 14 float xprev, yprev; | |
| 15 int i; | |
| 16 CGFontRef cgfref = NULL; | |
| 17 | |
| 18 cairo_bool_t isClipping = FALSE; | |
| 19 cairo_bool_t didForceFontSmoothing = FALSE; | |
| 20 + cairo_antialias_t effective_antialiasing; | |
| 21 | |
| 22 if (IS_EMPTY(surface)) | |
| 23 return CAIRO_STATUS_SUCCESS; | |
| 24 | |
| 25 if (num_glyphs <= 0) | |
| 26 return CAIRO_STATUS_SUCCESS; | |
| 27 | |
| 28 if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_QUARTZ) | |
| 29 @@ -2514,16 +2515,22 @@ _cairo_quartz_surface_show_glyphs (void | |
| 30 goto BAIL; | |
| 31 } | |
| 32 | |
| 33 /* this doesn't addref */ | |
| 34 cgfref = _cairo_quartz_scaled_font_get_cg_font_ref (scaled_font); | |
| 35 CGContextSetFont (state.context, cgfref); | |
| 36 CGContextSetFontSize (state.context, 1.0); | |
| 37 | |
| 38 + effective_antialiasing = scaled_font->options.antialias; | |
| 39 + if (effective_antialiasing == CAIRO_ANTIALIAS_SUBPIXEL && | |
| 40 + !surface->base.permit_subpixel_antialiasing) { | |
| 41 + effective_antialiasing = CAIRO_ANTIALIAS_GRAY; | |
| 42 + } | |
| 43 + | |
| 44 switch (scaled_font->options.antialias) { | |
| 45 case CAIRO_ANTIALIAS_SUBPIXEL: | |
| 46 CGContextSetShouldAntialias (state.context, TRUE); | |
| 47 CGContextSetShouldSmoothFonts (state.context, TRUE); | |
| 48 if (CGContextSetAllowsFontSmoothingPtr && | |
| 49 !CGContextGetAllowsFontSmoothingPtr (state.context)) | |
| 50 { | |
| 51 didForceFontSmoothing = TRUE; | |
| 52 diff --git a/gfx/cairo/cairo/src/cairo-surface-private.h b/gfx/cairo/cairo/src/cairo-surface-private.h | |
| 53 --- a/gfx/cairo/cairo/src/cairo-surface-private.h | |
| 54 +++ b/gfx/cairo/cairo/src/cairo-surface-private.h | |
| 55 @@ -58,16 +58,17 @@ struct _cairo_surface { | |
| 56 | |
| 57 cairo_reference_count_t ref_count; | |
| 58 cairo_status_t status; | |
| 59 unsigned int unique_id; | |
| 60 | |
| 61 unsigned finished : 1; | |
| 62 unsigned is_clear : 1; | |
| 63 unsigned has_font_options : 1; | |
| 64 + unsigned permit_subpixel_antialiasing : 1; | |
| 65 | |
| 66 cairo_user_data_array_t user_data; | |
| 67 cairo_user_data_array_t mime_data; | |
| 68 | |
| 69 cairo_matrix_t device_transform; | |
| 70 cairo_matrix_t device_transform_inverse; | |
| 71 | |
| 72 /* The actual resolution of the device, in dots per inch. */ | |
| 73 diff --git a/gfx/cairo/cairo/src/cairo-surface.c b/gfx/cairo/cairo/src/cairo-surface.c | |
| 74 --- a/gfx/cairo/cairo/src/cairo-surface.c | |
| 75 +++ b/gfx/cairo/cairo/src/cairo-surface.c | |
| 76 @@ -49,17 +49,18 @@ const cairo_surface_t name = { \ | |
| 77 NULL, /* backend */ \ | |
| 78 CAIRO_SURFACE_TYPE_IMAGE, /* type */ \ | |
| 79 CAIRO_CONTENT_COLOR, /* content */ \ | |
| 80 CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ \ | |
| 81 status, /* status */ \ | |
| 82 0, /* unique id */ \ | |
| 83 FALSE, /* finished */ \ | |
| 84 TRUE, /* is_clear */ \ | |
| 85 - FALSE, /* has_font_options */ \ | |
| 86 + FALSE, /* has_font_options */ \ | |
| 87 + FALSE, /* permit_subpixel_antialiasing */ \ | |
| 88 { 0, 0, 0, NULL, }, /* user_data */ \ | |
| 89 { 0, 0, 0, NULL, }, /* mime_data */ \ | |
| 90 { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 }, /* device_transform */ \ | |
| 91 { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 }, /* device_transform_inverse */ \ | |
| 92 0.0, /* x_resolution */ \ | |
| 93 0.0, /* y_resolution */ \ | |
| 94 0.0, /* x_fallback_resolution */ \ | |
| 95 0.0, /* y_fallback_resolution */ \ | |
| 96 @@ -342,46 +343,48 @@ _cairo_surface_init (cairo_surface_t * | |
| 97 surface->content = content; | |
| 98 surface->type = backend->type; | |
| 99 | |
| 100 CAIRO_REFERENCE_COUNT_INIT (&surface->ref_count, 1); | |
| 101 surface->status = CAIRO_STATUS_SUCCESS; | |
| 102 surface->unique_id = _cairo_surface_allocate_unique_id (); | |
| 103 surface->finished = FALSE; | |
| 104 surface->is_clear = FALSE; | |
| 105 + surface->has_font_options = FALSE; | |
| 106 + surface->permit_subpixel_antialiasing = TRUE; | |
| 107 | |
| 108 _cairo_user_data_array_init (&surface->user_data); | |
| 109 _cairo_user_data_array_init (&surface->mime_data); | |
| 110 | |
| 111 cairo_matrix_init_identity (&surface->device_transform); | |
| 112 cairo_matrix_init_identity (&surface->device_transform_inverse); | |
| 113 | |
| 114 surface->x_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT; | |
| 115 surface->y_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT; | |
| 116 | |
| 117 surface->x_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT; | |
| 118 surface->y_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT; | |
| 119 | |
| 120 _cairo_array_init (&surface->snapshots, sizeof (cairo_surface_t *)); | |
| 121 surface->snapshot_of = NULL; | |
| 122 - | |
| 123 - surface->has_font_options = FALSE; | |
| 124 } | |
| 125 | |
| 126 static void | |
| 127 _cairo_surface_copy_similar_properties (cairo_surface_t *surface, | |
| 128 cairo_surface_t *other) | |
| 129 { | |
| 130 if (other->has_font_options || other->backend != surface->backend) { | |
| 131 cairo_font_options_t options; | |
| 132 | |
| 133 cairo_surface_get_font_options (other, &options); | |
| 134 _cairo_surface_set_font_options (surface, &options); | |
| 135 } | |
| 136 | |
| 137 + surface->permit_subpixel_antialiasing = other->permit_subpixel_antialiasing; | |
| 138 + | |
| 139 cairo_surface_set_fallback_resolution (surface, | |
| 140 other->x_fallback_resolution, | |
| 141 other->y_fallback_resolution); | |
| 142 } | |
| 143 | |
| 144 cairo_surface_t * | |
| 145 _cairo_surface_create_similar_scratch (cairo_surface_t *other, | |
| 146 cairo_content_t content, | |
| 147 @@ -2482,16 +2485,67 @@ cairo_surface_has_show_text_glyphs (cair | |
| 148 | |
| 149 if (surface->backend->has_show_text_glyphs) | |
| 150 return surface->backend->has_show_text_glyphs (surface); | |
| 151 else | |
| 152 return surface->backend->show_text_glyphs != NULL; | |
| 153 } | |
| 154 slim_hidden_def (cairo_surface_has_show_text_glyphs); | |
| 155 | |
| 156 +/** | |
| 157 + * cairo_surface_set_subpixel_antialiasing: | |
| 158 + * @surface: a #cairo_surface_t | |
| 159 + * | |
| 160 + * Sets whether the surface permits subpixel antialiasing. By default, | |
| 161 + * surfaces permit subpixel antialiasing. | |
| 162 + * | |
| 163 + * Enabling subpixel antialiasing for CONTENT_COLOR_ALPHA surfaces generally | |
| 164 + * requires that the pixels in the areas under a subpixel antialiasing | |
| 165 + * operation already be opaque. | |
| 166 + * | |
| 167 + * Since: 1.12 | |
| 168 + **/ | |
| 169 +void | |
| 170 +cairo_surface_set_subpixel_antialiasing (cairo_surface_t *surface, | |
| 171 + cairo_subpixel_antialiasing_t enabled) | |
| 172 +{ | |
| 173 + if (surface->status) | |
| 174 + return; | |
| 175 + | |
| 176 + if (surface->finished) { | |
| 177 + _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); | |
| 178 + return; | |
| 179 + } | |
| 180 + | |
| 181 + surface->permit_subpixel_antialiasing = | |
| 182 + enabled == CAIRO_SUBPIXEL_ANTIALIASING_ENABLED; | |
| 183 +} | |
| 184 +slim_hidden_def (cairo_surface_set_subpixel_antialiasing); | |
| 185 + | |
| 186 +/** | |
| 187 + * cairo_surface_get_subpixel_antialiasing: | |
| 188 + * @surface: a #cairo_surface_t | |
| 189 + * | |
| 190 + * Gets whether the surface supports subpixel antialiasing. By default, | |
| 191 + * CAIRO_CONTENT_COLOR surfaces support subpixel antialiasing but other | |
| 192 + * surfaces do not. | |
| 193 + * | |
| 194 + * Since: 1.12 | |
| 195 + **/ | |
| 196 +cairo_subpixel_antialiasing_t | |
| 197 +cairo_surface_get_subpixel_antialiasing (cairo_surface_t *surface) | |
| 198 +{ | |
| 199 + if (surface->status) | |
| 200 + return CAIRO_SUBPIXEL_ANTIALIASING_DISABLED; | |
| 201 + | |
| 202 + return surface->permit_subpixel_antialiasing ? | |
| 203 + CAIRO_SUBPIXEL_ANTIALIASING_ENABLED : CAIRO_SUBPIXEL_ANTIALIASING_DISABLED; | |
| 204 +} | |
| 205 +slim_hidden_def (cairo_surface_get_subpixel_antialiasing); | |
| 206 + | |
| 207 /* Note: the backends may modify the contents of the glyph array as long as | |
| 208 * they do not return %CAIRO_INT_STATUS_UNSUPPORTED. This makes it possible to | |
| 209 * avoid copying the array again and again, and edit it in-place. | |
| 210 * Backends are in fact free to use the array as a generic buffer as they | |
| 211 * see fit. | |
| 212 * | |
| 213 * For show_glyphs backend method, and NOT for show_text_glyphs method, | |
| 214 * when they do return UNSUPPORTED, they may adjust remaining_glyphs to notify | |
| 215 diff --git a/gfx/cairo/cairo/src/cairo-win32-font.c b/gfx/cairo/cairo/src/cairo-win32-font.c | |
| 216 --- a/gfx/cairo/cairo/src/cairo-win32-font.c | |
| 217 +++ b/gfx/cairo/cairo/src/cairo-win32-font.c | |
| 218 @@ -1380,16 +1380,17 @@ _cairo_win32_scaled_font_show_glyphs (vo | |
| 219 cairo_win32_surface_t *surface = (cairo_win32_surface_t *)generic_surface; | |
| 220 cairo_status_t status; | |
| 221 | |
| 222 if (width == 0 || height == 0) | |
| 223 return CAIRO_STATUS_SUCCESS; | |
| 224 | |
| 225 if (_cairo_surface_is_win32 (generic_surface) && | |
| 226 surface->format == CAIRO_FORMAT_RGB24 && | |
| 227 + (generic_surface->permit_subpixel_antialiasing || scaled_font->quality != CLEARTYPE_QUALITY) && | |
| 228 op == CAIRO_OPERATOR_OVER && | |
| 229 _cairo_pattern_is_opaque_solid (pattern)) { | |
| 230 | |
| 231 cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)pattern; | |
| 232 | |
| 233 /* When compositing OVER on a GDI-understood surface, with a | |
| 234 * solid opaque color, we can just call ExtTextOut directly. | |
| 235 */ | |
| 236 @@ -1411,16 +1412,18 @@ _cairo_win32_scaled_font_show_glyphs (vo | |
| 237 * surface by drawing the the glyphs onto a DIB, black-on-white then | |
| 238 * inverting. GDI outputs gamma-corrected images so inverted black-on-white | |
| 239 * is very different from white-on-black. We favor the more common | |
| 240 * case where the final output is dark-on-light. | |
| 241 */ | |
| 242 cairo_win32_surface_t *tmp_surface; | |
| 243 cairo_surface_t *mask_surface; | |
| 244 cairo_surface_pattern_t mask; | |
| 245 + cairo_bool_t use_subpixel_antialiasing = | |
| 246 + scaled_font->quality == CLEARTYPE_QUALITY && generic_surface->permit_subpixel_antialiasing; | |
| 247 RECT r; | |
| 248 | |
| 249 tmp_surface = (cairo_win32_surface_t *)cairo_win32_surface_create_with_dib (CAIRO_FORMAT_ARGB32, width, height); | |
| 250 if (tmp_surface->base.status) | |
| 251 return tmp_surface->base.status; | |
| 252 | |
| 253 r.left = 0; | |
| 254 r.top = 0; | |
| 255 @@ -1432,17 +1435,17 @@ _cairo_win32_scaled_font_show_glyphs (vo | |
| 256 scaled_font, RGB (0, 0, 0), | |
| 257 dest_x, dest_y, | |
| 258 glyphs, num_glyphs); | |
| 259 if (status) { | |
| 260 cairo_surface_destroy (&tmp_surface->base); | |
| 261 return status; | |
| 262 } | |
| 263 | |
| 264 - if (scaled_font->quality == CLEARTYPE_QUALITY) { | |
| 265 + if (use_subpixel_antialiasing) { | |
| 266 /* For ClearType, we need a 4-channel mask. If we are compositing on | |
| 267 * a surface with alpha, we need to compute the alpha channel of | |
| 268 * the mask (we just copy the green channel). But for a destination | |
| 269 * surface without alpha the alpha channel of the mask is ignored | |
| 270 */ | |
| 271 | |
| 272 if (surface->format != CAIRO_FORMAT_RGB24) | |
| 273 _compute_argb32_mask_alpha (tmp_surface); | |
| 274 @@ -1460,17 +1463,17 @@ _cairo_win32_scaled_font_show_glyphs (vo | |
| 275 | |
| 276 /* For op == OVER, no-cleartype, a possible optimization here is to | |
| 277 * draw onto an intermediate ARGB32 surface and alpha-blend that with the | |
| 278 * destination | |
| 279 */ | |
| 280 _cairo_pattern_init_for_surface (&mask, mask_surface); | |
| 281 cairo_surface_destroy (mask_surface); | |
| 282 | |
| 283 - if (scaled_font->quality == CLEARTYPE_QUALITY) | |
| 284 + if (use_subpixel_antialiasing) | |
| 285 mask.base.has_component_alpha = TRUE; | |
| 286 | |
| 287 status = _cairo_surface_composite (op, pattern, | |
| 288 &mask.base, | |
| 289 &surface->base, | |
| 290 source_x, source_y, | |
| 291 0, 0, | |
| 292 dest_x, dest_y, | |
| 293 diff --git a/gfx/cairo/cairo/src/cairo-xlib-surface.c b/gfx/cairo/cairo/src/cairo-xlib-surface.c | |
| 294 --- a/gfx/cairo/cairo/src/cairo-xlib-surface.c | |
| 295 +++ b/gfx/cairo/cairo/src/cairo-xlib-surface.c | |
| 296 @@ -3570,16 +3570,17 @@ typedef struct _cairo_xlib_font_glyphset | |
| 297 GlyphSet glyphset; | |
| 298 cairo_format_t format; | |
| 299 XRenderPictFormat *xrender_format; | |
| 300 cairo_xlib_font_glyphset_free_glyphs_t *pending_free_glyphs; | |
| 301 } cairo_xlib_font_glyphset_info_t; | |
| 302 | |
| 303 typedef struct _cairo_xlib_surface_font_private { | |
| 304 cairo_scaled_font_t *scaled_font; | |
| 305 + cairo_scaled_font_t *grayscale_font; | |
| 306 cairo_xlib_hook_t close_display_hook; | |
| 307 cairo_xlib_display_t *display; | |
| 308 cairo_xlib_font_glyphset_info_t glyphset_info[NUM_GLYPHSETS]; | |
| 309 } cairo_xlib_surface_font_private_t; | |
| 310 | |
| 311 /* callback from CloseDisplay */ | |
| 312 static void | |
| 313 _cairo_xlib_surface_remove_scaled_font (cairo_xlib_display_t *display, | |
| 314 @@ -3599,16 +3600,20 @@ _cairo_xlib_surface_remove_scaled_font ( | |
| 315 | |
| 316 _cairo_scaled_font_reset_cache (scaled_font); | |
| 317 CAIRO_MUTEX_UNLOCK (scaled_font->mutex); | |
| 318 | |
| 319 if (font_private != NULL) { | |
| 320 Display *dpy; | |
| 321 int i; | |
| 322 | |
| 323 + if (font_private->grayscale_font) { | |
| 324 + cairo_scaled_font_destroy (font_private->grayscale_font); | |
| 325 + } | |
| 326 + | |
| 327 dpy = _cairo_xlib_display_get_dpy (display); | |
| 328 for (i = 0; i < NUM_GLYPHSETS; i++) { | |
| 329 cairo_xlib_font_glyphset_info_t *glyphset_info; | |
| 330 | |
| 331 glyphset_info = &font_private->glyphset_info[i]; | |
| 332 if (glyphset_info->glyphset) | |
| 333 XRenderFreeGlyphSet (dpy, glyphset_info->glyphset); | |
| 334 | |
| 335 @@ -3629,16 +3634,17 @@ _cairo_xlib_surface_font_init (Display | |
| 336 cairo_status_t status; | |
| 337 int i; | |
| 338 | |
| 339 font_private = malloc (sizeof (cairo_xlib_surface_font_private_t)); | |
| 340 if (unlikely (font_private == NULL)) | |
| 341 return _cairo_error (CAIRO_STATUS_NO_MEMORY); | |
| 342 | |
| 343 font_private->scaled_font = scaled_font; | |
| 344 + font_private->grayscale_font = NULL; | |
| 345 status = _cairo_xlib_display_get (dpy, &font_private->display); | |
| 346 if (unlikely (status)) { | |
| 347 free (font_private); | |
| 348 return status; | |
| 349 } | |
| 350 | |
| 351 /* initialize and hook into the CloseDisplay callback */ | |
| 352 font_private->close_display_hook.func = | |
| 353 @@ -3671,16 +3677,20 @@ _cairo_xlib_surface_scaled_font_fini (ca | |
| 354 { | |
| 355 cairo_xlib_surface_font_private_t *font_private; | |
| 356 | |
| 357 font_private = scaled_font->surface_private; | |
| 358 if (font_private != NULL) { | |
| 359 cairo_xlib_display_t *display; | |
| 360 int i; | |
| 361 | |
| 362 + if (font_private->grayscale_font) { | |
| 363 + cairo_scaled_font_destroy (font_private->grayscale_font); | |
| 364 + } | |
| 365 + | |
| 366 display = font_private->display; | |
| 367 _cairo_xlib_remove_close_display_hook (display, | |
| 368 &font_private->close_display_hook); | |
| 369 | |
| 370 for (i = 0; i < NUM_GLYPHSETS; i++) { | |
| 371 cairo_xlib_font_glyphset_info_t *glyphset_info; | |
| 372 | |
| 373 glyphset_info = &font_private->glyphset_info[i]; | |
| 374 @@ -4417,16 +4427,62 @@ _cairo_xlib_surface_owns_font (cairo_xli | |
| 375 (font_private != NULL && font_private->display != dst->display)) | |
| 376 { | |
| 377 return FALSE; | |
| 378 } | |
| 379 | |
| 380 return TRUE; | |
| 381 } | |
| 382 | |
| 383 +/* Gets a grayscale version of scaled_font. The grayscale version is cached | |
| 384 + * in our surface_private data. | |
| 385 + */ | |
| 386 +static cairo_scaled_font_t * | |
| 387 +_cairo_xlib_get_grayscale_font (cairo_xlib_surface_t *dst, | |
| 388 + cairo_scaled_font_t *scaled_font) | |
| 389 +{ | |
| 390 + cairo_xlib_surface_font_private_t *font_private = scaled_font->surface_private; | |
| 391 + cairo_bool_t needs_font; | |
| 392 + | |
| 393 + if (font_private == NULL) { | |
| 394 + cairo_status_t status = _cairo_xlib_surface_font_init (dst->dpy, scaled_font); | |
| 395 + if (unlikely (status)) | |
| 396 + return _cairo_scaled_font_create_in_error (status); | |
| 397 + font_private = scaled_font->surface_private; | |
| 398 + } | |
| 399 + | |
| 400 + CAIRO_MUTEX_LOCK (scaled_font->mutex); | |
| 401 + needs_font = !font_private->grayscale_font; | |
| 402 + CAIRO_MUTEX_UNLOCK (scaled_font->mutex); | |
| 403 + | |
| 404 + if (needs_font) { | |
| 405 + cairo_font_options_t options; | |
| 406 + cairo_scaled_font_t *new_font; | |
| 407 + | |
| 408 + options = scaled_font->options; | |
| 409 + options.antialias = CAIRO_ANTIALIAS_GRAY; | |
| 410 + new_font = cairo_scaled_font_create (scaled_font->font_face, | |
| 411 + &scaled_font->font_matrix, | |
| 412 + &scaled_font->ctm, &options); | |
| 413 + | |
| 414 + CAIRO_MUTEX_LOCK (scaled_font->mutex); | |
| 415 + if (!font_private->grayscale_font) { | |
| 416 + font_private->grayscale_font = new_font; | |
| 417 + new_font = NULL; | |
| 418 + } | |
| 419 + CAIRO_MUTEX_UNLOCK (scaled_font->mutex); | |
| 420 + | |
| 421 + if (new_font) { | |
| 422 + cairo_scaled_font_destroy (new_font); | |
| 423 + } | |
| 424 + } | |
| 425 + | |
| 426 + return font_private->grayscale_font; | |
| 427 +} | |
| 428 + | |
| 429 static cairo_int_status_t | |
| 430 _cairo_xlib_surface_show_glyphs (void *abstract_dst, | |
| 431 cairo_operator_t op, | |
| 432 const cairo_pattern_t *src_pattern, | |
| 433 cairo_glyph_t *glyphs, | |
| 434 int num_glyphs, | |
| 435 cairo_scaled_font_t *scaled_font, | |
| 436 cairo_clip_t *clip, | |
| 437 @@ -4475,16 +4531,21 @@ _cairo_xlib_surface_show_glyphs (void | |
| 438 | |
| 439 operation = _categorize_composite_operation (dst, op, src_pattern, TRUE); | |
| 440 if (operation == DO_UNSUPPORTED) | |
| 441 return UNSUPPORTED ("unsupported op"); | |
| 442 | |
| 443 if (! _cairo_xlib_surface_owns_font (dst, scaled_font)) | |
| 444 return UNSUPPORTED ("unowned font"); | |
| 445 | |
| 446 + if (!dst->base.permit_subpixel_antialiasing && | |
| 447 + scaled_font->options.antialias == CAIRO_ANTIALIAS_SUBPIXEL) { | |
| 448 + scaled_font = _cairo_xlib_get_grayscale_font (dst, scaled_font); | |
| 449 + } | |
| 450 + | |
| 451 X_DEBUG ((dst->dpy, "show_glyphs (dst=%x)", (unsigned int) dst->drawable)); | |
| 452 | |
| 453 if (clip_region != NULL && | |
| 454 cairo_region_num_rectangles (clip_region) == 1) | |
| 455 { | |
| 456 cairo_rectangle_int_t glyph_extents; | |
| 457 const cairo_rectangle_int_t *clip_extents; | |
| 458 | |
| 459 diff --git a/gfx/cairo/cairo/src/cairo.h b/gfx/cairo/cairo/src/cairo.h | |
| 460 --- a/gfx/cairo/cairo/src/cairo.h | |
| 461 +++ b/gfx/cairo/cairo/src/cairo.h | |
| 462 @@ -2101,16 +2101,35 @@ cairo_public void | |
| 463 cairo_surface_copy_page (cairo_surface_t *surface); | |
| 464 | |
| 465 cairo_public void | |
| 466 cairo_surface_show_page (cairo_surface_t *surface); | |
| 467 | |
| 468 cairo_public cairo_bool_t | |
| 469 cairo_surface_has_show_text_glyphs (cairo_surface_t *surface); | |
| 470 | |
| 471 +/** | |
| 472 + * _cairo_subpixel_antialiasing_t: | |
| 473 + * @CAIRO_SUBPIXEL_ANTIALIASING_ENABLED: subpixel antialiasing is enabled | |
| 474 + * for this surface. | |
| 475 + * @CAIRO_SUBPIXEL_ANTIALIASING_DISABLED: subpixel antialiasing is disabled | |
| 476 + * for this surface. | |
| 477 + */ | |
| 478 +typedef enum _cairo_subpixel_antialiasing_t { | |
| 479 + CAIRO_SUBPIXEL_ANTIALIASING_ENABLED, | |
| 480 + CAIRO_SUBPIXEL_ANTIALIASING_DISABLED | |
| 481 +} cairo_subpixel_antialiasing_t; | |
| 482 + | |
| 483 +cairo_public void | |
| 484 +cairo_surface_set_subpixel_antialiasing (cairo_surface_t *surface, | |
| 485 + cairo_subpixel_antialiasing_t enabled); | |
| 486 + | |
| 487 +cairo_public cairo_subpixel_antialiasing_t | |
| 488 +cairo_surface_get_subpixel_antialiasing (cairo_surface_t *surface); | |
| 489 + | |
| 490 /* Image-surface functions */ | |
| 491 | |
| 492 /** | |
| 493 * cairo_format_t: | |
| 494 * @CAIRO_FORMAT_ARGB32: each pixel is a 32-bit quantity, with | |
| 495 * alpha in the upper 8 bits, then red, then green, then blue. | |
| 496 * The 32-bit quantities are stored native-endian. Pre-multiplied | |
| 497 * alpha is used. (That is, 50% transparent red is 0x80800000, | |
| 498 diff --git a/gfx/cairo/cairo/src/cairoint.h b/gfx/cairo/cairo/src/cairoint.h | |
| 499 --- a/gfx/cairo/cairo/src/cairoint.h | |
| 500 +++ b/gfx/cairo/cairo/src/cairoint.h | |
| 501 @@ -2750,16 +2750,18 @@ slim_hidden_proto (cairo_surface_destroy | |
| 502 slim_hidden_proto (cairo_surface_finish); | |
| 503 slim_hidden_proto (cairo_surface_flush); | |
| 504 slim_hidden_proto (cairo_surface_get_content); | |
| 505 slim_hidden_proto (cairo_surface_get_device_offset); | |
| 506 slim_hidden_proto (cairo_surface_get_font_options); | |
| 507 slim_hidden_proto (cairo_surface_get_mime_data); | |
| 508 slim_hidden_proto (cairo_surface_get_type); | |
| 509 slim_hidden_proto (cairo_surface_has_show_text_glyphs); | |
| 510 +slim_hidden_proto (cairo_surface_set_subpixel_antialiasing); | |
| 511 +slim_hidden_proto (cairo_surface_get_subpixel_antialiasing); | |
| 512 slim_hidden_proto (cairo_surface_mark_dirty_rectangle); | |
| 513 slim_hidden_proto_no_warn (cairo_surface_reference); | |
| 514 slim_hidden_proto (cairo_surface_set_device_offset); | |
| 515 slim_hidden_proto (cairo_surface_set_fallback_resolution); | |
| 516 slim_hidden_proto (cairo_surface_set_mime_data); | |
| 517 slim_hidden_proto (cairo_surface_show_page); | |
| 518 slim_hidden_proto (cairo_surface_status); | |
| 519 slim_hidden_proto (cairo_text_cluster_allocate); |
