void dtgtk_cairo_paint_triangle(cairo_t *cr, gint x,int y,gint w,gint h, gint flags)
{
/* initialize rotation and flip matrices */
cairo_matrix_t hflip_matrix;
cairo_matrix_init(&hflip_matrix,-1,0,0,1,1,0);
double C=cos(-(M_PI/2.0)),S=sin(-(M_PI/2.0)); // -90 degrees
C=flags&CPF_DIRECTION_DOWN?cos(-(M_PI*1.5)):C;
S=flags&CPF_DIRECTION_DOWN?sin(-(M_PI*1.5)):S;
cairo_matrix_t rotation_matrix;
cairo_matrix_init(&rotation_matrix,C,S,-S,C,0.5-C*0.5+S*0.5,0.5-S*0.5-C*0.5);
/* scale and transform*/
gint s=w<h?w:h;
cairo_translate(cr, x+(w/2.0)-(s/2.0), y+(h/2.0)-(s/2.0));
cairo_scale(cr,s,s);
cairo_set_line_width(cr,0.1);
cairo_set_line_cap(cr,CAIRO_LINE_CAP_ROUND);
if( flags&CPF_DIRECTION_UP || flags &CPF_DIRECTION_DOWN)
cairo_transform(cr,&rotation_matrix);
else if(flags&CPF_DIRECTION_LEFT) // Flip x transformation
cairo_transform(cr,&hflip_matrix);
cairo_move_to(cr, 0.2, 0.2);
cairo_line_to(cr, 0.7, 0.5);
cairo_line_to(cr, 0.2, 0.8);
cairo_line_to(cr, 0.2, 0.2);
cairo_stroke(cr);
cairo_identity_matrix(cr);
}
void wxCairoSVGRadialGradient::Op(cairo_t* cairo_image, bool preserve, wxCairoSVGPaintServerOp op) {
cairo_pattern_t *pat;
bool saved = false;
if (m_gradientUnits == _T("objectBoundingBox")) {
cairo_save(cairo_image);
saved = true;
double minx;
double miny;
double maxx;
double maxy;
cairo_path_extents(cairo_image, &minx, &miny, &maxx, &maxy);
cairo_matrix_t mat;
cairo_matrix_init(&mat, maxx-minx, 0, 0, maxy-miny, minx, miny);
cairo_transform(cairo_image, &mat);
wxLogTrace(_T("svg"), _T("wxCairoSVGRadialGradient::Op transformed to objectBoundingBox minx %f miny %f maxx %f maxy %f"),
minx, miny, maxx, maxy);
} else if (m_gradientTransform.Contains(_T("matrix"))) {
double m[6];
wxArrayString params = wxStringTokenize(m_gradientTransform.Mid(m_gradientTransform.Find(_T("matrix(")) + 7), _T(" "));
if (params.Count() == 6) {
for (int i = 0; i < 6; i++) {
params[i].Strip().ToDouble(&m[i]);
}
cairo_save(cairo_image);
saved = true;
cairo_matrix_t mat;
cairo_matrix_init(&mat, m[0], m[1], m[2], m[3], m[4], m[5]);
cairo_transform(cairo_image, &mat);
wxLogTrace(_T("svg"), _T("wxCairoSVGRadialGradient::Op matrix transform %f %f %f %f %f %f"),
m[0], m[1], m[2], m[3], m[4], m[5]);
}
}
pat = cairo_pattern_create_radial(m_cx, m_cy, 0, m_cx, m_cy, m_r);
wxLogTrace(_T("svg"), _T("wxCairoSVGRadialGradient::Op cairo_pattern_create_radial cx %f cy %f r %f"),
m_cx, m_cy, m_r);
for (wxCairoSVGGradientStopList::iterator i = m_stopList.begin(); i != m_stopList.end(); ++i) {
wxCairoSVGGradientStop* stop = *i;
if (stop->m_opacity == 1) {
cairo_pattern_add_color_stop_rgb(pat, stop->m_offset, (double) stop->m_r / 255.0, (double) stop->m_g / 255.0, (double) stop->m_b / 255.0);
} else {
cairo_pattern_add_color_stop_rgba(pat, stop->m_offset, (double) stop->m_r / 255.0, (double) stop->m_g / 255.0, (double) stop->m_b / 255.0, stop->m_opacity);
}
}
cairo_set_source(cairo_image, pat);
wxCairoSVGPaintServer::Op(cairo_image, preserve, op);
if (saved) cairo_restore(cairo_image);
cairo_pattern_destroy(pat);
wxLogTrace(_T("svg"), _T("wxCairoSVGRadialGradient::Op done"));
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
/* We draw in the default black, so paint white first. */
cairo_save (cr);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_restore (cr);
cairo_translate (cr, PAD, PAD);
cairo_set_line_width (cr, LINE_WIDTH);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
cairo_save (cr);
{
cairo_matrix_t skew_x = {
1.0, 0.0,
SKEW_FACTOR, 1.0,
0.0, 0.0
};
cairo_translate (cr, LINE_WIDTH / 2.0, 0.0);
cairo_transform (cr, &skew_x);
cairo_move_to (cr, 0.0, 0.0);
cairo_line_to (cr, 0.0, LINE_LENGTH);
cairo_stroke (cr);
}
cairo_restore (cr);
cairo_translate (cr, 0.0, LINE_WIDTH);
cairo_save (cr);
{
cairo_matrix_t skew_y = {
1.0, SKEW_FACTOR,
0.0, 1.0,
0.0, 0.0
};
cairo_translate (cr, 0.0, LINE_WIDTH / 2.0);
cairo_transform (cr, &skew_y);
cairo_move_to (cr, 0.0, 0.0);
cairo_line_to (cr, LINE_LENGTH, 0.0);
cairo_stroke (cr);
}
cairo_restore (cr);
return CAIRO_TEST_SUCCESS;
}
CAMLprim value
ml_cairo_transform (value v_cr, value v_matrix)
{
#ifndef ARCH_ALIGN_DOUBLE
cairo_transform (cairo_t_val (v_cr), cairo_matrix_t_val (v_matrix));
#else
cairo_matrix_t mat;
ml_convert_cairo_matrix_in (v_matrix, &mat);
cairo_transform (cairo_t_val (v_cr), &mat);
#endif
check_cairo_status (v_cr);
return Val_unit;
}
void
gtk_css_style_render_icon (GtkCssStyle *style,
cairo_t *cr,
double x,
double y,
double width,
double height,
GtkCssImageBuiltinType builtin_type)
{
const GtkCssValue *shadows;
cairo_matrix_t matrix, transform_matrix, saved_matrix;
GtkCssImage *image;
g_return_if_fail (GTK_IS_CSS_STYLE (style));
g_return_if_fail (cr != NULL);
image = _gtk_css_image_value_get_image (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_SOURCE));
if (image == NULL)
return;
cairo_get_matrix (cr, &saved_matrix);
shadows = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_SHADOW);
cairo_translate (cr, x, y);
if (_gtk_css_transform_value_get_matrix (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_TRANSFORM), &transform_matrix))
{
/* XXX: Implement -gtk-icon-transform-origin instead of hardcoding "50% 50%" here */
cairo_matrix_init_translate (&matrix, width / 2, height / 2);
cairo_matrix_multiply (&matrix, &transform_matrix, &matrix);
cairo_matrix_translate (&matrix, - width / 2, - height / 2);
if (_gtk_css_shadows_value_is_none (shadows))
{
cairo_transform (cr, &matrix);
gtk_css_image_builtin_draw (image, cr, width, height, builtin_type);
}
else
{
cairo_push_group (cr);
cairo_transform (cr, &matrix);
gtk_css_image_builtin_draw (image, cr, width, height, builtin_type);
cairo_pop_group_to_source (cr);
_gtk_css_shadows_value_paint_icon (shadows, cr);
cairo_paint (cr);
}
}
cairo_set_matrix (cr, &saved_matrix);
}
static void
_adg_render(AdgEntity *entity, cairo_t *cr)
{
AdgLogoClassPrivate *data_class = ADG_LOGO_GET_CLASS(entity)->data_class;
AdgLogoPrivate *data = adg_logo_get_instance_private((AdgLogo *) entity);
const cairo_path_t *cairo_path;
cairo_transform(cr, adg_entity_get_global_matrix(entity));
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
cairo_path = adg_trail_get_cairo_path((AdgTrail *) data_class->symbol);
if (cairo_path != NULL) {
cairo_save(cr);
cairo_transform(cr, adg_entity_get_local_matrix(entity));
cairo_append_path(cr, cairo_path);
cairo_restore(cr);
cairo_set_line_width(cr, 3);
adg_entity_apply_dress(entity, data->symbol_dress, cr);
cairo_stroke(cr);
}
cairo_path = adg_trail_get_cairo_path((AdgTrail *) data_class->screen);
if (cairo_path != NULL) {
cairo_save(cr);
cairo_transform(cr, adg_entity_get_local_matrix(entity));
cairo_append_path(cr, cairo_path);
cairo_restore(cr);
cairo_set_line_width(cr, 2);
adg_entity_apply_dress(entity, data->screen_dress, cr);
cairo_stroke(cr);
}
cairo_path = adg_trail_get_cairo_path((AdgTrail *) data_class->frame);
if (cairo_path != NULL) {
cairo_save(cr);
cairo_transform(cr, adg_entity_get_local_matrix(entity));
cairo_append_path(cr, cairo_path);
cairo_restore(cr);
cairo_set_line_width(cr, 2);
cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
adg_entity_apply_dress(entity, data->frame_dress, cr);
cairo_stroke(cr);
}
}
static void
draw (TboObjectBase *self, Frame *frame, cairo_t *cr)
{
TboObjectPixmap *pixmap = TBO_OBJECT_PIXMAP (self);
int w, h;
cairo_surface_t *image;
GdkPixbuf *pixbuf;
GError *error = NULL;
char path[255];
tbo_files_expand_path (pixmap->path->str, path);
pixbuf = gdk_pixbuf_new_from_file (path, &error);
if (!pixbuf) {
g_warning ("There's a problem here: %s", error->message);
return;
}
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
if (!self->width) self->width = w;
if (!self->height) self->height = h;
float factorw = (float)self->width / (float)w;
float factorh = (float)self->height / (float)h;
cairo_matrix_t mx = {1, 0, 0, 1, 0, 0};
tbo_object_base_get_flip_matrix (self, &mx);
cairo_rectangle(cr, frame->x+2, frame->y+2, frame->width-4, frame->height-4);
cairo_clip (cr);
cairo_translate (cr, frame->x+self->x, frame->y+self->y);
cairo_rotate (cr, self->angle);
cairo_transform (cr, &mx);
cairo_scale (cr, factorw, factorh);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
cairo_scale (cr, 1/factorw, 1/factorh);
cairo_transform (cr, &mx);
cairo_rotate (cr, -self->angle);
cairo_translate (cr, -(frame->x+self->x), -(frame->y+self->y));
cairo_reset_clip (cr);
cairo_surface_destroy (image);
}
void Path::transform(const AffineTransform& trans)
{
cairo_t* m_cr = platformPath()->m_cr;
cairo_matrix_t c_matrix = cairo_matrix_t(trans);
cairo_matrix_invert(&c_matrix);
cairo_transform(m_cr, &c_matrix);
}
void cairo_container::draw_txdib( cairo_t* cr, CTxDIB* bmp, int x, int y, int cx, int cy )
{
cairo_save(cr);
cairo_matrix_t flib_m;
cairo_matrix_init(&flib_m, 1, 0, 0, -1, 0, 0);
cairo_surface_t* img = NULL;
CTxDIB rbmp;
if(cx != bmp->getWidth() || cy != bmp->getHeight())
{
bmp->resample(cx, cy, &rbmp);
img = cairo_image_surface_create_for_data((unsigned char*) rbmp.getBits(), CAIRO_FORMAT_ARGB32, rbmp.getWidth(), rbmp.getHeight(), rbmp.getWidth() * 4);
cairo_matrix_translate(&flib_m, 0, -rbmp.getHeight());
cairo_matrix_translate(&flib_m, x, -y);
} else
{
img = cairo_image_surface_create_for_data((unsigned char*) bmp->getBits(), CAIRO_FORMAT_ARGB32, bmp->getWidth(), bmp->getHeight(), bmp->getWidth() * 4);
cairo_matrix_translate(&flib_m, 0, -bmp->getHeight());
cairo_matrix_translate(&flib_m, x, -y);
}
cairo_transform(cr, &flib_m);
cairo_set_source_surface(cr, img, 0, 0);
cairo_paint(cr);
cairo_restore(cr);
cairo_surface_destroy(img);
}
void uiDrawTransform(uiDrawContext *c, uiDrawMatrix *m)
{
cairo_matrix_t cm;
m2c(m, &cm);
cairo_transform(c->cr, &cm);
}
/* Draw the word cairo at NUM_TEXT different angles.
* We separate the circle into quadrants to reduce
* numerical errors i.e. so each quarter is pixel-aligned.
*/
static void
draw_quadrant (cairo_t *cr,
const char *text,
const cairo_text_extents_t *extents,
const cairo_matrix_t *transform,
int x_off, int y_off)
{
int i;
for (i = 0; i < NUM_TEXT/4; i++) {
cairo_save (cr);
cairo_rotate (cr, 2*M_PI*i/NUM_TEXT);
cairo_transform (cr, transform);
cairo_set_line_width (cr, 1.0);
cairo_rectangle (cr, x_off - 0.5, y_off - 0.5, extents->width + 1, extents->height + 1);
cairo_set_source_rgb (cr, 1, 0, 0);
cairo_stroke (cr);
cairo_move_to (cr, x_off - extents->x_bearing, y_off - extents->y_bearing);
cairo_set_source_rgb (cr, 0, 0, 0);
#if CAIRO_TEST_GENERATE_REFERENCE_IMAGE
cairo_text_path (cr, text);
cairo_fill (cr);
#else
cairo_show_text (cr, text);
#endif
cairo_restore (cr);
}
}
static void
selection_render_mask (Selection *selection)
{
GdkWindow *window;
cairo_surface_t *surface;
cairo_t *cr;
window = gtk_widget_get_window (selection->shell->canvas);
surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_ALPHA,
gdk_window_get_width (window),
gdk_window_get_height (window));
cr = cairo_create (surface);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_width (cr, 1.0);
if (selection->shell->rotate_transform)
cairo_transform (cr, selection->shell->rotate_transform);
gimp_cairo_add_segments (cr,
selection->segs_in,
selection->n_segs_in);
cairo_stroke (cr);
selection->segs_in_mask = cairo_pattern_create_for_surface (surface);
cairo_destroy (cr);
cairo_surface_destroy (surface);
}
static VALUE
cr_transform (VALUE self, VALUE matrix)
{
cairo_transform (_SELF, RVAL2CRMATRIX (matrix));
cr_check_status (_SELF);
return self;
}
void
ge_cairo_mirror (cairo_t *cr,
CairoMirror mirror,
gint *x,
gint *y,
gint *width,
gint *height)
{
cairo_matrix_t matrix;
cairo_matrix_init_identity (&matrix);
cairo_translate (cr, *x, *y);
*x = 0;
*y = 0;
if (mirror & CR_MIRROR_HORIZONTAL)
{
cairo_matrix_scale (&matrix, -1, 1);
*x = -*width;
}
if (mirror & CR_MIRROR_VERTICAL)
{
cairo_matrix_scale (&matrix, 1, -1);
*y = -*height;
}
cairo_transform (cr, &matrix);
}
void Path::transform(const AffineTransform& trans)
{
cairo_t* cr = ensurePlatformPath()->context();
cairo_matrix_t c_matrix = cairo_matrix_t(trans);
cairo_matrix_invert(&c_matrix);
cairo_transform(cr, &c_matrix);
}
void Drawer::Rotation(double aAngle)
{
mAngle = aAngle * M_PI / 180;
double CentreX = 0.0;
double CentreY = 0.0;
cairo_matrix_t MatriceTranslate;
cairo_matrix_t MatriceRotate;
cairo_get_current_point(mCairoDC, &CentreX, &CentreY);
cairo_matrix_init_translate(&MatriceTranslate,CentreX,CentreY);
cairo_transform (mCairoDC, &MatriceTranslate);
cairo_matrix_init_rotate(&MatriceRotate, mAngle);
cairo_transform (mCairoDC, &MatriceRotate);
}
void dtgtk_cairo_paint_flip(cairo_t *cr,gint x,gint y,gint w,gint h,gint flags)
{
double C=cos(-1.570796327),S=sin(-1.570796327);
cairo_matrix_t rotation_matrix;
cairo_matrix_init(&rotation_matrix,C,S,-S,C,0.5-C*0.5+S*0.5,0.5-S*0.5-C*0.5);
gint s=w<h?w:h;
cairo_translate(cr, x+(w/2.0)-(s/2.0), y+(h/2.0)-(s/2.0));
cairo_scale(cr,s,s);
cairo_set_line_width(cr,0.15);
cairo_set_line_cap(cr,CAIRO_LINE_CAP_ROUND);
if( (flags&CPF_DIRECTION_UP) ) // Rotate -90 degrees
cairo_transform(cr,&rotation_matrix);
cairo_move_to(cr,0.05,0.50);
cairo_line_to(cr,0.05,0);
cairo_line_to(cr,0.95,0.50);
cairo_line_to(cr,0.2,0.50);
cairo_stroke(cr);
cairo_set_line_width(cr,0.04);
cairo_move_to(cr,0.05,0.62);
cairo_line_to(cr,0.05,1.0);
cairo_line_to(cr,0.95,0.62);
cairo_stroke(cr);
cairo_identity_matrix(cr);
}
void
ink_cairo_transform(cairo_t *ct, Geom::Affine const &m)
{
cairo_matrix_t cm;
ink_matrix_to_cairo(cm, m);
cairo_transform(ct, &cm);
}
void
GeometryGroup::Draw (cairo_t *cr)
{
Transform *transform = GetTransform ();
cairo_matrix_t saved;
cairo_get_matrix (cr, &saved);
if (transform) {
cairo_matrix_t matrix;
transform->GetTransform (&matrix);
cairo_transform (cr, &matrix);
}
GeometryCollection *children = GetChildren ();
Geometry *geometry;
// GeometryGroup is used for Clip (as a Geometry) so Fill (normally setting the fill rule) is never called
cairo_set_fill_rule (cr, convert_fill_rule (GetFillRule ()));
int children_count = children->GetCount ();
for (int i = 0; i < children_count; i++) {
geometry = children->GetValueAt (i)->AsGeometry ();
geometry->Draw (cr);
}
cairo_set_matrix (cr, &saved);
}
static int
cr_transform (lua_State *L) {
cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
cairo_matrix_t mat;
from_lua_matrix(L, &mat, 2);
cairo_transform(*obj, &mat);
return 0;
}
static void prepareContextForGlyphDrawing(cairo_t* context, const SimpleFontData* font)
{
cairo_set_scaled_font(context, font->platformData().scaledFont());
if (font->platformData().syntheticOblique()) {
cairo_matrix_t mat = {1, 0, gSyntheticObliqueSkew, 1, 0, 0};
cairo_transform(context, &mat);
}
}
void GraphicsContext::concatCTM(const AffineTransform& transform)
{
if (paintingDisabled())
return;
cairo_t* cr = m_data->cr;
const cairo_matrix_t* matrix = reinterpret_cast<const cairo_matrix_t*>(&transform);
cairo_transform(cr, matrix);
}
void lime_cairo_transform (value handle, value matrix) {
Matrix3 mat3 = Matrix3 (matrix);
cairo_matrix_t cm;
cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty);
cairo_transform ((cairo_t*)val_data (handle), &cm);
}
void LcCairoPainter::ellipse(double cx, double cy, double rx, double ry, double sa, double ea, double ra) {
double cosrotangle = std::cos(ra);
double sinrotangle = std::sin(ra);
cairo_matrix_t transformmatrix;
cairo_matrix_init(&transformmatrix, rx * cosrotangle, rx * sinrotangle, -ry * sinrotangle, ry * cosrotangle, cx, cy);
cairo_save(_cr);
cairo_transform(_cr, &transformmatrix);
cairo_arc(_cr, 0, 0, 1, sa, ea);
cairo_restore(_cr);
}
void lime_cairo_transform (double handle, value matrix) {
Matrix3 mat3 = Matrix3 (matrix);
cairo_matrix_t cm;
cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty);
cairo_transform ((cairo_t*)(intptr_t)handle, &cm);
}
void GraphicsContext::concatCTM(const AffineTransform& transform)
{
if (paintingDisabled())
return;
cairo_t* cr = platformContext()->cr();
const cairo_matrix_t matrix = cairo_matrix_t(transform);
cairo_transform(cr, &matrix);
m_data->concatCTM(transform);
}
gboolean
gimp_overlay_child_expose (GimpOverlayBox *box,
GimpOverlayChild *child,
GdkEventExpose *event)
{
GtkWidget *widget;
g_return_val_if_fail (GIMP_IS_OVERLAY_BOX (box), FALSE);
g_return_val_if_fail (child != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
widget = GTK_WIDGET (box);
if (event->window == gtk_widget_get_window (widget))
{
GtkAllocation child_allocation;
GdkRectangle bounds;
gtk_widget_get_allocation (child->widget, &child_allocation);
gimp_overlay_child_transform_bounds (child, &child_allocation, &bounds);
if (gtk_widget_get_visible (child->widget) &&
gdk_rectangle_intersect (&event->area, &bounds, NULL))
{
GdkPixmap *pixmap = gdk_offscreen_window_get_pixmap (child->window);
cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget));
gdk_cairo_region (cr, event->region);
cairo_clip (cr);
cairo_transform (cr, &child->matrix);
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint_with_alpha (cr, child->opacity);
cairo_destroy (cr);
}
}
else if (event->window == child->window)
{
if (! gtk_widget_get_app_paintable (child->widget))
gtk_paint_flat_box (gtk_widget_get_style (child->widget),
event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, NULL,
0, 0, -1, -1);
gtk_container_propagate_expose (GTK_CONTAINER (widget),
child->widget,
event);
return TRUE;
}
return FALSE;
}
void CairoContext::transform(Geom::Affine const &m)
{
cairo_matrix_t cm;
cm.xx = m[0];
cm.xy = m[2];
cm.x0 = m[4];
cm.yx = m[1];
cm.yy = m[3];
cm.y0 = m[5];
cairo_transform(cobj(), &cm);
}
static void
swfdec_text_render (SwfdecGraphic *graphic, cairo_t *cr,
const SwfdecColorTransform *trans)
{
guint i;
SwfdecColor color;
SwfdecText *text = SWFDEC_TEXT (graphic);
SwfdecColorTransform force_color;
cairo_transform (cr, &text->transform);
/* scale by bounds */
for (i = 0; i < text->glyphs->len; i++) {
SwfdecTextGlyph *glyph;
SwfdecDraw *draw;
cairo_matrix_t pos;
glyph = &g_array_index (text->glyphs, SwfdecTextGlyph, i);
draw = swfdec_font_get_glyph (glyph->font, glyph->glyph);
if (draw == NULL) {
SWFDEC_INFO ("failed getting glyph %d, maybe an empty glyph?", glyph->glyph);
continue;
}
cairo_matrix_init_translate (&pos,
glyph->x, glyph->y);
cairo_matrix_scale (&pos,
(double) glyph->height / glyph->font->scale_factor,
(double) glyph->height / glyph->font->scale_factor);
cairo_save (cr);
cairo_transform (cr, &pos);
if (!cairo_matrix_invert (&pos)) {
color = swfdec_color_apply_transform (glyph->color, trans);
swfdec_color_transform_init_color (&force_color, color);
swfdec_draw_paint (draw, cr, &force_color);
} else {
SWFDEC_ERROR ("non-invertible matrix!");
}
cairo_restore (cr);
}
}
static PyObject *
pycairo_transform (PycairoContext *o, PyObject *args) {
PycairoMatrix *matrix;
if (!PyArg_ParseTuple (args, "O!:Context.transform",
&PycairoMatrix_Type, &matrix))
return NULL;
cairo_transform (o->ctx, &matrix->matrix);
RETURN_NULL_IF_CAIRO_CONTEXT_ERROR(o->ctx);
Py_RETURN_NONE;
}
