Subversion Repositories Scribus

Rev

Rev 17188 | Blame | Compare with Previous | Last modification | View Log | RSS feed

/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
/* Cairo - a vector graphics library with display and print output
 *
 * Copyright © 2005 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 *
 * The Original Code is the cairo graphics library.
 *
 * The Initial Developer of the Original Code is Red Hat, Inc.
 *
 * Contributor(s):
 *      Owen Taylor <otaylor@redhat.com>
 *      Stuart Parmenter <stuart@mozilla.com>
 *      Vladimir Vukicevic <vladimir@pobox.com>
 */


#define WIN32_LEAN_AND_MEAN
/* We require Windows 2000 features such as ETO_PDY */
#if !defined(WINVER) || (WINVER < 0x0500)
# define WINVER 0x0500
#endif
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
# define _WIN32_WINNT 0x0500
#endif

#include "cairoint.h"

#include "cairo-clip-private.h"
#include "cairo-paginated-private.h"
#include "cairo-win32-private.h"
#include "cairo-scaled-font-subsets-private.h"
#include "cairo-surface-fallback-private.h"

#include <wchar.h>
#include <windows.h>

#if defined(__MINGW32__) && !defined(ETO_PDY)
# define ETO_PDY 0x2000
#endif

#undef DEBUG_COMPOSITE

/* for older SDKs */
#ifndef SHADEBLENDCAPS
#define SHADEBLENDCAPS  120
#endif
#ifndef SB_NONE
#define SB_NONE         0x00000000
#endif

#define PELS_72DPI  ((LONG)(72. / 0.0254))

static const cairo_surface_backend_t cairo_win32_surface_backend;

/**
 * _cairo_win32_print_gdi_error:
 * @context: context string to display along with the error
 *
 * Helper function to dump out a human readable form of the
 * current error code.
 *
 * Return value: A cairo status code for the error code
 **/

cairo_status_t
_cairo_win32_print_gdi_error (const char *context)
{
    void *lpMsgBuf;
    DWORD last_error = GetLastError ();

    if (!FormatMessageW (FORMAT_MESSAGE_ALLOCATE_BUFFER |
                         FORMAT_MESSAGE_FROM_SYSTEM,
                         NULL,
                         last_error,
                         MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                         (LPWSTR) &lpMsgBuf,
                         0, NULL)) {
        fprintf (stderr, "%s: Unknown GDI error", context);
    } else {
        fprintf (stderr, "%s: %S", context, (wchar_t *)lpMsgBuf);

        LocalFree (lpMsgBuf);
    }

        fflush (stderr);

    /* We should switch off of last_status, but we'd either return
     * CAIRO_STATUS_NO_MEMORY or CAIRO_STATUS_UNKNOWN_ERROR and there
     * is no CAIRO_STATUS_UNKNOWN_ERROR.
     */


    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}

uint32_t
_cairo_win32_flags_for_dc (HDC dc)
{
    uint32_t flags = 0;

    if (GetDeviceCaps(dc, TECHNOLOGY) == DT_RASDISPLAY) {
        flags |= CAIRO_WIN32_SURFACE_IS_DISPLAY;

        /* These will always be possible, but the actual GetDeviceCaps
         * calls will return whether they're accelerated or not.
         * We may want to use our own (pixman) routines sometimes
         * if they're eventually faster, but for now have GDI do
         * everything.
         */

        flags |= CAIRO_WIN32_SURFACE_CAN_BITBLT;
        flags |= CAIRO_WIN32_SURFACE_CAN_ALPHABLEND;
        flags |= CAIRO_WIN32_SURFACE_CAN_STRETCHBLT;
        flags |= CAIRO_WIN32_SURFACE_CAN_STRETCHDIB;
    } else {
        int cap;

        cap = GetDeviceCaps(dc, SHADEBLENDCAPS);
        if (cap != SB_NONE)
            flags |= CAIRO_WIN32_SURFACE_CAN_ALPHABLEND;

        cap = GetDeviceCaps(dc, RASTERCAPS);
        if (cap & RC_BITBLT)
            flags |= CAIRO_WIN32_SURFACE_CAN_BITBLT;
        if (cap & RC_STRETCHBLT)
            flags |= CAIRO_WIN32_SURFACE_CAN_STRETCHBLT;
        if (cap & RC_STRETCHDIB)
            flags |= CAIRO_WIN32_SURFACE_CAN_STRETCHDIB;
    }

    return flags;
}

static cairo_status_t
_create_dc_and_bitmap (cairo_win32_surface_t *surface,
                       HDC                    original_dc,
                       cairo_format_t         format,
                       int                    width,
                       int                    height,
                       unsigned char        **bits_out,
                       int                   *rowstride_out)
{
    cairo_status_t status;

    BITMAPINFO *bitmap_info = NULL;
    struct {
        BITMAPINFOHEADER bmiHeader;
        RGBQUAD bmiColors[2];
    } bmi_stack;
    void *bits;

    int num_palette = 0;        /* Quiet GCC */
    int i;

    surface->dc = NULL;
    surface->bitmap = NULL;
    surface->is_dib = FALSE;

    switch (format) {
    case CAIRO_FORMAT_ARGB32:
    case CAIRO_FORMAT_RGB24:
        num_palette = 0;
        break;

    case CAIRO_FORMAT_A8:
        num_palette = 256;
        break;

    case CAIRO_FORMAT_A1:
        num_palette = 2;
        break;
    }

    if (num_palette > 2) {
        bitmap_info = _cairo_malloc_ab_plus_c (num_palette, sizeof(RGBQUAD), sizeof(BITMAPINFOHEADER));
        if (!bitmap_info)
            return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    } else {
        bitmap_info = (BITMAPINFO *)&bmi_stack;
    }

    bitmap_info->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
    bitmap_info->bmiHeader.biWidth = width == 0 ? 1 : width;
    bitmap_info->bmiHeader.biHeight = height == 0 ? -1 : - height; /* top-down */
    bitmap_info->bmiHeader.biSizeImage = 0;
    bitmap_info->bmiHeader.biXPelsPerMeter = PELS_72DPI; /* unused here */
    bitmap_info->bmiHeader.biYPelsPerMeter = PELS_72DPI; /* unused here */
    bitmap_info->bmiHeader.biPlanes = 1;

    switch (format) {
    /* We can't create real RGB24 bitmaps because something seems to
     * break if we do, especially if we don't set up an image
     * fallback.  It could be a bug with using a 24bpp pixman image
     * (and creating one with masks).  So treat them like 32bpp.
     * Note: This causes problems when using BitBlt/AlphaBlend/etc!
     * see end of file.
     */

    case CAIRO_FORMAT_RGB24:
    case CAIRO_FORMAT_ARGB32:
        bitmap_info->bmiHeader.biBitCount = 32;
        bitmap_info->bmiHeader.biCompression = BI_RGB;
        bitmap_info->bmiHeader.biClrUsed = 0;   /* unused */
        bitmap_info->bmiHeader.biClrImportant = 0;
        break;

    case CAIRO_FORMAT_A8:
        bitmap_info->bmiHeader.biBitCount = 8;
        bitmap_info->bmiHeader.biCompression = BI_RGB;
        bitmap_info->bmiHeader.biClrUsed = 256;
        bitmap_info->bmiHeader.biClrImportant = 0;

        for (i = 0; i < 256; i++) {
            bitmap_info->bmiColors[i].rgbBlue = i;
            bitmap_info->bmiColors[i].rgbGreen = i;
            bitmap_info->bmiColors[i].rgbRed = i;
            bitmap_info->bmiColors[i].rgbReserved = 0;
        }

        break;

    case CAIRO_FORMAT_A1:
        bitmap_info->bmiHeader.biBitCount = 1;
        bitmap_info->bmiHeader.biCompression = BI_RGB;
        bitmap_info->bmiHeader.biClrUsed = 2;
        bitmap_info->bmiHeader.biClrImportant = 0;

        for (i = 0; i < 2; i++) {
            bitmap_info->bmiColors[i].rgbBlue = i * 255;
            bitmap_info->bmiColors[i].rgbGreen = i * 255;
            bitmap_info->bmiColors[i].rgbRed = i * 255;
            bitmap_info->bmiColors[i].rgbReserved = 0;
        }

        break;
    }

    surface->dc = CreateCompatibleDC (original_dc);
    if (!surface->dc)
        goto FAIL;

    surface->bitmap = CreateDIBSection (surface->dc,
                                        bitmap_info,
                                        DIB_RGB_COLORS,
                                        &bits,
                                        NULL, 0);
    if (!surface->bitmap)
        goto FAIL;

    surface->is_dib = TRUE;

    GdiFlush();

    surface->saved_dc_bitmap = SelectObject (surface->dc,
                                             surface->bitmap);
    if (!surface->saved_dc_bitmap)
        goto FAIL;

    if (bitmap_info && num_palette > 2)
        free (bitmap_info);

    if (bits_out)
        *bits_out = bits;

    if (rowstride_out) {
        /* Windows bitmaps are padded to 32-bit (dword) boundaries */
        switch (format) {
        case CAIRO_FORMAT_ARGB32:
        case CAIRO_FORMAT_RGB24:
            *rowstride_out = 4 * width;
            break;

        case CAIRO_FORMAT_A8:
            *rowstride_out = (width + 3) & ~3;
            break;

        case CAIRO_FORMAT_A1:
            *rowstride_out = ((width + 31) & ~31) / 8;
            break;
        }
    }

    surface->flags = _cairo_win32_flags_for_dc (surface->dc);

    return CAIRO_STATUS_SUCCESS;

 FAIL:
    status = _cairo_win32_print_gdi_error ("_create_dc_and_bitmap");

    if (bitmap_info && num_palette > 2)
        free (bitmap_info);

    if (surface->saved_dc_bitmap) {
        SelectObject (surface->dc, surface->saved_dc_bitmap);
        surface->saved_dc_bitmap = NULL;
    }

    if (surface->bitmap) {
        DeleteObject (surface->bitmap);
        surface->bitmap = NULL;
    }

    if (surface->dc) {
        DeleteDC (surface->dc);
        surface->dc = NULL;
    }

    return status;
}

