src/win32/cairo-win32-gdi-compositor.c

   1 /* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
   2 /* cairo - a vector graphics library with display and print output
   3  *
   4  * Copyright © 2012 Intel Corporation
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it either under the terms of the GNU Lesser General Public
   8  * License version 2.1 as published by the Free Software Foundation
   9  * (the "LGPL") or, at your option, under the terms of the Mozilla
  10  * Public License Version 1.1 (the "MPL"). If you do not alter this
  11  * notice, a recipient may use your version of this file under either
  12  * the MPL or the LGPL.
  13  *
  14  * You should have received a copy of the LGPL along with this library
  15  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
  17  * You should have received a copy of the MPL along with this library
  18  * in the file COPYING-MPL-1.1
  19  *
  20  * The contents of this file are subject to the Mozilla Public License
  21  * Version 1.1 (the "License"); you may not use this file except in
  22  * compliance with the License. You may obtain a copy of the License at
  23  * http://www.mozilla.org/MPL/
  24  *
  25  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  26  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  27  * the specific language governing rights and limitations.
  28  *
  29  * The Original Code is the cairo graphics library.
  30  *
  31  * The Initial Developer of the Original Code is University of Southern
  32  * California.
  33  *
  34  * Contributor(s):
  35  *      Carl D. Worth <cworth@cworth.org>
  36  *      Behdad Esfahbod <behdad@behdad.org>
  37  *      Chris Wilson <chris@chris-wilson.co.uk>
  38  *      Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation
  39  */
  40
  41 /* The original X drawing API was very restrictive in what it could handle,
  42  * pixel-aligned fill/blits are all that map into Cairo's drawing model.
  43  */
  44
  45 #include "cairoint.h"
  46
  47 #include "cairo-win32-private.h"
  48
  49 #include "cairo-boxes-private.h"
  50 #include "cairo-clip-inline.h"
  51 #include "cairo-compositor-private.h"
  52 #include "cairo-image-surface-private.h"
  53 #include "cairo-pattern-private.h"
  54 #include "cairo-region-private.h"
  55 #include "cairo-surface-inline.h"
  56 #include "cairo-surface-offset-private.h"
  57
  58 #if !defined(AC_SRC_OVER)
  59 #define AC_SRC_OVER                 0x00
  60 #pragma pack(1)
  61 typedef struct {
  62     BYTE   BlendOp;
  63     BYTE   BlendFlags;
  64     BYTE   SourceConstantAlpha;
  65     BYTE   AlphaFormat;
  66 }BLENDFUNCTION;
  67 #pragma pack()
  68 #endif
  69
  70 /* for compatibility with VC++ 6 */
  71 #ifndef AC_SRC_ALPHA
  72 #define AC_SRC_ALPHA                0x01
  73 #endif
  74
  75 #define PELS_72DPI  ((LONG)(72. / 0.0254))
  76
  77 /* the low-level interface */
  78
  79 struct fill_box {
  80     HDC dc;
  81     HBRUSH brush;
  82 };
  83
  84 static cairo_bool_t fill_box (cairo_box_t *box, void *closure)
  85 {
  86     struct fill_box *fb = closure;
  87     RECT rect;
  88
  89     rect.left = _cairo_fixed_integer_part (box->p1.x);
  90     rect.top = _cairo_fixed_integer_part (box->p1.y);
  91     rect.right = _cairo_fixed_integer_part (box->p2.x);
  92     rect.bottom = _cairo_fixed_integer_part (box->p2.y);
  93
  94     TRACE ((stderr, "%s\n", __FUNCTION__));
  95     return FillRect (fb->dc, &rect, fb->brush);
  96 }
  97
  98 struct check_box {
  99     cairo_rectangle_int_t limit;
 100     int tx, ty;
 101 };
 102
 103 struct copy_box {
 104     cairo_rectangle_int_t limit;
 105     int tx, ty;
 106     HDC dst, src;
 107     BLENDFUNCTION bf;
 108     cairo_win32_alpha_blend_func_t alpha_blend;
 109 };
 110
 111 static cairo_bool_t copy_box (cairo_box_t *box, void *closure)
 112 {
 113     const struct copy_box *cb = closure;
 114     int x = _cairo_fixed_integer_part (box->p1.x);
 115     int y = _cairo_fixed_integer_part (box->p1.y);
 116     int width  = _cairo_fixed_integer_part (box->p2.x - box->p1.x);
 117     int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y);
 118
 119     TRACE ((stderr, "%s\n", __FUNCTION__));
 120     return BitBlt (cb->dst, x, y, width, height,
 121                    cb->src, x + cb->tx, y + cb->ty,
 122                    SRCCOPY);
 123 }
 124
 125 static cairo_bool_t alpha_box (cairo_box_t *box, void *closure)
 126 {
 127     const struct copy_box *cb = closure;
 128     int x = _cairo_fixed_integer_part (box->p1.x);
 129     int y = _cairo_fixed_integer_part (box->p1.y);
 130     int width  = _cairo_fixed_integer_part (box->p2.x - box->p1.x);
 131     int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y);
 132
 133     TRACE ((stderr, "%s\n", __FUNCTION__));
 134     return cb->alpha_blend (cb->dst, x, y, width, height,
 135                             cb->src, x + cb->tx, y + cb->ty, width, height,
 136                             cb->bf);
 137 }
 138
 139 struct upload_box {
 140     cairo_rectangle_int_t limit;
 141     int tx, ty;
 142     HDC dst;
 143     BITMAPINFO bi;
 144     void *data;
 145 };
 146
 147 static cairo_bool_t upload_box (cairo_box_t *box, void *closure)
 148 {
 149     const struct upload_box *cb = closure;
 150     int x = _cairo_fixed_integer_part (box->p1.x);
 151     int y = _cairo_fixed_integer_part (box->p1.y);
 152     int width  = _cairo_fixed_integer_part (box->p2.x - box->p1.x);
 153     int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y);
 154
 155     TRACE ((stderr, "%s\n", __FUNCTION__));
 156     return StretchDIBits (cb->dst, x, y + height - 1, width, -height,
 157                           x + cb->tx,  height - (y + cb->ty - 1),
 158                           width, -height,
 159                           cb->data, &cb->bi,
 160                           DIB_RGB_COLORS, SRCCOPY);
 161 }
 162
 163 /* the mid-level: converts boxes into drawing operations */
 164
 165 static COLORREF color_to_rgb(const cairo_color_t *c)
 166 {
 167     return RGB (c->red_short >> 8, c->green_short >> 8, c->blue_short >> 8);
 168 }
 169
 170 static cairo_int_status_t
 171 fill_boxes (cairo_win32_display_surface_t       *dst,
 172             const cairo_pattern_t               *src,
 173             cairo_boxes_t                       *boxes)
 174 {
 175     const cairo_color_t *color = &((cairo_solid_pattern_t *) src)->color;
 176     cairo_status_t status = CAIRO_STATUS_SUCCESS;
 177     struct fill_box fb;
 178
 179     TRACE ((stderr, "%s\n", __FUNCTION__));
 180
 181     fb.dc = dst->win32.dc;
 182     fb.brush = CreateSolidBrush (color_to_rgb(color));
 183     if (!fb.brush)
 184         return _cairo_win32_print_gdi_error (__FUNCTION__);
 185
 186     if (! _cairo_boxes_for_each_box (boxes, fill_box, &fb))
 187         status = CAIRO_INT_STATUS_UNSUPPORTED;
 188
 189     DeleteObject (fb.brush);
 190
 191     return status;
 192 }
 193
 194 static cairo_bool_t source_contains_box (cairo_box_t *box, void *closure)
 195 {
 196     struct check_box *data = closure;
 197
 198     /* The box is pixel-aligned so the truncation is safe. */
 199     return
 200         _cairo_fixed_integer_part (box->p1.x) + data->tx >= data->limit.x &&
 201         _cairo_fixed_integer_part (box->p1.y) + data->ty >= data->limit.y &&
 202         _cairo_fixed_integer_part (box->p2.x) + data->tx <= data->limit.x + data->limit.width &&
 203         _cairo_fixed_integer_part (box->p2.y) + data->ty <= data->limit.y + data->limit.height;
 204 }
 205
 206 static cairo_status_t
 207 copy_boxes (cairo_win32_display_surface_t *dst,
 208             const cairo_pattern_t *source,
 209             cairo_boxes_t *boxes)
 210 {
 211     const cairo_surface_pattern_t *pattern;
 212     struct copy_box cb;
 213     cairo_surface_t *surface;
 214     cairo_status_t status;
 215
 216     TRACE ((stderr, "%s\n", __FUNCTION__));
 217
 218     pattern = (const cairo_surface_pattern_t *) source;
 219     surface = _cairo_surface_get_source (pattern->surface, &cb.limit);
 220     if (surface->type == CAIRO_SURFACE_TYPE_IMAGE) {
 221         surface = to_image_surface(surface)->parent;
 222         if (surface == NULL)
 223             return CAIRO_INT_STATUS_UNSUPPORTED;
 224     }
 225     if (surface->type != CAIRO_SURFACE_TYPE_WIN32)
 226         return CAIRO_INT_STATUS_UNSUPPORTED;
 227
 228     if (! _cairo_matrix_is_integer_translation (&source->matrix,
 229                                                 &cb.tx, &cb.ty))
 230         return CAIRO_INT_STATUS_UNSUPPORTED;
 231
 232     cb.dst = dst->win32.dc;
 233     cb.src = to_win32_surface(surface)->dc;
 234
 235     /* First check that the data is entirely within the image */
 236     if (! _cairo_boxes_for_each_box (boxes, source_contains_box, &cb))
 237         return CAIRO_INT_STATUS_UNSUPPORTED;
 238
 239     status = _cairo_surface_flush (surface);
 240     if (status)
 241         return status;
 242
 243     cb.tx += cb.limit.x;
 244     cb.ty += cb.limit.y;
 245     status = CAIRO_STATUS_SUCCESS;
 246     if (! _cairo_boxes_for_each_box (boxes, copy_box, &cb))
 247         status = CAIRO_INT_STATUS_UNSUPPORTED;
 248
 249     _cairo_win32_display_surface_discard_fallback (dst);
 250     return status;
 251 }
 252
 253 static cairo_status_t
 254 upload_boxes (cairo_win32_display_surface_t *dst,
 255               const cairo_pattern_t *source,
 256               cairo_boxes_t *boxes)
 257 {
 258     const cairo_surface_pattern_t *pattern;
 259     struct upload_box cb;
 260     cairo_surface_t *surface;
 261     cairo_image_surface_t *image;
 262     void *image_extra;
 263     cairo_status_t status;
 264
 265     TRACE ((stderr, "%s\n", __FUNCTION__));
 266
 267     if ((dst->win32.flags & CAIRO_WIN32_SURFACE_CAN_STRETCHDIB) == 0)
 268         return CAIRO_INT_STATUS_UNSUPPORTED;
 269
 270     if (! _cairo_matrix_is_integer_translation (&source->matrix,
 271                                                 &cb.tx, &cb.ty))
 272         return CAIRO_INT_STATUS_UNSUPPORTED;
 273
 274     pattern = (const cairo_surface_pattern_t *) source;
 275     surface = _cairo_surface_get_source (pattern->surface, &cb.limit);
 276
 277     /* First check that the data is entirely within the image */
 278     if (! _cairo_boxes_for_each_box (boxes, source_contains_box, &cb))
 279         return CAIRO_INT_STATUS_UNSUPPORTED;
 280
 281     if (surface->type != CAIRO_SURFACE_TYPE_IMAGE) {
 282         status = _cairo_surface_acquire_source_image (surface,
 283                                                       &image, &image_extra);
 284         if (status)
 285             return status;
 286     } else
 287         image = to_image_surface(surface);
 288
 289     status = CAIRO_INT_STATUS_UNSUPPORTED;
 290     if (!(image->format == CAIRO_FORMAT_ARGB32 ||
 291           image->format == CAIRO_FORMAT_RGB24))
 292         goto err;
 293     if (image->stride != 4*image->width)
 294         goto err;
 295
 296     cb.dst = dst->win32.dc;
 297     cb.data = image->data;
 298
 299     cb.bi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
 300     cb.bi.bmiHeader.biWidth = image->width;
 301     cb.bi.bmiHeader.biHeight = -image->height;
 302     cb.bi.bmiHeader.biSizeImage = 0;
 303     cb.bi.bmiHeader.biXPelsPerMeter = PELS_72DPI;
 304     cb.bi.bmiHeader.biYPelsPerMeter = PELS_72DPI;
 305     cb.bi.bmiHeader.biPlanes = 1;
 306     cb.bi.bmiHeader.biBitCount = 32;
 307     cb.bi.bmiHeader.biCompression = BI_RGB;
 308     cb.bi.bmiHeader.biClrUsed = 0;
 309     cb.bi.bmiHeader.biClrImportant = 0;
 310
 311     cb.tx += cb.limit.x;
 312     cb.ty += cb.limit.y;
 313     status = CAIRO_STATUS_SUCCESS;
 314     if (! _cairo_boxes_for_each_box (boxes, upload_box, &cb))
 315         status = CAIRO_INT_STATUS_UNSUPPORTED;
 316
 317     _cairo_win32_display_surface_discard_fallback (dst);
 318 err:
 319     if (&image->base != surface)
 320         _cairo_surface_release_source_image (surface, image, image_extra);
 321
 322     return status;
 323 }
 324
 325 static cairo_status_t
 326 alpha_blend_boxes (cairo_win32_display_surface_t *dst,
 327                    const cairo_pattern_t *source,
 328                    cairo_boxes_t *boxes,
 329                    uint8_t alpha)
 330 {
 331     const cairo_surface_pattern_t *pattern;
 332     struct copy_box cb;
 333     cairo_surface_t *surface;
 334     cairo_win32_display_surface_t *src;
 335     cairo_status_t status;
 336
 337     TRACE ((stderr, "%s\n", __FUNCTION__));
 338     if (source->type != CAIRO_PATTERN_TYPE_SURFACE)
 339         return CAIRO_INT_STATUS_UNSUPPORTED;
 340
 341     pattern = (const cairo_surface_pattern_t *) source;
 342     surface = _cairo_surface_get_source (pattern->surface, &cb.limit);
 343     if (surface->type == CAIRO_SURFACE_TYPE_IMAGE) {
 344         surface = to_image_surface(surface)->parent;
 345         if (surface == NULL)
 346             return CAIRO_INT_STATUS_UNSUPPORTED;
 347     }
 348     if (surface->type != CAIRO_SURFACE_TYPE_WIN32)
 349         return CAIRO_INT_STATUS_UNSUPPORTED;
 350
 351     if (! _cairo_matrix_is_integer_translation (&source->matrix,
 352                                                 &cb.tx, &cb.ty))
 353         return CAIRO_INT_STATUS_UNSUPPORTED;
 354
 355     src = to_win32_display_surface (surface);
 356     cb.dst = dst->win32.dc;
 357     cb.src = src->win32.dc;
 358
 359     /* First check that the data is entirely within the image */
 360     if (! _cairo_boxes_for_each_box (boxes, source_contains_box, &cb))
 361         return CAIRO_INT_STATUS_UNSUPPORTED;
 362
 363     status = _cairo_surface_flush (&src->win32.base);
 364     if (status)
 365         return status;
 366
 367     cb.bf.BlendOp = AC_SRC_OVER;
 368     cb.bf.BlendFlags = 0;
 369     cb.bf.SourceConstantAlpha = alpha;
 370     cb.bf.AlphaFormat = (src->win32.format == CAIRO_FORMAT_ARGB32) ? AC_SRC_ALPHA : 0;
 371     cb.alpha_blend = to_win32_device(dst->win32.base.device)->alpha_blend;
 372
 373     cb.tx += cb.limit.x;
 374     cb.ty += cb.limit.y;
 375     status = CAIRO_STATUS_SUCCESS;
 376     if (! _cairo_boxes_for_each_box (boxes, alpha_box, &cb))
 377         status = CAIRO_INT_STATUS_UNSUPPORTED;
 378
 379     _cairo_win32_display_surface_discard_fallback (dst);
 380     return status;
 381 }
 382
 383 static cairo_bool_t
 384 can_alpha_blend (cairo_win32_display_surface_t *dst)
 385 {
 386     if ((dst->win32.flags & CAIRO_WIN32_SURFACE_CAN_ALPHABLEND) == 0)
 387         return FALSE;
 388
 389     return to_win32_device(dst->win32.base.device)->alpha_blend != NULL;
 390 }
 391
 392 static cairo_status_t
 393 draw_boxes (cairo_composite_rectangles_t *composite,
 394             cairo_boxes_t *boxes)
 395 {
 396     cairo_win32_display_surface_t *dst = to_win32_display_surface(composite->surface);
 397     cairo_operator_t op = composite->op;
 398     const cairo_pattern_t *src = &composite->source_pattern.base;
 399     cairo_int_status_t status;
 400
 401     TRACE ((stderr, "%s\n", __FUNCTION__));
 402     if (boxes->num_boxes == 0 && composite->is_bounded)
 403         return CAIRO_STATUS_SUCCESS;
 404
 405     if (!boxes->is_pixel_aligned)
 406         return CAIRO_INT_STATUS_UNSUPPORTED;
 407
 408     if (op == CAIRO_OPERATOR_CLEAR)
 409         op = CAIRO_OPERATOR_SOURCE;
 410
 411     if (op == CAIRO_OPERATOR_OVER &&
 412         _cairo_pattern_is_opaque (src, &composite->bounded))
 413         op = CAIRO_OPERATOR_SOURCE;
 414
 415     if (dst->win32.base.is_clear &&
 416         (op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD))
 417         op = CAIRO_OPERATOR_SOURCE;
 418
 419     if (op == CAIRO_OPERATOR_SOURCE) {
 420         status = CAIRO_INT_STATUS_UNSUPPORTED;
 421         if (src->type == CAIRO_PATTERN_TYPE_SURFACE) {
 422             status = copy_boxes (dst, src, boxes);
 423             if (status == CAIRO_INT_STATUS_UNSUPPORTED)
 424                 status = upload_boxes (dst, src, boxes);
 425         } else if (src->type == CAIRO_PATTERN_TYPE_SOLID) {
 426             status = fill_boxes (dst, src, boxes);
 427         }
 428         return status;
 429     }
 430
 431     if (op == CAIRO_OPERATOR_OVER && can_alpha_blend (dst))
 432         return alpha_blend_boxes (dst, src, boxes, 255);
 433
 434     return CAIRO_INT_STATUS_UNSUPPORTED;
 435 }
 436
 437 static cairo_status_t
 438 opacity_boxes (cairo_composite_rectangles_t *composite,
 439                cairo_boxes_t *boxes)
 440 {
 441     cairo_win32_display_surface_t *dst = to_win32_display_surface(composite->surface);
 442     cairo_operator_t op = composite->op;
 443     const cairo_pattern_t *src = &composite->source_pattern.base;
 444
 445     TRACE ((stderr, "%s\n", __FUNCTION__));
 446     if (composite->mask_pattern.base.type != CAIRO_PATTERN_TYPE_SOLID)
 447         return CAIRO_INT_STATUS_UNSUPPORTED;
 448
 449     if (boxes->num_boxes == 0 && composite->is_bounded)
 450         return CAIRO_STATUS_SUCCESS;
 451
 452     if (!boxes->is_pixel_aligned)
 453         return CAIRO_INT_STATUS_UNSUPPORTED;
 454
 455     if (op != CAIRO_OPERATOR_OVER)
 456         return CAIRO_INT_STATUS_UNSUPPORTED;
 457
 458     if (!can_alpha_blend (dst))
 459         return CAIRO_INT_STATUS_UNSUPPORTED;
 460
 461     return alpha_blend_boxes (dst, src, boxes,
 462                               composite->mask_pattern.solid.color.alpha_short >> 8);
 463 }
 464
 465 /* high-level compositor interface */
 466
 467 static cairo_bool_t check_blit (cairo_composite_rectangles_t *composite)
 468 {
 469     cairo_win32_display_surface_t *dst;
 470
 471     if (composite->clip->path)
 472         return FALSE;
 473
 474     dst = to_win32_display_surface (composite->surface);
 475     if (dst->fallback)
 476         return FALSE;
 477
 478     if (dst->win32.format != CAIRO_FORMAT_RGB24)
 479         return FALSE;
 480
 481     if (dst->win32.flags & CAIRO_WIN32_SURFACE_CAN_BITBLT)
 482         return TRUE;
 483
 484     return dst->image == NULL;
 485 }
 486
 487 static cairo_int_status_t
 488 _cairo_win32_gdi_compositor_paint (const cairo_compositor_t     *compositor,
 489                                    cairo_composite_rectangles_t *composite)
 490 {
 491     cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
 492
 493     if (check_blit (composite)) {
 494         cairo_boxes_t boxes;
 495
 496         TRACE ((stderr, "%s\n", __FUNCTION__));
 497         _cairo_clip_steal_boxes (composite->clip, &boxes);
 498         status = draw_boxes (composite, &boxes);
 499         _cairo_clip_unsteal_boxes (composite->clip, &boxes);
 500     }
 501
 502     return status;
 503 }
 504
 505 static cairo_int_status_t
 506 _cairo_win32_gdi_compositor_mask (const cairo_compositor_t      *compositor,
 507                                   cairo_composite_rectangles_t *composite)
 508 {
 509     cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
 510
 511     if (check_blit (composite)) {
 512         cairo_boxes_t boxes;
 513
 514         TRACE ((stderr, "%s\n", __FUNCTION__));
 515         _cairo_clip_steal_boxes (composite->clip, &boxes);
 516         status = opacity_boxes (composite, &boxes);
 517         _cairo_clip_unsteal_boxes (composite->clip, &boxes);
 518     }
 519
 520     return status;
 521 }
 522
 523 static cairo_int_status_t
 524 _cairo_win32_gdi_compositor_stroke (const cairo_compositor_t    *compositor,
 525                                     cairo_composite_rectangles_t *composite,
 526                                     const cairo_path_fixed_t    *path,
 527                                     const cairo_stroke_style_t  *style,
 528                                     const cairo_matrix_t        *ctm,
 529                                     const cairo_matrix_t        *ctm_inverse,
 530                                     double                       tolerance,
 531                                     cairo_antialias_t            antialias)
 532 {
 533     cairo_int_status_t status;
 534
 535     status = CAIRO_INT_STATUS_UNSUPPORTED;
 536     if (check_blit (composite) &&
 537         _cairo_path_fixed_stroke_is_rectilinear (path)) {
 538         cairo_boxes_t boxes;
 539
 540         TRACE ((stderr, "%s\n", __FUNCTION__));
 541         _cairo_boxes_init_with_clip (&boxes, composite->clip);
 542         status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,
 543                                                                 style,
 544                                                                 ctm,
 545                                                                 antialias,
 546                                                                 &boxes);
 547         if (likely (status == CAIRO_INT_STATUS_SUCCESS))
 548             status = draw_boxes (composite, &boxes);
 549         _cairo_boxes_fini (&boxes);
 550     }
 551
 552     return status;
 553 }
 554
 555 static cairo_int_status_t
 556 _cairo_win32_gdi_compositor_fill (const cairo_compositor_t      *compositor,
 557                                   cairo_composite_rectangles_t  *composite,
 558                                   const cairo_path_fixed_t      *path,
 559                                   cairo_fill_rule_t              fill_rule,
 560                                   double                         tolerance,
 561                                   cairo_antialias_t              antialias)
 562 {
 563     cairo_int_status_t status;
 564
 565     status = CAIRO_INT_STATUS_UNSUPPORTED;
 566     if (check_blit (composite) &&
 567         _cairo_path_fixed_fill_is_rectilinear (path)) {
 568         cairo_boxes_t boxes;
 569
 570         TRACE ((stderr, "%s\n", __FUNCTION__));
 571         _cairo_boxes_init_with_clip (&boxes, composite->clip);
 572         status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,
 573                                                               fill_rule,
 574                                                               antialias,
 575                                                               &boxes);
 576         if (likely (status == CAIRO_INT_STATUS_SUCCESS))
 577             status = draw_boxes (composite, &boxes);
 578         _cairo_boxes_fini (&boxes);
 579     }
 580
 581     return status;
 582 }
 583
 584 static cairo_bool_t check_glyphs (cairo_composite_rectangles_t *composite,
 585                                   cairo_scaled_font_t *scaled_font)
 586 {
 587     if (! _cairo_clip_is_region (composite->clip))
 588         return FALSE;
 589
 590     if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_WIN32)
 591         return FALSE;
 592
 593     if (! _cairo_pattern_is_opaque_solid (&composite->source_pattern.base))
 594         return FALSE;
 595
 596     return (composite->op == CAIRO_OPERATOR_CLEAR ||
 597             composite->op == CAIRO_OPERATOR_SOURCE ||
 598             composite->op == CAIRO_OPERATOR_OVER);
 599 }
 600
 601 static cairo_int_status_t
 602 _cairo_win32_gdi_compositor_glyphs (const cairo_compositor_t    *compositor,
 603                                     cairo_composite_rectangles_t*composite,
 604                                     cairo_scaled_font_t         *scaled_font,
 605                                     cairo_glyph_t               *glyphs,
 606                                     int                          num_glyphs,
 607                                     cairo_bool_t                 overlap)
 608 {
 609     cairo_int_status_t status;
 610
 611     status = CAIRO_INT_STATUS_UNSUPPORTED;
 612     if (check_blit (composite) && check_glyphs (composite, scaled_font)) {
 613         cairo_win32_display_surface_t *dst = to_win32_display_surface (composite->surface);
 614
 615         TRACE ((stderr, "%s\n", __FUNCTION__));
 616         status = _cairo_win32_display_surface_set_clip(dst, composite->clip);
 617         if (status)
 618             return status;
 619
 620         status = _cairo_win32_surface_emit_glyphs (&dst->win32,
 621                                                    &composite->source_pattern.base,
 622                                                    glyphs,
 623                                                    num_glyphs,
 624                                                    scaled_font,
 625                                                    TRUE);
 626
 627         _cairo_win32_display_surface_unset_clip (dst);
 628     }
 629
 630     return status;
 631 }
 632
 633 const cairo_compositor_t *
 634 _cairo_win32_gdi_compositor_get (void)
 635 {
 636     static cairo_compositor_t compositor;
 637
 638     if (compositor.delegate == NULL) {
 639         compositor.delegate = &_cairo_fallback_compositor;
 640
 641         compositor.paint  = _cairo_win32_gdi_compositor_paint;
 642         compositor.mask   = _cairo_win32_gdi_compositor_mask;
 643         compositor.fill   = _cairo_win32_gdi_compositor_fill;
 644         compositor.stroke = _cairo_win32_gdi_compositor_stroke;
 645         compositor.glyphs = _cairo_win32_gdi_compositor_glyphs;
 646     }
 647
 648     return &compositor;
 649 }