fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2026-02-19 01:50:50 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
cairo/src/cairo_gdip_surface.cpp
Kristian Høgsberg b1ec8ae13e New PDF backend. 
Add PDF surface constructors.
New file - generic array implementation.
Add cairo_array prototypes.
Add cairo_array.c and cairo_pdf_surface.c.
2005-01-05 14:29:31 +00:00

728 lines
26 KiB
C++
Raw Blame History

/* cairo - a vector graphics library with display and print output
*
* Copyright © 2004 Stuart Parmenter
*
* 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 Stuart Parmenter.
*
* Contributor(s):
* Stuart Parmenter <pavlov@pavlov.net>
*/
extern "C" {
#include "cairo-features.h"
#include "cairoint.h"
}
/* export symbols, for cairo.dll only */
#pragma comment(linker, "/EXPORT:_cairo_create")
#pragma comment(linker, "/EXPORT:_cairo_reference")
#pragma comment(linker, "/EXPORT:_cairo_destroy")
#pragma comment(linker, "/EXPORT:_cairo_save")
#pragma comment(linker, "/EXPORT:_cairo_restore")
#pragma comment(linker, "/EXPORT:_cairo_copy")
#pragma comment(linker, "/EXPORT:_cairo_set_target_surface")
#pragma comment(linker, "/EXPORT:_cairo_set_target_image")
#ifdef CAIRO_HAS_PS_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_set_target_ps")
#endif
#ifdef CAIRO_HAS_PS_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_set_target_pdf")
#endif
#ifdef CAIRO_HAS_PNG_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_set_target_png")
#endif
#ifdef CAIRO_HAS_GL_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_set_target_gl")
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_set_target_win32")
#endif
#pragma comment(linker, "/EXPORT:_cairo_set_operator")
#pragma comment(linker, "/EXPORT:_cairo_set_rgb_color")
#pragma comment(linker, "/EXPORT:_cairo_set_pattern")
#pragma comment(linker, "/EXPORT:_cairo_set_alpha")
#pragma comment(linker, "/EXPORT:_cairo_set_tolerance")
#pragma comment(linker, "/EXPORT:_cairo_set_fill_rule")
#pragma comment(linker, "/EXPORT:_cairo_set_line_width")
#pragma comment(linker, "/EXPORT:_cairo_set_line_cap")
#pragma comment(linker, "/EXPORT:_cairo_set_line_join")
#pragma comment(linker, "/EXPORT:_cairo_set_dash")
#pragma comment(linker, "/EXPORT:_cairo_set_miter_limit")
#pragma comment(linker, "/EXPORT:_cairo_set_line_cap")
#pragma comment(linker, "/EXPORT:_cairo_translate")
#pragma comment(linker, "/EXPORT:_cairo_scale")
#pragma comment(linker, "/EXPORT:_cairo_rotate")
#pragma comment(linker, "/EXPORT:_cairo_concat_matrix")
#pragma comment(linker, "/EXPORT:_cairo_set_matrix")
#pragma comment(linker, "/EXPORT:_cairo_default_matrix")
#pragma comment(linker, "/EXPORT:_cairo_identity_matrix")
#pragma comment(linker, "/EXPORT:_cairo_transform_point")
#pragma comment(linker, "/EXPORT:_cairo_transform_distance")
#pragma comment(linker, "/EXPORT:_cairo_inverse_transform_point")
#pragma comment(linker, "/EXPORT:_cairo_inverse_transform_distance")
#pragma comment(linker, "/EXPORT:_cairo_new_path")
#pragma comment(linker, "/EXPORT:_cairo_move_to")
#pragma comment(linker, "/EXPORT:_cairo_line_to")
#pragma comment(linker, "/EXPORT:_cairo_curve_to")
#pragma comment(linker, "/EXPORT:_cairo_arc")
#pragma comment(linker, "/EXPORT:_cairo_arc_negative")
#pragma comment(linker, "/EXPORT:_cairo_rel_move_to")
#pragma comment(linker, "/EXPORT:_cairo_rel_line_to")
#pragma comment(linker, "/EXPORT:_cairo_rel_curve_to")
#pragma comment(linker, "/EXPORT:_cairo_rectangle")
#pragma comment(linker, "/EXPORT:_cairo_close_path")
#pragma comment(linker, "/EXPORT:_cairo_stroke")
#pragma comment(linker, "/EXPORT:_cairo_fill")
#pragma comment(linker, "/EXPORT:_cairo_copy_page")
#pragma comment(linker, "/EXPORT:_cairo_show_page")
#pragma comment(linker, "/EXPORT:_cairo_in_stroke")
#pragma comment(linker, "/EXPORT:_cairo_in_fill")
#pragma comment(linker, "/EXPORT:_cairo_stroke_extents")
#pragma comment(linker, "/EXPORT:_cairo_fill_extents")
#pragma comment(linker, "/EXPORT:_cairo_init_clip")
#pragma comment(linker, "/EXPORT:_cairo_clip")
#pragma comment(linker, "/EXPORT:_cairo_select_font")
#pragma comment(linker, "/EXPORT:_cairo_scale_font")
#pragma comment(linker, "/EXPORT:_cairo_transform_font")
#pragma comment(linker, "/EXPORT:_cairo_show_text")
#pragma comment(linker, "/EXPORT:_cairo_show_glyphs")
#pragma comment(linker, "/EXPORT:_cairo_current_font")
#pragma comment(linker, "/EXPORT:_cairo_current_font_extents")
#pragma comment(linker, "/EXPORT:_cairo_set_font")
#pragma comment(linker, "/EXPORT:_cairo_text_extents")
#pragma comment(linker, "/EXPORT:_cairo_glyph_extents")
#pragma comment(linker, "/EXPORT:_cairo_text_path")
#pragma comment(linker, "/EXPORT:_cairo_glyph_path")
#pragma comment(linker, "/EXPORT:_cairo_font_reference")
#pragma comment(linker, "/EXPORT:_cairo_font_destroy")
#pragma comment(linker, "/EXPORT:_cairo_font_set_transform")
#pragma comment(linker, "/EXPORT:_cairo_font_current_transform")
/*#pragma comment(linker, "/EXPORT:_cairo_ft_font_create")
#pragma comment(linker, "/EXPORT:_cairo_ft_font_create_for_ft_face")
*/
#if 0
/* hmm, this function doesn't exist, but __cairo_ft_font_destroy does */
#pragma comment(linker, "/EXPORT:_cairo_ft_font_destroy")
#endif
/*
#pragma comment(linker, "/EXPORT:_cairo_ft_font_face")
#pragma comment(linker, "/EXPORT:_cairo_ft_font_pattern")
*/
#pragma comment(linker, "/EXPORT:_cairo_show_surface")
#pragma comment(linker, "/EXPORT:_cairo_current_operator")
#pragma comment(linker, "/EXPORT:_cairo_current_rgb_color")
#pragma comment(linker, "/EXPORT:_cairo_current_pattern")
#pragma comment(linker, "/EXPORT:_cairo_current_alpha")
#pragma comment(linker, "/EXPORT:_cairo_current_tolerance")
#pragma comment(linker, "/EXPORT:_cairo_current_point")
#pragma comment(linker, "/EXPORT:_cairo_current_fill_rule")
#pragma comment(linker, "/EXPORT:_cairo_current_line_width")
#pragma comment(linker, "/EXPORT:_cairo_current_line_cap")
#pragma comment(linker, "/EXPORT:_cairo_current_line_join")
#pragma comment(linker, "/EXPORT:_cairo_current_rgb_color")
#pragma comment(linker, "/EXPORT:_cairo_current_miter_limit")
#pragma comment(linker, "/EXPORT:_cairo_current_matrix")
#pragma comment(linker, "/EXPORT:_cairo_current_target_surface")
#pragma comment(linker, "/EXPORT:_cairo_current_path")
#pragma comment(linker, "/EXPORT:_cairo_current_path_flat")
#pragma comment(linker, "/EXPORT:_cairo_status")
#pragma comment(linker, "/EXPORT:_cairo_status_string")
#pragma comment(linker, "/EXPORT:_cairo_surface_create_for_image")
#pragma comment(linker, "/EXPORT:_cairo_surface_create_similar")
#pragma comment(linker, "/EXPORT:_cairo_surface_reference")
#pragma comment(linker, "/EXPORT:_cairo_surface_destroy")
#pragma comment(linker, "/EXPORT:_cairo_surface_set_repeat")
#pragma comment(linker, "/EXPORT:_cairo_surface_set_matrix")
#pragma comment(linker, "/EXPORT:_cairo_surface_get_matrix")
#pragma comment(linker, "/EXPORT:_cairo_surface_set_filter")
#pragma comment(linker, "/EXPORT:_cairo_surface_get_filter")
#pragma comment(linker, "/EXPORT:_cairo_image_surface_create")
#pragma comment(linker, "/EXPORT:_cairo_image_surface_create_for_data")
#pragma comment(linker, "/EXPORT:_cairo_pattern_create_for_surface")
#pragma comment(linker, "/EXPORT:_cairo_pattern_create_linear")
#pragma comment(linker, "/EXPORT:_cairo_pattern_create_radial")
#pragma comment(linker, "/EXPORT:_cairo_pattern_reference")
#pragma comment(linker, "/EXPORT:_cairo_pattern_destroy")
#pragma comment(linker, "/EXPORT:_cairo_pattern_add_color_stop")
#pragma comment(linker, "/EXPORT:_cairo_pattern_set_matrix")
#pragma comment(linker, "/EXPORT:_cairo_pattern_get_matrix")
#pragma comment(linker, "/EXPORT:_cairo_pattern_set_extend")
#pragma comment(linker, "/EXPORT:_cairo_pattern_get_extend")
#pragma comment(linker, "/EXPORT:_cairo_pattern_set_filter")
#pragma comment(linker, "/EXPORT:_cairo_pattern_get_filter")
#ifdef CAIRO_HAS_PS_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_ps_surface_create")
#endif
#ifdef CAIRO_HAS_PNG_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_png_surface_create")
#endif
#ifdef CAIRO_HAS_GL_SURFACE
#pragma comment(linker, "/EXPORT:_cairo_gl_surface_create")
#endif
#pragma comment(linker, "/EXPORT:_cairo_matrix_create")
#pragma comment(linker, "/EXPORT:_cairo_matrix_destroy")
#pragma comment(linker, "/EXPORT:_cairo_matrix_copy")
#pragma comment(linker, "/EXPORT:_cairo_matrix_set_identity")
#pragma comment(linker, "/EXPORT:_cairo_matrix_set_affine")
#pragma comment(linker, "/EXPORT:_cairo_matrix_get_affine")
#pragma comment(linker, "/EXPORT:_cairo_matrix_translate")
#pragma comment(linker, "/EXPORT:_cairo_matrix_scale")
#pragma comment(linker, "/EXPORT:_cairo_matrix_rotate")
#pragma comment(linker, "/EXPORT:_cairo_matrix_invert")
#pragma comment(linker, "/EXPORT:_cairo_matrix_multiply")
#pragma comment(linker, "/EXPORT:_cairo_matrix_transform_distance")
#pragma comment(linker, "/EXPORT:_cairo_matrix_transform_point")
#include <windows.h>
#include <gdiplus.h>
using namespace Gdiplus;
extern const cairo_surface_backend_t cairo_win32_surface_backend;
cairo_surface_t *_cairo_win32_surface_create (HDC dc);
void
cairo_set_target_win32(cairo_t *cr, HDC dc)
{
cairo_surface_t *surface;
surface = _cairo_win32_surface_create(dc);
if (surface == NULL) {
cr->status = CAIRO_STATUS_NO_MEMORY;
return;
}
cairo_set_target_surface (cr, surface);
/* cairo_set_target_surface takes a reference, so we must destroy ours */
cairo_surface_destroy (surface);
}
typedef struct cairo_win32_surface {
cairo_surface_t base;
Graphics *gr;
Brush *brush;
} cairo_win32_surface_t;
static void
_cairo_win32_surface_erase(cairo_win32_surface_t *surface);
cairo_surface_t *
_cairo_win32_surface_create(HDC dc)
{
cairo_win32_surface_t *surface;
surface = (cairo_win32_surface_t*)malloc(sizeof(cairo_win32_surface_t));
if (surface == NULL)
return NULL;
surface->gr = new Graphics(dc);
surface->brush = NULL;
// surface->gr->TranslateTransform(-2000*2.5, -3000*2.2);
// surface->gr->ScaleTransform(20, 20);
surface->gr->SetSmoothingMode(SmoothingModeAntiAlias);
/* do pixmap creation, etc */
_cairo_surface_init(&surface->base, &cairo_win32_surface_backend);
_cairo_win32_surface_erase(surface);
return &surface->base;
}
static cairo_surface_t *
_cairo_win32_surface_create_similar(void *abstract_src,
cairo_format_t format,
int drawable,
int width,
int height)
{
return NULL;
}
static void
_cairo_win32_surface_destroy (void *abstract_surface)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
delete surface->gr;
delete surface->brush;
free(surface);
}
static void
_cairo_win32_surface_erase(cairo_win32_surface_t *surface)
{
surface->gr->Clear(Color(255, 0, 0, 0));
}
/* XXX: We should re-work this interface to return both X/Y ppi values. */
static double
_cairo_win32_surface_pixels_per_inch(void *abstract_surface)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
return surface->gr->GetDpiY();
}
static Image *
make_image(cairo_image_surface_t *image)
{
Rect r(0, 0, image->width, image->height);
Bitmap *b = new Bitmap(image->width, image->height, PixelFormat32bppPARGB);
BitmapData data;
b->LockBits(&r, ImageLockModeWrite, PixelFormat32bppPARGB, &data);
memcpy(data.Scan0, image->data, image->stride * image->height);
b->UnlockBits(&data);
return b;
}
static cairo_image_surface_t *
_cairo_win32_surface_get_image(void *abstract_surface)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
/* need to figure out how to get the data from a Graphics and turn it in to an Image */
return NULL;
}
static cairo_status_t
_cairo_win32_surface_set_image(void *abstract_surface,
cairo_image_surface_t *image)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
Image *img = make_image(image);
surface->gr->DrawImage(img, 0, 0);
delete img;
return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t
_cairo_win32_surface_set_matrix(void *abstract_surface,
cairo_matrix_t *matrix)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
Matrix m((float)matrix->m[0][0], (float)matrix->m[1][0], (float)matrix->m[2][0],
(float)matrix->m[0][1], (float)matrix->m[1][1], (float)matrix->m[2][1]);
surface->gr->SetTransform(&m);
return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t
_cairo_win32_surface_set_filter (void *abstract_surface,
cairo_filter_t filter)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
SmoothingMode mode;
switch (filter) {
case CAIRO_FILTER_FAST:
mode = SmoothingModeNone;
break;
case CAIRO_FILTER_GOOD:
case CAIRO_FILTER_BEST:
case CAIRO_FILTER_NEAREST:
case CAIRO_FILTER_BILINEAR:
case CAIRO_FILTER_GAUSSIAN:
default:
mode = SmoothingModeAntiAlias;
break;
}
surface->gr->SetSmoothingMode(mode);
return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t
_cairo_win32_surface_set_repeat (void *abstract_surface,
int repeat)
{
/* what is this function supposed to do? */
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
return (cairo_status_t)CAIRO_INT_STATUS_UNSUPPORTED;
}
static cairo_int_status_t
_cairo_win32_surface_composite(cairo_operator_t op,
cairo_surface_t *generic_src,
cairo_surface_t *generic_mask,
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)
{
return CAIRO_INT_STATUS_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_t *rects,
int num_rects)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
SolidBrush brush(Color(color->alpha_short, color->red_short, color->green_short, color->blue_short));
RectF *r = new RectF[num_rects]; /* should really allocate a small number here on the stack and use those if possible */
for (int i = 0; i < num_rects; ++i) {
r[i].X = rects[i].x;
r[i].Y = rects[i].y;
r[i].Width = rects[i].width;
r[i].Height = rects[i].height;
}
surface->gr->FillRectangles(&brush, r, num_rects);
delete[] r;
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
}
static int
_cairo_win32_extract_rectangle (cairo_trapezoid_t *trap,
RectF *rect)
{
if (trap->left.p1.x == trap->left.p2.x &&
trap->right.p1.x == trap->right.p2.x &&
trap->left.p1.y == trap->right.p1.y &&
trap->left.p2.y == trap->right.p2.y) {
double x = _cairo_fixed_to_double (trap->left.p1.x);
double y = _cairo_fixed_to_double (trap->left.p1.y);
rect->X = (float)x;
rect->Y = (float)y;
rect->Width = (float)(_cairo_fixed_to_double(trap->right.p1.x) - x);
rect->Height = (float)(_cairo_fixed_to_double(trap->left.p2.y) - y);
return 1;
}
return 0;
}
static cairo_int_status_t
_cairo_win32_surface_composite_trapezoids (cairo_operator_t op,
cairo_surface_t *generic_src,
void *abstract_dst,
int x_src,
int y_src,
cairo_trapezoid_t *traps,
int num_traps)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_dst;
static int zzz = 0;
zzz += num_traps;
Image *img = NULL;
Brush *brush = NULL; /* i'd really like to not allocate this on the heap.. */
#define FIXED_TO_FLOAT(x) (float)_cairo_fixed_to_double((x))
/* ugh.. figure out if we're a "native" pattern or an image_surface pattern.. */
if (generic_src->backend == &cairo_win32_surface_backend) {
brush = ((cairo_win32_surface_t*)generic_src)->brush;
/* XXX move this outside so that TextureBrushes can take advantage of it */
/* Check to see if we can represent these traps as a rectangle. */
RectF rect;
if (num_traps == 1 && _cairo_win32_extract_rectangle(traps, &rect)) {
surface->gr->FillRectangle(brush, rect);
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
}
} else {
/* I would really love to move this code in to create_pattern if possible */
img = make_image((cairo_image_surface_t*)generic_src);
brush = new TextureBrush(img);
// XXX this will probably break. Don't know why we have +1 and +2 offsets..
float xoff = (FIXED_TO_FLOAT(traps[0].left.p1.x) + 0.5f);
float yoff = (FIXED_TO_FLOAT(traps[0].left.p1.y) + 1.5f);
static_cast<TextureBrush*>(brush)->TranslateTransform((int)(-x_src + xoff),
(int)(-y_src + yoff));
}
CompositingMode mode;
switch (op) {
case CAIRO_OPERATOR_OVER:
mode = CompositingModeSourceOver;
break;
case CAIRO_OPERATOR_CLEAR:
mode = CompositingModeSourceCopy;
break;
case CAIRO_OPERATOR_SRC:
case CAIRO_OPERATOR_DST:
case CAIRO_OPERATOR_OVER_REVERSE:
case CAIRO_OPERATOR_IN:
case CAIRO_OPERATOR_IN_REVERSE:
case CAIRO_OPERATOR_OUT:
case CAIRO_OPERATOR_OUT_REVERSE:
case CAIRO_OPERATOR_ATOP:
case CAIRO_OPERATOR_ATOP_REVERSE:
case CAIRO_OPERATOR_XOR:
case CAIRO_OPERATOR_ADD:
case CAIRO_OPERATOR_SATURATE:
mode = CompositingModeSourceOver;
break;
}
surface->gr->SetCompositingMode(mode);
PointF points[4];
for (int i = 0; i < num_traps; ++i) {
float top = FIXED_TO_FLOAT(traps[i].top);
float bottom = FIXED_TO_FLOAT(traps[i].bottom);
/* left line */
points[0].X = FIXED_TO_FLOAT(traps[i].left.p1.x);
points[0].Y = FIXED_TO_FLOAT(traps[i].left.p1.y);
points[1].X = FIXED_TO_FLOAT(traps[i].left.p2.x);
points[1].Y = FIXED_TO_FLOAT(traps[i].left.p2.y);
/* right line */
points[2].X = FIXED_TO_FLOAT(traps[i].right.p2.x);
points[2].Y = FIXED_TO_FLOAT(traps[i].right.p2.y);
points[3].X = FIXED_TO_FLOAT(traps[i].right.p1.x);
points[3].Y = FIXED_TO_FLOAT(traps[i].right.p1.y);
surface->gr->FillPolygon(brush, points, 4);
//Pen p(Color(255,0,0,0), 1.0f/10.0f);
//surface->gr->DrawPolygon(&p, points, 4);
}
#undef FIXED_TO_FLOAT
delete img;
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
_cairo_win32_surface_copy_page (void *abstract_surface)
{
return CAIRO_INT_STATUS_UNSUPPORTED;
}
static cairo_int_status_t
_cairo_win32_surface_show_page (void *abstract_surface)
{
return CAIRO_INT_STATUS_UNSUPPORTED;
}
static cairo_int_status_t
_cairo_win32_surface_set_clip_region (void *abstract_surface,
pixman_region16_t *region)
{
cairo_win32_surface_t *surface = (cairo_win32_surface_t *)abstract_surface;
pixman_box16_t *box;
int n = pixman_region_num_rects(region);
if (n == 0)
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
box = pixman_region_rects(region);
surface->gr->ResetClip();
for (int i = 0; i < n; ++i) {
Rect r(box[i].x1, box[i].y1, box[i].x2 - box[i].x1, box[i].y2 - box[i].y1);
surface->gr->SetClip(r, CombineModeUnion); /* do I need to do replace once and then union? */
}
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
_cairo_win32_surface_create_pattern (void *abstract_surface,
cairo_pattern_t *pattern,
cairo_box_t *box)
{
/* SOLID is easy -> SolidBrush
LINEAR we can only do a gradient from 1 color to another -> LinearGradientBrush
We should do this if thats all we need, otherwise use software.
RADIAL we can't really do it. Let it fall back to software I guess. */
/* in the case of PATTERN_SOLID, we really just want to create a brush and hand that back... */
if (pattern->type == CAIRO_PATTERN_SOLID) {
/* ugh, this surface creation code should _really_ live somewhere else */
cairo_win32_surface_t *src = (cairo_win32_surface_t*)malloc(sizeof(cairo_win32_surface_t));
if (src == NULL)
return CAIRO_INT_STATUS_UNSUPPORTED;
_cairo_surface_init(&src->base, &cairo_win32_surface_backend);
pattern->source = &src->base;
src->gr = NULL;
src->brush = new SolidBrush(Color(pattern->color.alpha_short,
pattern->color.red_short,
pattern->color.green_short,
pattern->color.blue_short));
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
}
else if (pattern->type == CAIRO_PATTERN_LINEAR && pattern->n_stops == 2) {
/* ugh, this surface creation code should _really_ live somewhere else */
cairo_win32_surface_t *src = (cairo_win32_surface_t*)malloc(sizeof(cairo_win32_surface_t));
if (src == NULL)
return CAIRO_INT_STATUS_UNSUPPORTED;
_cairo_surface_init(&src->base, &cairo_win32_surface_backend);
pattern->source = &src->base;
src->gr = NULL;
RectF r((float)pattern->u.linear.point0.x,
(float)pattern->u.linear.point0.y,
((box->p2.x + 65535) >> 16) - (box->p1.x >> 16),
((box->p2.y + 65535) >> 16) - (box->p1.y >> 16));
src->brush = new LinearGradientBrush(r,
Color(pattern->stops[0].color_char[3],
pattern->stops[0].color_char[0],
pattern->stops[0].color_char[1],
pattern->stops[0].color_char[2]),
Color(pattern->stops[1].color_char[3],
pattern->stops[1].color_char[0],
pattern->stops[1].color_char[1],
pattern->stops[1].color_char[2]),
90.0, FALSE);
static_cast<LinearGradientBrush*>(src->brush)->TranslateTransform((float)pattern->source_offset.x,
(float)pattern->source_offset.y);
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
}
else if (pattern->type == CAIRO_PATTERN_RADIAL) {
#if 0 /* XXX not sure this will work.. do we have to draw with FillPath() in order for this brush to work properly? */
/* use PathGradientBrush here */
/* ugh, this surface creation code should _really_ live somewhere else */
cairo_win32_surface_t *src = (cairo_win32_surface_t*)malloc(sizeof(cairo_win32_surface_t));
if (src == NULL)
return CAIRO_INT_STATUS_UNSUPPORTED;
_cairo_surface_init(&src->base, &cairo_win32_surface_backend);
pattern->source = &src->base;
src->gr = NULL;
PointF center(pattern->u.radial.center1.x, pattern->u.radial.center1.y);
GraphicsPath path;
path.AddEllipse(0, 0, 140, 70);
// Use the path to construct a brush.
PathGradientBrush *brush = new PathGradientBrush(&path);
src->brush = brush;
// Set the color at the center of the path to blue.
brush->SetCenterColor(Color(50, 100, 0, 255));
// Set the color along the entire boundary of the path to aqua.
Color colors[] = {Color(255, 0, 255, 255)};
int count = 1;
brush->SetSurroundColors(colors, &count);
brush->SetCenterPoint(center);
return (cairo_int_status_t)CAIRO_STATUS_SUCCESS;
#endif
}
return CAIRO_INT_STATUS_UNSUPPORTED;
}
static const cairo_surface_backend_t cairo_win32_surface_backend = {
_cairo_win32_surface_create_similar,
_cairo_win32_surface_destroy,
_cairo_win32_surface_pixels_per_inch,
_cairo_win32_surface_get_image,
_cairo_win32_surface_set_image,
_cairo_win32_surface_set_matrix,
_cairo_win32_surface_set_filter,
_cairo_win32_surface_set_repeat,
_cairo_win32_surface_composite,
_cairo_win32_surface_fill_rectangles,
_cairo_win32_surface_composite_trapezoids,
_cairo_win32_surface_copy_page,
_cairo_win32_surface_show_page,
_cairo_win32_surface_set_clip_region,
_cairo_win32_surface_create_pattern,
};
Reference in a new issue View git blame Copy permalink