static cairo_surface_t *
_cairo_win32_surface_create_for_dc (HDC             original_dc,
                                    cairo_format_t  format,
                                    int             width,
                                    int             height)
{
    cairo_status_t status;
    cairo_win32_surface_t *surface;
    unsigned char *bits;
    int rowstride;

    surface = malloc (sizeof (cairo_win32_surface_t));
    if (surface == NULL)
        return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

    surface->clip_region = NULL;

    status = _create_dc_and_bitmap (surface, original_dc, format,
                                    width, height,
                                    &bits, &rowstride);
    if (status)
        goto FAIL;

    surface->image = cairo_image_surface_create_for_data (bits, format,
                                                          width, height, rowstride);
    status = surface->image->status;
    if (status)
        goto FAIL;

    surface->format = format;

    surface->clip_rect.x = 0;
    surface->clip_rect.y = 0;
    surface->clip_rect.width = width;
    surface->clip_rect.height = height;

    surface->initial_clip_rgn = NULL;
    surface->had_simple_clip = FALSE;

    surface->extents = surface->clip_rect;
    surface->font_subsets = NULL;

    _cairo_surface_init (&surface->base, &cairo_win32_surface_backend,
                         _cairo_content_from_format (format));

    return &surface->base;

 FAIL:
    if (surface->bitmap) {
        SelectObject (surface->dc, surface->saved_dc_bitmap);
        DeleteObject (surface->bitmap);
        DeleteDC (surface->dc);
    }
    free (surface);

    return _cairo_surface_create_in_error (status);
}

static cairo_surface_t *
_cairo_win32_surface_create_similar_internal (void          *abstract_src,
                                              cairo_content_t content,
                                              int            width,
                                              int            height,
                                              cairo_bool_t   force_dib)
{
    cairo_win32_surface_t *src = abstract_src;
    cairo_format_t format = _cairo_format_from_content (content);
    cairo_surface_t *new_surf = NULL;

    /* We force a DIB always if:
     * - we need alpha; or
     * - the parent is a DIB; or
     * - the parent is for printing (because we don't care about the bit depth at that point)
     *
     * We also might end up with a DIB even if a DDB is requested if DDB creation failed
     * due to out of memory.
     */

    if (src->is_dib ||
        (content & CAIRO_CONTENT_ALPHA) ||
        src->base.backend->type == CAIRO_SURFACE_TYPE_WIN32_PRINTING)
    {
        force_dib = TRUE;
    }

    if (!force_dib) {
        /* try to create a ddb */
        new_surf = cairo_win32_surface_create_with_ddb (src->dc, CAIRO_FORMAT_RGB24, width, height);

        if (new_surf->status != CAIRO_STATUS_SUCCESS)
            new_surf = NULL;
    }

    if (new_surf == NULL) {
        new_surf = _cairo_win32_surface_create_for_dc (src->dc, format, width, height);
    }

    return new_surf;
}

cairo_surface_t *
_cairo_win32_surface_create_similar (void           *abstract_src,
                                     cairo_content_t content,
                                     int             width,
                                     int             height)
{
    return _cairo_win32_surface_create_similar_internal (abstract_src, content, width, height, FALSE);
}

