Subversion Repositories Scribus

Compare Revisions

Ignore whitespace Rev 16123 → Rev 16124

/trunk/Scribus/scribus/third_party/cairo/cairo-win32-surface.c
0,0 → 1,2180
/* -*- 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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),
(LPSTR) &lpMsgBuf,
0, NULL)) {
fprintf (stderr, "%s: Unknown GDI error", context);
} else {
fwprintf (stderr, "%S: %s", context, (char *)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) {
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);
}