text: /* -*- 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, Suite 500, Boston, MA 02110-1335, 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-composite-rectangles-private.h"
  #include "cairo-error-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))
  
  /**
   * SECTION:cairo-win32
   * @Title: Win32 Surfaces
   * @Short_Description: Microsoft Windows surface support
   * @See_Also: #cairo_surface_t
   *
   * The Microsoft Windows surface is used to render cairo graphics to
   * Microsoft Windows windows, bitmaps, and printing device contexts.
   *
   * The surface returned by cairo_win32_printing_surface_create() is of surface
   * type %CAIRO_SURFACE_TYPE_WIN32_PRINTING and is a multi-page vector surface
   * type.
   *
   * The surface returned by the other win32 constructors is of surface type
   * %CAIRO_SURFACE_TYPE_WIN32 and is a raster surface type.
   */
  
  /**
   * CAIRO_HAS_WIN32_SURFACE:
   *
   * Defined if the Microsoft Windows surface backend is available.
   * This macro can be used to conditionally compile backend-specific code.
   */
  
  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 {
  	fwprintf (stderr, L"%s: %S", context, (wchar_t *)lpMsgBuf);
  
  	LocalFree (lpMsgBuf);
      }
  
      /* 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) {
      default:
      case CAIRO_FORMAT_INVALID:
  	return _cairo_error (CAIRO_STATUS_INVALID_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;
  
      if (! CAIRO_FORMAT_VALID (format))
  	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
  
      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,
  			 NULL, /* device */
  			 _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;
       
      /* ENSO EDIT: changed the pixel format from its default 
      * CAIRO_FORMAT_RGB24 to CAIRO_FORMAT_ARGB32, because that's what 
      * TransparentWindow's underlying bitmap always uses internally. */
      format = CAIRO_FORMAT_ARGB32;
  
      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,
  			 NULL, /* device */
  			 _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_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;
  
      uint8_t *mask_data;
      uint32_t mask_stride;
  
      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_rows (
      void				*abstract_renderer,
      int					 y,
      int					 height,
      const cairo_half_open_span_t	*spans,
      unsigned				 num_spans)
  {
      cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
      while (height--)
  	_cairo_image_surface_span_render_row (y++, spans, num_spans, renderer->mask_data, renderer->mask_stride);
      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->bounded.x, rects->bounded.y,
  		    0, 0,		/* mask.x, mask.y */
  		    rects->bounded.x, rects->bounded.y,
  		    rects->bounded.width, rects->bounded.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->bounded.x, rects->bounded.y,
  		    0, 0,		/* mask.x, mask.y */
  		    rects->bounded.x, rects->bounded.y,
  		    rects->bounded.width, rects->bounded.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->bounded.width;
      int height = rects->bounded.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_rows = _cairo_win32_surface_span_renderer_render_rows;
      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);
      }
  
      renderer->mask_data = renderer->mask->data - rects->bounded.x - rects->bounded.y * renderer->mask->stride;
      renderer->mask_stride = renderer->mask->stride;
      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);
  }
  