cairo_status_t
_cairo_win32_surface_finish (void *abstract_surface)
{
    cairo_win32_surface_t *surface = abstract_surface;

    if (surface->image)
        cairo_surface_destroy (surface->image);

    /* If we created the Bitmap and DC, destroy them */
    if (surface->bitmap) {
        SelectObject (surface->dc, surface->saved_dc_bitmap);
        DeleteObject (surface->bitmap);
        DeleteDC (surface->dc);
    } else {
        _cairo_win32_restore_initial_clip (surface);
    }

    if (surface->initial_clip_rgn)
        DeleteObject (surface->initial_clip_rgn);

    if (surface->font_subsets != NULL)
        _cairo_scaled_font_subsets_destroy (surface->font_subsets);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_win32_surface_get_subimage (cairo_win32_surface_t  *surface,
                                   int                     x,
                                   int                     y,
                                   int                     width,
                                   int                     height,
                                   cairo_win32_surface_t **local_out)
{
    cairo_win32_surface_t *local;
    cairo_int_status_t status;
    cairo_content_t content = _cairo_content_from_format (surface->format);

    local =
        (cairo_win32_surface_t *) _cairo_win32_surface_create_similar_internal
        (surface, content, width, height, TRUE);
    if (local == NULL)
        return CAIRO_INT_STATUS_UNSUPPORTED;
    if (local->base.status)
        return local->base.status;

    status = CAIRO_INT_STATUS_UNSUPPORTED;

    /* Only BitBlt if the source surface supports it. */
    if ((surface->flags & CAIRO_WIN32_SURFACE_CAN_BITBLT) &&
        BitBlt (local->dc,
                0, 0,
                width, height,
                surface->dc,
                x, y,
                SRCCOPY))
    {
        status = CAIRO_STATUS_SUCCESS;
    }

    if (status) {
        /* If we failed here, most likely the source or dest doesn't
         * support BitBlt/AlphaBlend (e.g. a printer).
         * You can't reliably get bits from a printer DC, so just fill in
         * the surface as white (common case for printing).
         */


        RECT r;
        r.left = r.top = 0;
        r.right = width;
        r.bottom = height;
        FillRect(local->dc, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));
    }

    *local_out = local;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_win32_surface_acquire_source_image (void                    *abstract_surface,
                                           cairo_image_surface_t  **image_out,
                                           void                   **image_extra)
{
    cairo_win32_surface_t *surface = abstract_surface;
    cairo_win32_surface_t *local;
    cairo_status_t status;

    if (surface->image) {
        *image_out = (cairo_image_surface_t *)surface->image;
        *image_extra = NULL;
        return CAIRO_STATUS_SUCCESS;
    }

    status = _cairo_win32_surface_get_subimage (abstract_surface, 0, 0,
                                                surface->extents.width,
                                                surface->extents.height, &local);
    if (status)
        return status;

    *image_out = (cairo_image_surface_t *)local->image;
    *image_extra = local;
    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_win32_surface_release_source_image (void                   *abstract_surface,
                                           cairo_image_surface_t  *image,
                                           void                   *image_extra)
{
    cairo_win32_surface_t *local = image_extra;

    if (local)
        cairo_surface_destroy ((cairo_surface_t *)local);
}

static cairo_status_t
_cairo_win32_surface_acquire_dest_image (void                    *abstract_surface,
                                         cairo_rectangle_int_t   *interest_rect,
                                         cairo_image_surface_t  **image_out,
                                         cairo_rectangle_int_t   *image_rect,
                                         void                   **image_extra)
{
    cairo_win32_surface_t *surface = abstract_surface;
    cairo_win32_surface_t *local = NULL;
    cairo_status_t status;

    if (surface->image) {
        GdiFlush();

        *image_out = (cairo_image_surface_t *) surface->image;
        *image_extra = NULL;
        *image_rect = surface->extents;
        return CAIRO_STATUS_SUCCESS;
    }

    status = _cairo_win32_surface_get_subimage (abstract_surface,
                                                interest_rect->x,
                                                interest_rect->y,
                                                interest_rect->width,
                                                interest_rect->height,
                                                &local);
    if (status)
        return status;

    *image_out = (cairo_image_surface_t *) local->image;
    *image_extra = local;
    *image_rect = *interest_rect;
    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_win32_surface_release_dest_image (void                    *abstract_surface,
                                         cairo_rectangle_int_t   *interest_rect,
                                         cairo_image_surface_t   *image,
                                         cairo_rectangle_int_t   *image_rect,
                                         void                    *image_extra)
{
    cairo_win32_surface_t *surface = abstract_surface;
    cairo_win32_surface_t *local = image_extra;

    if (!local)
        return;

    if (!BitBlt (surface->dc,
                 image_rect->x, image_rect->y,
                 image_rect->width, image_rect->height,
                 local->dc,
                 0, 0,
                 SRCCOPY))
        _cairo_win32_print_gdi_error ("_cairo_win32_surface_release_dest_image");

    cairo_surface_destroy ((cairo_surface_t *)local);
}

cairo_status_t
_cairo_win32_surface_set_clip_region (void           *abstract_surface,
                                      cairo_region_t *region)
{
    cairo_win32_surface_t *surface = abstract_surface;
    cairo_status_t status = CAIRO_STATUS_SUCCESS;

    if (surface->clip_region == region)
        return CAIRO_STATUS_SUCCESS;

    cairo_region_destroy (surface->clip_region);
    surface->clip_region = cairo_region_reference (region);

    /* The semantics we want is that any clip set by cairo combines
     * is intersected with the clip on device context that the
     * surface was created for. To implement this, we need to
     * save the original clip when first setting a clip on surface.
     */


    /* Clear any clip set by cairo, return to the original first */
    status = _cairo_win32_restore_initial_clip (surface);

    /* Then combine any new region with it */
    if (region) {
        cairo_rectangle_int_t extents;
        int num_rects;
        RGNDATA *data;
        size_t data_size;
        RECT *rects;
        int i;
        HRGN gdi_region;

        /* Create a GDI region for the cairo region */

        cairo_region_get_extents (region, &extents);
        num_rects = cairo_region_num_rectangles (region);
        /* XXX see notes in _cairo_win32_save_initial_clip --
         * this code will interact badly with a HDC which had an initial
         * world transform -- we should probably manually transform the
         * region rects, because SelectClipRgn takes device units, not
         * logical units (unlike IntersectClipRect).
         */


        data_size = sizeof (RGNDATAHEADER) + num_rects * sizeof (RECT);
        data = malloc (data_size);
        if (!data)
            return _cairo_error(CAIRO_STATUS_NO_MEMORY);
        rects = (RECT *)data->Buffer;

        data->rdh.dwSize = sizeof (RGNDATAHEADER);
        data->rdh.iType = RDH_RECTANGLES;
        data->rdh.nCount = num_rects;
        data->rdh.nRgnSize = num_rects * sizeof (RECT);
        data->rdh.rcBound.left = extents.x;
        data->rdh.rcBound.top = extents.y;
        data->rdh.rcBound.right = extents.x + extents.width;
        data->rdh.rcBound.bottom = extents.y + extents.height;

        for (i = 0; i < num_rects; i++) {
            cairo_rectangle_int_t rect;

            cairo_region_get_rectangle (region, i, &rect);

            rects[i].left   = rect.x;
            rects[i].top    = rect.y;
            rects[i].right  = rect.x + rect.width;
            rects[i].bottom = rect.y + rect.height;
        }

        gdi_region = ExtCreateRegion (NULL, data_size, data);
        free (data);

        if (!gdi_region)
            return _cairo_error (CAIRO_STATUS_NO_MEMORY);

        /* AND the new region into our DC */
        if (ExtSelectClipRgn (surface->dc, gdi_region, RGN_AND) == ERROR)
            status = _cairo_win32_print_gdi_error ("_cairo_win32_surface_set_clip_region");

        DeleteObject (gdi_region);
    }

    return status;
}

#if !defined(AC_SRC_OVER)
#define AC_SRC_OVER                 0x00
#pragma pack(1)
typedef struct {
    BYTE   BlendOp;
    BYTE   BlendFlags;
    BYTE   SourceConstantAlpha;
    BYTE   AlphaFormat;
}BLENDFUNCTION;
#pragma pack()
#endif

/* for compatibility with VC++ 6 */
#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                0x01
#endif

typedef BOOL (WINAPI *cairo_alpha_blend_func_t) (HDC hdcDest,
                                                 int nXOriginDest,
                                                 int nYOriginDest,
                                                 int nWidthDest,
                                                 int hHeightDest,
                                                 HDC hdcSrc,
                                                 int nXOriginSrc,
                                                 int nYOriginSrc,
                                                 int nWidthSrc,
                                                 int nHeightSrc,
                                                 BLENDFUNCTION blendFunction);

static cairo_int_status_t
_composite_alpha_blend (cairo_win32_surface_t *dst,
                        cairo_win32_surface_t *src,
                        int                    alpha,
                        int                    src_x,
                        int                    src_y,
                        int                    src_w,
                        int                    src_h,
                        int                    dst_x,
                        int                    dst_y,
                        int                    dst_w,
                        int                    dst_h)
{
    static unsigned alpha_blend_checked = FALSE;
    static cairo_alpha_blend_func_t alpha_blend = NULL;

    BLENDFUNCTION blend_function;

    /* Check for AlphaBlend dynamically to allow compiling on
     * MSVC 6 and use on older windows versions
     */

    if (!alpha_blend_checked) {
        OSVERSIONINFO os;

        os.dwOSVersionInfoSize = sizeof (os);
        GetVersionEx (&os);

        /* If running on Win98, disable using AlphaBlend()
         * to avoid Win98 AlphaBlend() bug */

        if (VER_PLATFORM_WIN32_WINDOWS != os.dwPlatformId ||
            os.dwMajorVersion != 4 || os.dwMinorVersion != 10)
        {
            HMODULE msimg32_dll = LoadLibraryW (L"msimg32");

            if (msimg32_dll != NULL)
                alpha_blend = (cairo_alpha_blend_func_t)GetProcAddress (msimg32_dll,
                                                                        "AlphaBlend");
        }

        alpha_blend_checked = TRUE;
    }

    if (alpha_blend == NULL)
        return CAIRO_INT_STATUS_UNSUPPORTED;
    if (!(dst->flags & CAIRO_WIN32_SURFACE_CAN_ALPHABLEND))
        return CAIRO_INT_STATUS_UNSUPPORTED;
    if (src->format == CAIRO_FORMAT_RGB24 && dst->format == CAIRO_FORMAT_ARGB32)
        return CAIRO_INT_STATUS_UNSUPPORTED;

    blend_function.BlendOp = AC_SRC_OVER;
    blend_function.BlendFlags = 0;
    blend_function.SourceConstantAlpha = alpha;
    blend_function.AlphaFormat = (src->format == CAIRO_FORMAT_ARGB32) ? AC_SRC_ALPHA : 0;

    if (!alpha_blend (dst->dc,
                      dst_x, dst_y,
                      dst_w, dst_h,
                      src->dc,
                      src_x, src_y,
                      src_w, src_h,
                      blend_function))
        return _cairo_win32_print_gdi_error ("_cairo_win32_surface_composite(AlphaBlend)");

    return CAIRO_STATUS_SUCCESS;
}

static cairo_int_status_t
_cairo_win32_surface_composite_inner (cairo_win32_surface_t *src,
                                      cairo_image_surface_t *src_image,
                                      cairo_win32_surface_t *dst,
                                      cairo_rectangle_int_t src_extents,
                                      cairo_rectangle_int_t src_r,
                                      cairo_rectangle_int_t dst_r,
                                      int alpha,
                                      cairo_bool_t needs_alpha,
                                      cairo_bool_t needs_scale)
{
    /* Then do BitBlt, StretchDIBits, StretchBlt, AlphaBlend, or MaskBlt */
    if (src_image) {
        if (needs_alpha || needs_scale)
            return CAIRO_INT_STATUS_UNSUPPORTED;

        if (dst->flags & CAIRO_WIN32_SURFACE_CAN_STRETCHBLT) {
            BITMAPINFO bi;
            bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
            bi.bmiHeader.biWidth = src_image->width;
            bi.bmiHeader.biHeight = - src_image->height;
            bi.bmiHeader.biSizeImage = 0;
            bi.bmiHeader.biXPelsPerMeter = PELS_72DPI;
            bi.bmiHeader.biYPelsPerMeter = PELS_72DPI;
            bi.bmiHeader.biPlanes = 1;
            bi.bmiHeader.biBitCount = 32;
            bi.bmiHeader.biCompression = BI_RGB;
            bi.bmiHeader.biClrUsed = 0;
            bi.bmiHeader.biClrImportant = 0;

            /* StretchDIBits is broken with top-down dibs; you need to do some
             * special munging to make the coordinate space work (basically,
             * need to address everything based on the bottom left, instead of top left,
             * and need to tell it to flip the resulting image.
             *
             * See http://blog.vlad1.com/archives/2006/10/26/134/ and comments.
             */

            if (!StretchDIBits (dst->dc,
                                /* dst x,y,w,h */
                                dst_r.x, dst_r.y + dst_r.height - 1,
                                dst_r.width, - (int) dst_r.height,
                                /* src x,y,w,h */
                                src_r.x, src_extents.height - src_r.y + 1,
                                src_r.width, - (int) src_r.height,
                                src_image->data,
                                &bi,
                                DIB_RGB_COLORS,
                                SRCCOPY))
                return _cairo_win32_print_gdi_error ("_cairo_win32_surface_composite(StretchDIBits)");
        }
    } else if (!needs_alpha) {
        /* BitBlt or StretchBlt? */
        if (!needs_scale && (dst->flags & CAIRO_WIN32_SURFACE_CAN_BITBLT)) {
            if (!BitBlt (dst->dc,
                         dst_r.x, dst_r.y,
                         dst_r.width, dst_r.height,
                         src->dc,
                         src_r.x, src_r.y,
                         SRCCOPY))
                return _cairo_win32_print_gdi_error ("_cairo_win32_surface_composite(BitBlt)");
        } else if (dst->flags & CAIRO_WIN32_SURFACE_CAN_STRETCHBLT) {
            /* StretchBlt? */
            /* XXX check if we want HALFTONE, based on the src filter */
            BOOL success;
            int oldmode = SetStretchBltMode(dst->dc, HALFTONE);
            success = StretchBlt(dst->dc,
                                 dst_r.x, dst_r.y,
                                 dst_r.width, dst_r.height,
                                 src->dc,
                                 src_r.x, src_r.y,
                                 src_r.width, src_r.height,
                                 SRCCOPY);
            SetStretchBltMode(dst->dc, oldmode);

            if (!success)
                return _cairo_win32_print_gdi_error ("StretchBlt");
        }
    } else if (needs_alpha && !needs_scale) {
        return _composite_alpha_blend (dst, src, alpha,
                                       src_r.x, src_r.y, src_r.width, src_r.height,
                                       dst_r.x, dst_r.y, dst_r.width, dst_r.height);
    }

    return CAIRO_STATUS_SUCCESS;
}

/* from pixman-private.h */
#define MOD(a,b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))

static cairo_int_status_t
_cairo_win32_surface_composite (cairo_operator_t        op,
                                const cairo_pattern_t   *pattern,
                                const cairo_pattern_t   *mask_pattern,
                                void                    *abstract_dst,
                                int                     src_x,
                                int                     src_y,
                                int                     mask_x,
                                int                     mask_y,
                                int                     dst_x,
                                int                     dst_y,
                                unsigned int            width,
                                unsigned int            height,
                                cairo_region_t         *clip_region)
{
    cairo_win32_surface_t *dst = abstract_dst;
    cairo_win32_surface_t *src;
    cairo_surface_pattern_t *src_surface_pattern;
    int alpha;
    double scalex, scaley;
    cairo_fixed_t x0_fixed, y0_fixed;
    cairo_int_status_t status;

    cairo_bool_t needs_alpha, needs_scale, needs_repeat;
    cairo_image_surface_t *src_image = NULL;

    cairo_format_t src_format;
    cairo_rectangle_int_t src_extents;

    cairo_rectangle_int_t src_r = { src_x, src_y, width, height };
    cairo_rectangle_int_t dst_r = { dst_x, dst_y, width, height };

#ifdef DEBUG_COMPOSITE
    fprintf (stderr, "+++ composite: %d %p %p %p [%d %d] [%d %d] [%d %d] %dx%d\n",
             op, pattern, mask_pattern, abstract_dst, src_x, src_y, mask_x, mask_y, dst_x, dst_y, width, height);
#endif

    /* If the destination can't do any of these, then
     * we may as well give up, since this is what we'll
     * look to for optimization.
     */

    if ((dst->flags & (CAIRO_WIN32_SURFACE_CAN_BITBLT |
                       CAIRO_WIN32_SURFACE_CAN_ALPHABLEND |
                       CAIRO_WIN32_SURFACE_CAN_STRETCHBLT |
                       CAIRO_WIN32_SURFACE_CAN_STRETCHDIB))
        == 0)
    {
        goto UNSUPPORTED;
    }

    if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE)
        goto UNSUPPORTED;

    if (pattern->extend != CAIRO_EXTEND_NONE &&
        pattern->extend != CAIRO_EXTEND_REPEAT)
        goto UNSUPPORTED;

    if (mask_pattern) {
        /* FIXME: When we fully support RENDER style 4-channel
         * masks we need to check r/g/b != 1.0.
         */

        if (mask_pattern->type != CAIRO_PATTERN_TYPE_SOLID)
            return CAIRO_INT_STATUS_UNSUPPORTED;

        alpha = ((cairo_solid_pattern_t *)mask_pattern)->color.alpha_short >> 8;
    } else {
        alpha = 255;
    }

    src_surface_pattern = (cairo_surface_pattern_t *)pattern;
    src = (cairo_win32_surface_t *)src_surface_pattern->surface;

    if (src->base.type == CAIRO_SURFACE_TYPE_IMAGE &&
        dst->flags & (CAIRO_WIN32_SURFACE_CAN_STRETCHDIB))
    {
        /* In some very limited cases, we can use StretchDIBits to draw
         * an image surface directly:
         *  - source is CAIRO_FORMAT_ARGB32
         *  - dest is CAIRO_FORMAT_ARGB32
         *  - alpha is 255
         *  - operator is SOURCE or OVER
         *  - image stride is 4*width
         */

        src_image = (cairo_image_surface_t*) src;

        if (src_image->format != CAIRO_FORMAT_RGB24 ||
            dst->format != CAIRO_FORMAT_RGB24 ||
            alpha != 255 ||
            (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_OVER) ||
            src_image->stride != (src_image->width * 4))
        {
            goto UNSUPPORTED;
        }

        src_format = src_image->format;
        src_extents.x = 0;
        src_extents.y = 0;
        src_extents.width = src_image->width;
        src_extents.height = src_image->height;
    } else if (src->base.backend != dst->base.backend) {
        goto UNSUPPORTED;
    } else {
        src_format = src->format;
        src_extents = src->extents;
    }


#ifdef DEBUG_COMPOSITE
    fprintf (stderr, "Before check: src size: (%d %d) xy [%d %d] -> dst [%d %d %d %d] {srcmat %f %f %f %f}\n",
             src_extents.width, src_extents.height,
             src_x, src_y,
             dst_x, dst_y, width, height,
             pattern->matrix.x0, pattern->matrix.y0, pattern->matrix.xx, pattern->matrix.yy);
#endif

    /* We can only use GDI functions if the source and destination rectangles
     * are on integer pixel boundaries.  Figure that out here.
     */

    x0_fixed = _cairo_fixed_from_double(pattern->matrix.x0 / pattern->matrix.xx);
    y0_fixed = _cairo_fixed_from_double(pattern->matrix.y0 / pattern->matrix.yy);

    if (pattern->matrix.yx != 0.0 ||
        pattern->matrix.xy != 0.0 ||
        !_cairo_fixed_is_integer(x0_fixed) ||
        !_cairo_fixed_is_integer(y0_fixed))
    {
        goto UNSUPPORTED;
    }

    scalex = pattern->matrix.xx;
    scaley = pattern->matrix.yy;

    src_r.x += _cairo_fixed_integer_part(x0_fixed);
    src_r.y += _cairo_fixed_integer_part(y0_fixed);

    /* Success, right? */
    if (scalex == 0.0 || scaley == 0.0)
        return CAIRO_STATUS_SUCCESS;

    if (scalex != 1.0 || scaley != 1.0)
        goto UNSUPPORTED;

    /* If the src coordinates are outside of the source surface bounds,
     * we have to fix them up, because this is an error for the GDI
     * functions.
     */


#ifdef DEBUG_COMPOSITE
    fprintf (stderr, "before: [%d %d %d %d] -> [%d %d %d %d]\n",
             src_r.x, src_r.y, src_r.width, src_r.height,
             dst_r.x, dst_r.y, dst_r.width, dst_r.height);
    fflush (stderr);
#endif

    /* If the src rectangle doesn't wholly lie within the src extents,
     * fudge things.  We really need to do fixup on the unpainted
     * region -- e.g. the SOURCE operator is broken for areas outside
     * of the extents, because it won't clear that area to transparent
     * black.
     */


    if (pattern->extend != CAIRO_EXTEND_REPEAT) {
        needs_repeat = FALSE;

        /* If the src rect and the extents of the source image don't overlap at all,
         * we can't do anything useful here.
         */

        if (src_r.x > src_extents.width || src_r.y > src_extents.height ||
            (src_r.x + src_r.width) < 0 || (src_r.y + src_r.height) < 0)
        {
            if (op == CAIRO_OPERATOR_OVER)
                return CAIRO_STATUS_SUCCESS;
            goto UNSUPPORTED;
        }

        if (src_r.x < 0) {
            src_r.width += src_r.x;
            src_r.x = 0;

            dst_r.width += src_r.x;
            dst_r.x -= src_r.x;
        }

        if (src_r.y < 0) {
            src_r.height += src_r.y;
            src_r.y = 0;

            dst_r.height += dst_r.y;
            dst_r.y -= src_r.y;
        }

        if (src_r.x + src_r.width > src_extents.width) {
            src_r.width = src_extents.width - src_r.x;
            dst_r.width = src_r.width;
        }

        if (src_r.y + src_r.height > src_extents.height) {
            src_r.height = src_extents.height - src_r.y;
            dst_r.height = src_r.height;
        }
    } else {
        needs_repeat = TRUE;
    }

    /*
     * Operations that we can do:
     *
     *  RGB OVER  RGB -> BitBlt (same as SOURCE)
     *  RGB OVER ARGB -> UNSUPPORTED (AlphaBlend treats this as a BitBlt, even with SCA 255 and no AC_SRC_ALPHA)
     * ARGB OVER ARGB -> AlphaBlend, with AC_SRC_ALPHA
     * ARGB OVER  RGB -> AlphaBlend, with AC_SRC_ALPHA; we'll have junk in the dst A byte
     *
     *  RGB OVER  RGB + mask -> AlphaBlend, no AC_SRC_ALPHA
     *  RGB OVER ARGB + mask -> UNSUPPORTED
     * ARGB OVER ARGB + mask -> AlphaBlend, with AC_SRC_ALPHA
     * ARGB OVER  RGB + mask -> AlphaBlend, with AC_SRC_ALPHA; junk in the dst A byte
     *
     *  RGB SOURCE  RGB -> BitBlt
     *  RGB SOURCE ARGB -> UNSUPPORTED (AlphaBlend treats this as a BitBlt, even with SCA 255 and no AC_SRC_ALPHA)
     * ARGB SOURCE ARGB -> BitBlt
     * ARGB SOURCE  RGB -> BitBlt
     *
     *  RGB SOURCE  RGB + mask -> unsupported
     *  RGB SOURCE ARGB + mask -> unsupported
     * ARGB SOURCE ARGB + mask -> unsupported
     * ARGB SOURCE  RGB + mask -> unsupported
     */


    /*
     * Figure out what action to take.
     */

    if (op == CAIRO_OPERATOR_OVER) {
        if (alpha == 0)
            return CAIRO_STATUS_SUCCESS;

        if (src_format == dst->format) {
            if (alpha == 255 && src_format == CAIRO_FORMAT_RGB24) {
                needs_alpha = FALSE;
            } else {
                needs_alpha = TRUE;
            }
        } else if (src_format == CAIRO_FORMAT_ARGB32 &&
                   dst->format == CAIRO_FORMAT_RGB24)
        {
            needs_alpha = TRUE;
        } else {
            goto UNSUPPORTED;
        }
    } else if (alpha == 255 && op == CAIRO_OPERATOR_SOURCE) {
        if ((src_format == dst->format) ||
            (src_format == CAIRO_FORMAT_ARGB32 && dst->format == CAIRO_FORMAT_RGB24))
        {
            needs_alpha = FALSE;
        } else {
            goto UNSUPPORTED;
        }
    } else {
        goto UNSUPPORTED;
    }

    if (scalex == 1.0 && scaley == 1.0) {
        needs_scale = FALSE;
    } else {
        /* Should never be reached until we turn StretchBlt back on */
        needs_scale = TRUE;
    }

#ifdef DEBUG_COMPOSITE
    fprintf (stderr, "action: [%d %d %d %d] -> [%d %d %d %d]\n",
             src_r.x, src_r.y, src_r.width, src_r.height,
             dst_r.x, dst_r.y, dst_r.width, dst_r.height);
    fflush (stderr);
#endif

    status = _cairo_win32_surface_set_clip_region (dst, clip_region);
    if (status)
        return status;

    /* If we need to repeat, we turn the repeated blit into
     * a bunch of piece-by-piece blits.
     */

    if (needs_repeat) {
        cairo_rectangle_int_t piece_src_r, piece_dst_r;
        uint32_t rendered_width = 0, rendered_height = 0;
        uint32_t to_render_height, to_render_width;
        int32_t piece_x, piece_y;
        int32_t src_start_x = MOD(src_r.x, src_extents.width);
        int32_t src_start_y = MOD(src_r.y, src_extents.height);

        if (needs_scale)
            goto UNSUPPORTED;

        /* If both the src and dest have an image, we may as well fall
         * back, because it will be faster than our separate blits.
         * Our blit code will be fastest when the src is a DDB and the
         * destination is a DDB.
         */

        if ((src_image || src->image) && dst->image)
            goto UNSUPPORTED;

        /* If the src is not a bitmap but an on-screen (or unknown)
         * DC, chances are that fallback will be faster.
         */

        if (src->bitmap == NULL)
            goto UNSUPPORTED;

        /* If we can use PatBlt, just do so */
        if (!src_image && !needs_alpha)
        {
            HBRUSH brush;
            HGDIOBJ old_brush;
            POINT old_brush_origin;

            /* Set up the brush with our bitmap */
            brush = CreatePatternBrush (src->bitmap);

            /* SetBrushOrgEx sets the coordinates in the destination DC of where the
             * pattern should start.
             */

            SetBrushOrgEx (dst->dc, dst_r.x - src_start_x,
                           dst_r.y - src_start_y, &old_brush_origin);

            old_brush = SelectObject (dst->dc, brush);

            PatBlt (dst->dc, dst_r.x, dst_r.y, dst_r.width, dst_r.height, PATCOPY);

            /* Restore the old brush and pen */
            SetBrushOrgEx (dst->dc, old_brush_origin.x, old_brush_origin.y, NULL);
            SelectObject (dst->dc, old_brush);
            DeleteObject (brush);

            return CAIRO_STATUS_SUCCESS;
        }

        /* If we were not able to use PatBlt, then manually expand out the blit */

        /* Arbitrary factor; we think that going through
         * fallback will be faster if we have to do more
         * than this amount of blits in either direction.
         */

        if (dst_r.width / src_extents.width > 5 ||
            dst_r.height / src_extents.height > 5)
            goto UNSUPPORTED;

        for (rendered_height = 0;
             rendered_height < dst_r.height;
             rendered_height += to_render_height)
        {
            piece_y = (src_start_y + rendered_height) % src_extents.height;
            to_render_height = src_extents.height - piece_y;

            if (rendered_height + to_render_height > dst_r.height)
                to_render_height = dst_r.height - rendered_height;

            for (rendered_width = 0;
                 rendered_width < dst_r.width;
                 rendered_width += to_render_width)
            {
                piece_x = (src_start_x + rendered_width) % src_extents.width;
                to_render_width = src_extents.width - piece_x;

                if (rendered_width + to_render_width > dst_r.width)
                    to_render_width = dst_r.width - rendered_width;

                piece_src_r.x = piece_x;
                piece_src_r.y = piece_y;
                piece_src_r.width = to_render_width;
                piece_src_r.height = to_render_height;

                piece_dst_r.x = dst_r.x + rendered_width;
                piece_dst_r.y = dst_r.y + rendered_height;
                piece_dst_r.width = to_render_width;
                piece_dst_r.height = to_render_height;

                status = _cairo_win32_surface_composite_inner (src, src_image, dst,
                                                               src_extents, piece_src_r, piece_dst_r,
                                                               alpha, needs_alpha, needs_scale);
                if (status != CAIRO_STATUS_SUCCESS) {
                    /* Uh oh.  If something failed, and it's the first
                     * piece, then we can jump to UNSUPPORTED.
                     * Otherwise, this is bad times, because part of the
                     * rendering was already done. */

                    if (rendered_width == 0 &&
                        rendered_height == 0)
                    {
                        goto UNSUPPORTED;
                    }

                    return status;
                }
            }
        }
    } else {
        status = _cairo_win32_surface_composite_inner (src, src_image, dst,
                                                       src_extents, src_r, dst_r,
                                                       alpha, needs_alpha, needs_scale);
    }

    if (status == CAIRO_STATUS_SUCCESS)
        return status;

UNSUPPORTED:
    /* Fall back to image surface directly, if this is a DIB surface */
    if (dst->image) {
        GdiFlush();

        return dst->image->backend->composite (op, pattern, mask_pattern,
                                               dst->image,
                                               src_x, src_y,
                                               mask_x, mask_y,
                                               dst_x, dst_y,
                                               width, height,
                                               clip_region);
    }

    return CAIRO_INT_STATUS_UNSUPPORTED;
}

/* This big function tells us how to optimize operators for the
 * case of solid destination and constant-alpha source
 *
 * Note: This function needs revisiting if we add support for
 *       super-luminescent colors (a == 0, r,g,b > 0)
 */

static enum { DO_CLEAR, DO_SOURCE, DO_NOTHING, DO_UNSUPPORTED }
categorize_solid_dest_operator (cairo_operator_t op,
                                unsigned short   alpha)
{
    enum { SOURCE_TRANSPARENT, SOURCE_LIGHT, SOURCE_SOLID, SOURCE_OTHER } source;

    if (alpha >= 0xff00)
        source = SOURCE_SOLID;
    else if (alpha < 0x100)
        source = SOURCE_TRANSPARENT;
    else
        source = SOURCE_OTHER;

    switch (op) {
    case CAIRO_OPERATOR_CLEAR:    /* 0                 0 */
    case CAIRO_OPERATOR_OUT:      /* 1 - Ab            0 */
        return DO_CLEAR;
        break;

    case CAIRO_OPERATOR_SOURCE:   /* 1                 0 */
    case CAIRO_OPERATOR_IN:       /* Ab                0 */
        return DO_SOURCE;
        break;

    case CAIRO_OPERATOR_OVER:     /* 1            1 - Aa */
    case CAIRO_OPERATOR_ATOP:     /* Ab           1 - Aa */
        if (source == SOURCE_SOLID)
            return DO_SOURCE;
        else if (source == SOURCE_TRANSPARENT)
            return DO_NOTHING;
        else
            return DO_UNSUPPORTED;
        break;

    case CAIRO_OPERATOR_DEST_OUT: /* 0            1 - Aa */
    case CAIRO_OPERATOR_XOR:      /* 1 - Ab       1 - Aa */
        if (source == SOURCE_SOLID)
            return DO_CLEAR;
        else if (source == SOURCE_TRANSPARENT)
            return DO_NOTHING;
        else
            return DO_UNSUPPORTED;
        break;

    case CAIRO_OPERATOR_DEST:     /* 0                 1 */
    case CAIRO_OPERATOR_DEST_OVER:/* 1 - Ab            1 */
    case CAIRO_OPERATOR_SATURATE: /* min(1,(1-Ab)/Aa)  1 */
        return DO_NOTHING;
        break;

    case CAIRO_OPERATOR_DEST_IN:  /* 0                Aa */
    case CAIRO_OPERATOR_DEST_ATOP:/* 1 - Ab           Aa */
        if (source == SOURCE_SOLID)
            return DO_NOTHING;
        else if (source == SOURCE_TRANSPARENT)
            return DO_CLEAR;
        else
            return DO_UNSUPPORTED;
        break;

    case CAIRO_OPERATOR_ADD:      /* 1                1 */
        if (source == SOURCE_TRANSPARENT)
            return DO_NOTHING;
        else
            return DO_UNSUPPORTED;
        break;
    }

    ASSERT_NOT_REACHED;
    return DO_UNSUPPORTED;
}

static cairo_int_status_t
_cairo_win32_surface_fill_rectangles (void                      *abstract_surface,
                                      cairo_operator_t          op,
                                      const cairo_color_t       *color,
                                      cairo_rectangle_int_t     *rects,
                                      int                       num_rects)
{
    cairo_win32_surface_t *surface = abstract_surface;
    cairo_status_t status;
    COLORREF new_color;
    HBRUSH new_brush;
    int i;

    /* XXXperf If it's not RGB24, we need to do a little more checking
     * to figure out when we can use GDI.  We don't have that checking
     * anywhere at the moment, so just bail and use the fallback
     * paths. */

    if (surface->format != CAIRO_FORMAT_RGB24)
        return CAIRO_INT_STATUS_UNSUPPORTED;

    status = _cairo_win32_surface_set_clip_region (surface, NULL);
    if (status)
        return status;

    /* Optimize for no destination alpha (surface->pixman_image is non-NULL for all
     * surfaces with alpha.)
     */

    switch (categorize_solid_dest_operator (op, color->alpha_short)) {
    case DO_CLEAR:
        new_color = RGB (0, 0, 0);
        break;
    case DO_SOURCE:
        new_color = RGB (color->red_short >> 8, color->green_short >> 8, color->blue_short >> 8);
        break;
    case DO_NOTHING:
        return CAIRO_STATUS_SUCCESS;
    case DO_UNSUPPORTED:
    default:
        return CAIRO_INT_STATUS_UNSUPPORTED;
    }

    new_brush = CreateSolidBrush (new_color);
    if (!new_brush)
        return _cairo_win32_print_gdi_error ("_cairo_win32_surface_fill_rectangles");

    for (i = 0; i < num_rects; i++) {
        RECT rect;

        rect.left = rects[i].x;
        rect.top = rects[i].y;
        rect.right = rects[i].x + rects[i].width;
        rect.bottom = rects[i].y + rects[i].height;

        if (!FillRect (surface->dc, &rect, new_brush))
            goto FAIL;
    }

    DeleteObject (new_brush);

    return CAIRO_STATUS_SUCCESS;

 FAIL:
    status = _cairo_win32_print_gdi_error ("_cairo_win32_surface_fill_rectangles");

    DeleteObject (new_brush);

    return status;
}

cairo_bool_t
_cairo_win32_surface_get_extents (void                    *abstract_surface,
                                  cairo_rectangle_int_t   *rectangle)
{
    cairo_win32_surface_t *surface = abstract_surface;

    *rectangle = surface->extents;
    return TRUE;
}

static cairo_status_t
_cairo_win32_surface_flush (void *abstract_surface)
{
    return _cairo_win32_surface_set_clip_region (abstract_surface, NULL);
}

#define STACK_GLYPH_SIZE 256

cairo_int_status_t
_cairo_win32_surface_show_glyphs (void                  *surface,
                                  cairo_operator_t       op,
                                  const cairo_pattern_t *source,
                                  cairo_glyph_t         *glyphs,
                                  int                    num_glyphs,
                                  cairo_scaled_font_t   *scaled_font,
                                  cairo_clip_t          *clip,
                                  int                   *remaining_glyphs)
{
#if CAIRO_HAS_WIN32_FONT
    cairo_win32_surface_t *dst = surface;

    WORD glyph_buf_stack[STACK_GLYPH_SIZE];
    WORD *glyph_buf = glyph_buf_stack;
    int dxy_buf_stack[2 * STACK_GLYPH_SIZE];
    int *dxy_buf = dxy_buf_stack;

    BOOL win_result = 0;
    int i, j;

    cairo_solid_pattern_t *solid_pattern;
    COLORREF color;

    cairo_matrix_t device_to_logical;

    int start_x, start_y;
    double user_x, user_y;
    int logical_x, logical_y;
    unsigned int glyph_index_option;

    /* We can only handle win32 fonts */
    if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_WIN32)
        return CAIRO_INT_STATUS_UNSUPPORTED;

    /* We can only handle opaque solid color sources */
    if (!_cairo_pattern_is_opaque_solid(source))
        return CAIRO_INT_STATUS_UNSUPPORTED;

    /* We can only handle operator SOURCE or OVER with the destination
     * having no alpha */

    if ((op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_OVER) ||
        (dst->format != CAIRO_FORMAT_RGB24))
        return CAIRO_INT_STATUS_UNSUPPORTED;

    /* If we have a fallback mask clip set on the dst, we have
     * to go through the fallback path, but only if we're not
     * doing this for printing */

    if (clip != NULL) {
        if ((dst->flags & CAIRO_WIN32_SURFACE_FOR_PRINTING) == 0) {
            cairo_region_t *clip_region;
            cairo_status_t status;

            status = _cairo_clip_get_region (clip, &clip_region);
            assert (status != CAIRO_INT_STATUS_NOTHING_TO_DO);
            if (status)
                return status;

            _cairo_win32_surface_set_clip_region (surface, clip_region);
        }
    }

    solid_pattern = (cairo_solid_pattern_t *)source;
    color = RGB(((int)solid_pattern->color.red_short) >> 8,
                ((int)solid_pattern->color.green_short) >> 8,
                ((int)solid_pattern->color.blue_short) >> 8);

    cairo_win32_scaled_font_get_device_to_logical(scaled_font, &device_to_logical);

    SaveDC(dst->dc);

    cairo_win32_scaled_font_select_font(scaled_font, dst->dc);
    SetTextColor(dst->dc, color);
    SetTextAlign(dst->dc, TA_BASELINE | TA_LEFT);
    SetBkMode(dst->dc, TRANSPARENT);

    if (num_glyphs > STACK_GLYPH_SIZE) {
        glyph_buf = (WORD *) _cairo_malloc_ab (num_glyphs, sizeof(WORD));
        dxy_buf = (int *) _cairo_malloc_abc (num_glyphs, sizeof(int), 2);
    }

    /* It is vital that dx values for dxy_buf are calculated from the delta of
     * _logical_ x coordinates (not user x coordinates) or else the sum of all
     * previous dx values may start to diverge from the current glyph's x
     * coordinate due to accumulated rounding error. As a result strings could
     * be painted shorter or longer than expected. */


    user_x = glyphs[0].x;
    user_y = glyphs[0].y;

    cairo_matrix_transform_point(&device_to_logical,
                                 &user_x, &user_y);

    logical_x = _cairo_lround (user_x);
    logical_y = _cairo_lround (user_y);

    start_x = logical_x;
    start_y = logical_y;

    for (i = 0, j = 0; i < num_glyphs; ++i, j = 2 * i) {
        glyph_buf[i] = (WORD) glyphs[i].index;
        if (i == num_glyphs - 1) {
            dxy_buf[j] = 0;
            dxy_buf[j+1] = 0;
        } else {
            double next_user_x = glyphs[i+1].x;
            double next_user_y = glyphs[i+1].y;
            int next_logical_x, next_logical_y;

            cairo_matrix_transform_point(&device_to_logical,
                                         &next_user_x, &next_user_y);

            next_logical_x = _cairo_lround (next_user_x);
            next_logical_y = _cairo_lround (next_user_y);

            dxy_buf[j] = _cairo_lround (next_logical_x - logical_x);
            dxy_buf[j+1] = _cairo_lround (next_logical_y - logical_y);

            logical_x = next_logical_x;
            logical_y = next_logical_y;
        }
    }

    /* Using glyph indices for a Type 1 font does not work on a
     * printer DC. The win32 printing surface will convert the the
     * glyph indices of Type 1 fonts to the unicode values.
     */

    if ((dst->flags & CAIRO_WIN32_SURFACE_FOR_PRINTING) &&
        _cairo_win32_scaled_font_is_type1 (scaled_font))
    {
        glyph_index_option = 0;
    }
    else
    {
        glyph_index_option = ETO_GLYPH_INDEX;
    }

    win_result = ExtTextOutW(dst->dc,
                             start_x,
                             start_y,
                             glyph_index_option | ETO_PDY,
                             NULL,
                             glyph_buf,
                             num_glyphs,
                             dxy_buf);
    if (!win_result) {
        _cairo_win32_print_gdi_error("_cairo_win32_surface_show_glyphs(ExtTextOutW failed)");
    }

    RestoreDC(dst->dc, -1);

    if (glyph_buf != glyph_buf_stack) {
        free(glyph_buf);
        free(dxy_buf);
    }
    return (win_result) ? CAIRO_STATUS_SUCCESS : CAIRO_INT_STATUS_UNSUPPORTED;
#else
    return CAIRO_INT_STATUS_UNSUPPORTED;
#endif
}

#undef STACK_GLYPH_SIZE

/**
 * cairo_win32_surface_create:
 * @hdc: the DC to create a surface for
 *
 * Creates a cairo surface that targets the given DC.  The DC will be
 * queried for its initial clip extents, and this will be used as the
 * size of the cairo surface.  The resulting surface will always be of
 * format %CAIRO_FORMAT_RGB24; should you need another surface format,
 * you will need to create one through
 * cairo_win32_surface_create_with_dib().
 *
 * Return value: the newly created surface
 **/

cairo_surface_t *
cairo_win32_surface_create (HDC hdc)
{
    cairo_win32_surface_t *surface;

    cairo_format_t format;
    RECT rect;

    /* Assume that everything coming in as a HDC is RGB24 */
    format = CAIRO_FORMAT_RGB24;

    surface = malloc (sizeof (cairo_win32_surface_t));
    if (surface == NULL)
        return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

    if (_cairo_win32_save_initial_clip (hdc, surface) != CAIRO_STATUS_SUCCESS) {
        free (surface);
        return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
    }

    surface->clip_region = NULL;
    surface->image = NULL;
    surface->format = format;

    surface->dc = hdc;
    surface->bitmap = NULL;
    surface->is_dib = FALSE;
    surface->saved_dc_bitmap = NULL;
    surface->brush = NULL;
    surface->old_brush = NULL;
    surface->font_subsets = NULL;

    GetClipBox(hdc, &rect);
    surface->extents.x = rect.left;
    surface->extents.y = rect.top;
    surface->extents.width = rect.right - rect.left;
    surface->extents.height = rect.bottom - rect.top;

    surface->flags = _cairo_win32_flags_for_dc (surface->dc);

    _cairo_surface_init (&surface->base, &cairo_win32_surface_backend,
                         _cairo_content_from_format (format));

    return (cairo_surface_t *)surface;
}

/**
 * cairo_win32_surface_create_with_dib:
 * @format: format of pixels in the surface to create
 * @width: width of the surface, in pixels
 * @height: height of the surface, in pixels
 *
 * Creates a device-independent-bitmap surface not associated with
 * any particular existing surface or device context. The created
 * bitmap will be uninitialized.
 *
 * Return value: the newly created surface
 *
 * Since: 1.2
 **/

cairo_surface_t *
cairo_win32_surface_create_with_dib (cairo_format_t format,
                                     int            width,
                                     int            height)
{
    return _cairo_win32_surface_create_for_dc (NULL, format, width, height);
}

/**
 * cairo_win32_surface_create_with_ddb:
 * @hdc: the DC to create a surface for
 * @format: format of pixels in the surface to create
 * @width: width of the surface, in pixels
 * @height: height of the surface, in pixels
 *
 * Creates a device-independent-bitmap surface not associated with
 * any particular existing surface or device context. The created
 * bitmap will be uninitialized.
 *
 * Return value: the newly created surface
 *
 * Since: 1.4
 **/

cairo_surface_t *
cairo_win32_surface_create_with_ddb (HDC hdc,
                                     cairo_format_t format,
                                     int width,
                                     int height)
{
    cairo_win32_surface_t *new_surf;
    HBITMAP ddb;
    HDC screen_dc, ddb_dc;
    HBITMAP saved_dc_bitmap;

    if (format != CAIRO_FORMAT_RGB24)
        return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
/* XXX handle these eventually
        format != CAIRO_FORMAT_A8 ||
        format != CAIRO_FORMAT_A1)
*/


    if (!hdc) {
        screen_dc = GetDC (NULL);
        hdc = screen_dc;
    } else {
        screen_dc = NULL;
    }

    ddb_dc = CreateCompatibleDC (hdc);
    if (ddb_dc == NULL) {
        new_surf = (cairo_win32_surface_t*) _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
        goto FINISH;
    }

    ddb = CreateCompatibleBitmap (hdc, width, height);
    if (ddb == NULL) {
        DeleteDC (ddb_dc);

        /* Note that if an app actually does hit this out of memory
         * condition, it's going to have lots of other issues, as
         * video memory is probably exhausted.  However, it can often
         * continue using DIBs instead of DDBs.
         */

        new_surf = (cairo_win32_surface_t*) _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
        goto FINISH;
    }

    saved_dc_bitmap = SelectObject (ddb_dc, ddb);

    new_surf = (cairo_win32_surface_t*) cairo_win32_surface_create (ddb_dc);
    new_surf->bitmap = ddb;
    new_surf->saved_dc_bitmap = saved_dc_bitmap;
    new_surf->is_dib = FALSE;

FINISH:
    if (screen_dc)
        ReleaseDC (NULL, screen_dc);

    return (cairo_surface_t*) new_surf;
}

/**
 * _cairo_surface_is_win32:
 * @surface: a #cairo_surface_t
 *
 * Checks if a surface is a win32 surface.  This will
 * return False if this is a win32 printing surface; use
 * _cairo_surface_is_win32_printing() to check for that.
 *
 * Return value: True if the surface is an win32 surface
 **/

int
_cairo_surface_is_win32 (cairo_surface_t *surface)
{
    return surface->backend == &cairo_win32_surface_backend;
}

/**
 * cairo_win32_surface_get_dc
 * @surface: a #cairo_surface_t
 *
 * Returns the HDC associated with this surface, or %NULL if none.
 * Also returns %NULL if the surface is not a win32 surface.
 *
 * Return value: HDC or %NULL if no HDC available.
 *
 * Since: 1.2
 **/

HDC
cairo_win32_surface_get_dc (cairo_surface_t *surface)
{
    cairo_win32_surface_t *winsurf;

    if (_cairo_surface_is_win32 (surface)){
        winsurf = (cairo_win32_surface_t *) surface;

        return winsurf->dc;
    }

    if (_cairo_surface_is_paginated (surface)) {
        cairo_surface_t *target;

        target = _cairo_paginated_surface_get_target (surface);

        if (_cairo_surface_is_win32_printing (target)) {
            winsurf = (cairo_win32_surface_t *) target;

            return winsurf->dc;
        }
    }

    return NULL;
}

/**
 * cairo_win32_surface_get_image
 * @surface: a #cairo_surface_t
 *
 * Returns a #cairo_surface_t image surface that refers to the same bits
 * as the DIB of the Win32 surface.  If the passed-in win32 surface
 * is not a DIB surface, %NULL is returned.
 *
 * Return value: a #cairo_surface_t (owned by the win32 #cairo_surface_t),
 * or %NULL if the win32 surface is not a DIB.
 *
 * Since: 1.4
 */

cairo_surface_t *
cairo_win32_surface_get_image (cairo_surface_t *surface)
{
    if (!_cairo_surface_is_win32(surface))
        return NULL;

    return ((cairo_win32_surface_t*)surface)->image;
}

static cairo_bool_t
_cairo_win32_surface_is_similar (void *surface_a,
                                 void *surface_b,
                                 cairo_content_t content)
{
    cairo_win32_surface_t *a = surface_a;
    cairo_win32_surface_t *b = surface_b;

    return a->dc == b->dc;
}

typedef struct _cairo_win32_surface_span_renderer {
    cairo_span_renderer_t base;

    cairo_operator_t op;
    const cairo_pattern_t *pattern;
    cairo_antialias_t antialias;

    cairo_image_surface_t *mask;
    cairo_win32_surface_t *dst;
    cairo_region_t *clip_region;

    cairo_composite_rectangles_t composite_rectangles;
} cairo_win32_surface_span_renderer_t;

static cairo_status_t
_cairo_win32_surface_span_renderer_render_row (
    void                                *abstract_renderer,
    int                                  y,
    const cairo_half_open_span_t        *spans,
    unsigned                             num_spans)
{
    cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
    _cairo_image_surface_span_render_row (y, spans, num_spans, renderer->mask, &renderer->composite_rectangles);
    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_win32_surface_span_renderer_destroy (void *abstract_renderer)
{
    cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
    if (!renderer) return;

    if (renderer->mask != NULL)
        cairo_surface_destroy (&renderer->mask->base);

    free (renderer);
}

static cairo_status_t
_cairo_win32_surface_span_renderer_finish (void *abstract_renderer)
{
    cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
    cairo_status_t status = CAIRO_STATUS_SUCCESS;

    if (renderer->pattern == NULL || renderer->mask == NULL)
        return CAIRO_STATUS_SUCCESS;

    status = cairo_surface_status (&renderer->mask->base);
    if (status == CAIRO_STATUS_SUCCESS) {
        cairo_composite_rectangles_t *rects = &renderer->composite_rectangles;
        cairo_win32_surface_t *dst = renderer->dst;
        cairo_pattern_t *mask_pattern = cairo_pattern_create_for_surface (&renderer->mask->base);
        /* composite onto the image surface directly if we can */
        if (dst->image) {
            GdiFlush(); /* XXX: I'm not sure if this needed or not */

            status = dst->image->backend->composite (renderer->op,
                    renderer->pattern, mask_pattern, dst->image,
                    rects->src.x,
                    rects->src.y,
                    0, 0,               /* mask.x, mask.y */
                    rects->dst.x, rects->dst.y,
                    rects->width, rects->height,
                    renderer->clip_region);
        } else {
            /* otherwise go through the fallback_composite path which
             * will do the appropriate surface acquisition */

            status = _cairo_surface_fallback_composite (
                    renderer->op,
                    renderer->pattern, mask_pattern, &dst->base,
                    rects->src.x,
                    rects->src.y,
                    0, 0,               /* mask.x, mask.y */
                    rects->dst.x, rects->dst.y,
                    rects->width, rects->height,
                    renderer->clip_region);
        }
        cairo_pattern_destroy (mask_pattern);

    }
    if (status != CAIRO_STATUS_SUCCESS)
        return _cairo_span_renderer_set_error (abstract_renderer,
                                               status);
    return CAIRO_STATUS_SUCCESS;
}

static cairo_bool_t
_cairo_win32_surface_check_span_renderer (cairo_operator_t        op,
                                          const cairo_pattern_t  *pattern,
                                          void                   *abstract_dst,
                                          cairo_antialias_t       antialias)
{
    (void) op;
    (void) pattern;
    (void) abstract_dst;
    (void) antialias;
    return TRUE;
}

static cairo_span_renderer_t *
_cairo_win32_surface_create_span_renderer (cairo_operator_t      op,
                                           const cairo_pattern_t  *pattern,
                                           void                 *abstract_dst,
                                           cairo_antialias_t     antialias,
                                           const cairo_composite_rectangles_t *rects,
                                           cairo_region_t       *clip_region)
{
    cairo_win32_surface_t *dst = abstract_dst;
    cairo_win32_surface_span_renderer_t *renderer;
    cairo_status_t status;
    int width = rects->width;
    int height = rects->height;

    renderer = calloc(1, sizeof(*renderer));
    if (renderer == NULL)
        return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY);

    renderer->base.destroy = _cairo_win32_surface_span_renderer_destroy;
    renderer->base.finish = _cairo_win32_surface_span_renderer_finish;
    renderer->base.render_row =
        _cairo_win32_surface_span_renderer_render_row;
    renderer->op = op;
    renderer->pattern = pattern;
    renderer->antialias = antialias;
    renderer->dst = dst;
    renderer->clip_region = clip_region;

    renderer->composite_rectangles = *rects;

    /* TODO: support rendering to A1 surfaces (or: go add span
     * compositing to pixman.) */

    renderer->mask = (cairo_image_surface_t *)
        cairo_image_surface_create (CAIRO_FORMAT_A8,
                                    width, height);

    status = cairo_surface_status (&renderer->mask->base);

    if (status != CAIRO_STATUS_SUCCESS) {
        _cairo_win32_surface_span_renderer_destroy (renderer);
        return _cairo_span_renderer_create_in_error (status);
    }
    return &renderer->base;
}


static const cairo_surface_backend_t cairo_win32_surface_backend = {
    CAIRO_SURFACE_TYPE_WIN32,
    _cairo_win32_surface_create_similar,
    _cairo_win32_surface_finish,
    _cairo_win32_surface_acquire_source_image,
    _cairo_win32_surface_release_source_image,
    _cairo_win32_surface_acquire_dest_image,
    _cairo_win32_surface_release_dest_image,
    NULL, /* clone similar */
    _cairo_win32_surface_composite,
    _cairo_win32_surface_fill_rectangles,
    NULL, /* composite_trapezoids */
    _cairo_win32_surface_create_span_renderer,
    _cairo_win32_surface_check_span_renderer,
    NULL, /* copy_page */
    NULL, /* show_page */
    _cairo_win32_surface_get_extents,
    NULL, /* old_show_glyphs */
    NULL, /* get_font_options */
    _cairo_win32_surface_flush,
    NULL, /* mark_dirty_rectangle */
    NULL, /* scaled_font_fini */
    NULL, /* scaled_glyph_fini */

    NULL, /* paint */
    NULL, /* mask */
    NULL, /* stroke */
    NULL, /* fill */
    _cairo_win32_surface_show_glyphs,

    NULL,  /* snapshot */
    _cairo_win32_surface_is_similar,
};

/* Notes:
 *
 * Win32 alpha-understanding functions
 *
 * BitBlt - will copy full 32 bits from a 32bpp DIB to result
 *          (so it's safe to use for ARGB32->ARGB32 SOURCE blits)
 *          (but not safe going RGB24->ARGB32, if RGB24 is also represented
 *           as a 32bpp DIB, since the alpha isn't discarded!)
 *
 * AlphaBlend - if both the source and dest have alpha, even if AC_SRC_ALPHA isn't set,
 *              it will still copy over the src alpha, because the SCA value (255) will be
 *              multiplied by all the src components.
 */



cairo_int_status_t
_cairo_win32_save_initial_clip (HDC hdc, cairo_win32_surface_t *surface)
{
    RECT rect;
    int clipBoxType;
    int gm;
    XFORM saved_xform;

    /* GetClipBox/GetClipRgn and friends interact badly with a world transform
     * set.  GetClipBox returns values in logical (transformed) coordinates;
     * it's unclear what GetClipRgn returns, because the region is empty in the
     * case of a SIMPLEREGION clip, but I assume device (untransformed) coordinates.
     * Similarily, IntersectClipRect works in logical units, whereas SelectClipRgn
     * works in device units.
     *
     * So, avoid the whole mess and get rid of the world transform
     * while we store our initial data and when we restore initial coordinates.
     *
     * XXX we may need to modify x/y by the ViewportOrg or WindowOrg
     * here in GM_COMPATIBLE; unclear.
     */

    gm = GetGraphicsMode (hdc);
    if (gm == GM_ADVANCED) {
        GetWorldTransform (hdc, &saved_xform);
        ModifyWorldTransform (hdc, NULL, MWT_IDENTITY);
    }

    clipBoxType = GetClipBox (hdc, &rect);
    if (clipBoxType == ERROR) {
        _cairo_win32_print_gdi_error ("cairo_win32_surface_create");
        SetGraphicsMode (hdc, gm);
        /* XXX: Can we make a more reasonable guess at the error cause here? */
        return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    surface->clip_rect.x = rect.left;
    surface->clip_rect.y = rect.top;
    surface->clip_rect.width = rect.right - rect.left;
    surface->clip_rect.height = rect.bottom - rect.top;

    surface->initial_clip_rgn = NULL;
    surface->had_simple_clip = FALSE;

    if (clipBoxType == COMPLEXREGION) {
        surface->initial_clip_rgn = CreateRectRgn (0, 0, 0, 0);
        if (GetClipRgn (hdc, surface->initial_clip_rgn) <= 0) {
            DeleteObject(surface->initial_clip_rgn);
            surface->initial_clip_rgn = NULL;
        }
    } else if (clipBoxType == SIMPLEREGION) {
        surface->had_simple_clip = TRUE;
    }

    if (gm == GM_ADVANCED)
        SetWorldTransform (hdc, &saved_xform);

    return CAIRO_STATUS_SUCCESS;
}

cairo_int_status_t
_cairo_win32_restore_initial_clip (cairo_win32_surface_t *surface)
{
    cairo_int_status_t status = CAIRO_STATUS_SUCCESS;

    XFORM saved_xform;
    int gm = GetGraphicsMode (surface->dc);
    if (gm == GM_ADVANCED) {
        GetWorldTransform (surface->dc, &saved_xform);
        ModifyWorldTransform (surface->dc, NULL, MWT_IDENTITY);
    }

    /* initial_clip_rgn will either be a real region or NULL (which means reset to no clip region) */
    SelectClipRgn (surface->dc, surface->initial_clip_rgn);

    if (surface->had_simple_clip) {
        /* then if we had a simple clip, intersect */
        IntersectClipRect (surface->dc,
                           surface->clip_rect.x,
                           surface->clip_rect.y,
                           surface->clip_rect.x + surface->clip_rect.width,
                           surface->clip_rect.y + surface->clip_rect.height);
    }

    if (gm == GM_ADVANCED)
        SetWorldTransform (surface->dc, &saved_xform);

    return status;
}

void
_cairo_win32_debug_dump_hrgn (HRGN rgn, char *header)
{
    RGNDATA *rd;
    unsigned int z;

    if (header)
        fprintf (stderr, "%s\n", header);

    if (rgn == NULL) {
        fprintf (stderr, " NULL\n");
    }

    z = GetRegionData(rgn, 0, NULL);
    rd = (RGNDATA*) malloc(z);
    z = GetRegionData(rgn, z, rd);

    fprintf (stderr, " %ld rects, bounds: %ld %ld %ld %ld\n",
             rd->rdh.nCount,
             rd->rdh.rcBound.left,
             rd->rdh.rcBound.top,
             rd->rdh.rcBound.right - rd->rdh.rcBound.left,
             rd->rdh.rcBound.bottom - rd->rdh.rcBound.top);

    for (z = 0; z < rd->rdh.nCount; z++) {
        RECT r = ((RECT*)rd->Buffer)[z];
        fprintf (stderr, " [%d]: [%ld %ld %ld %ld]\n",
                 z, r.left, r.top, r.right - r.left, r.bottom - r.top);
    }

    free(rd);
    fflush (stderr);
}