void wxGISDisplay::InitTransformMatrix(void) { m_dFrameCenterX = m_oDeviceFrameRect.GetWidth() / 2; m_dFrameCenterY = m_oDeviceFrameRect.GetHeight() / 2; double dWorldCenterX = (m_CurrentBounds.MaxX - m_CurrentBounds.MinX) / 2; double dWorldCenterY = (m_CurrentBounds.MaxY - m_CurrentBounds.MinY) / 2; //origin (UL corner) m_dOrigin_X = m_dCacheCenterX - m_dFrameCenterX; m_dOrigin_Y = m_dCacheCenterY - m_dFrameCenterY; //get scale double dScaleX = fabs(m_dFrameCenterX / dWorldCenterX); double dScaleY = fabs(m_dFrameCenterY / dWorldCenterY); m_dScale = wxMin(dScaleX, dScaleY); double dWorldDeltaX = dWorldCenterX + m_CurrentBounds.MinX; double dWorldDeltaY = dWorldCenterY + m_CurrentBounds.MinY; double dWorldDeltaXSt = m_dScale * dWorldDeltaX;// + m_dAngleRad * dWorldDeltaY; double dWorldDeltaYSt = m_dScale * dWorldDeltaY;//m_dAngleRad * dWorldDeltaX + //double dCenterX = m_dCacheCenterX - dWorldDeltaXSt;//(dWorldCenterX + m_CurrentBounds.MinX) * dScale;// //double dCenterY = m_dCacheCenterY + dWorldDeltaYSt;//(dWorldCenterY + m_CurrentBounds.MinY) * dScale;// m_dFrameXShift = m_dFrameCenterX - dWorldDeltaXSt;//(dWorldCenterX + m_CurrentBounds.MinX) * dScale;// m_dFrameYShift = m_dFrameCenterY + dWorldDeltaYSt;//(dWorldCenterY + m_CurrentBounds.MinY) * dScale;// // cairo_matrix_init (m_pMatrix, 1, 0, 0, 1, m_dCacheCenterX, m_dCacheCenterY); //cairo_matrix_init (m_pMatrix, dScale, 0.0, 0.0, -dScale, dCenterX, dCenterY); cairo_matrix_init_translate (m_pMatrix, m_dCacheCenterX, m_dCacheCenterY); //rotate //cairo_matrix_rotate(m_pMatrix, 45.0 * M_PI / 180.0); if(!IsDoubleEquil(m_dAngleRad, 0.0)) //{ //cairo_matrix_translate(m_pMatrix, dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_rotate(m_pMatrix, m_dAngleRad); //cairo_matrix_translate(m_pMatrix, -dWorldDeltaXSt, dWorldDeltaYSt); //} //else cairo_matrix_translate(m_pMatrix, -dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_scale(m_pMatrix, m_dScale, -m_dScale); //init matrix for Wld2DC & DC2Wld cairo_matrix_init_translate (m_pDisplayMatrix, m_dFrameCenterX, m_dFrameCenterY); if(!IsDoubleEquil(m_dAngleRad, 0.0)) cairo_matrix_rotate(m_pDisplayMatrix, m_dAngleRad); cairo_matrix_translate(m_pDisplayMatrix, -dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_scale(m_pDisplayMatrix, m_dScale, -m_dScale); //init matrix for TransformRect cairo_matrix_init_translate (m_pDisplayMatrixNoRotate, m_dFrameCenterX, m_dFrameCenterY); cairo_matrix_translate(m_pDisplayMatrixNoRotate, -dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_scale(m_pDisplayMatrixNoRotate, m_dScale, -m_dScale); //set matrix to all caches for(size_t i = 0; i < m_saLayerCaches.size(); ++i) cairo_set_matrix (m_saLayerCaches[i].pCairoContext, m_pMatrix); }
static cairo_int_status_t render_glyphs_via_mask (cairo_gl_surface_t *dst, int dst_x, int dst_y, cairo_operator_t op, cairo_surface_t *source, cairo_composite_glyphs_info_t *info) { cairo_surface_t *mask; cairo_status_t status; cairo_bool_t has_component_alpha; TRACE ((stderr, "%s\n", __FUNCTION__)); /* XXX: For non-CA, this should be CAIRO_CONTENT_ALPHA to save memory */ mask = cairo_gl_surface_create (dst->base.device, CAIRO_CONTENT_COLOR_ALPHA, info->extents.width, info->extents.height); if (unlikely (mask->status)) return mask->status; status = render_glyphs ((cairo_gl_surface_t *) mask, info->extents.x, info->extents.y, CAIRO_OPERATOR_ADD, NULL, info, &has_component_alpha); if (likely (status == CAIRO_STATUS_SUCCESS)) { cairo_surface_pattern_t mask_pattern; cairo_surface_pattern_t source_pattern; mask->is_clear = FALSE; _cairo_pattern_init_for_surface (&mask_pattern, mask); mask_pattern.base.has_component_alpha = has_component_alpha; mask_pattern.base.filter = CAIRO_FILTER_NEAREST; mask_pattern.base.extend = CAIRO_EXTEND_NONE; cairo_matrix_init_translate (&mask_pattern.base.matrix, dst_x-info->extents.x, dst_y-info->extents.y); _cairo_pattern_init_for_surface (&source_pattern, source); cairo_matrix_init_translate (&source_pattern.base.matrix, dst_x-info->extents.x, dst_y-info->extents.y); status = _cairo_surface_mask (&dst->base, op, &source_pattern.base, &mask_pattern.base, NULL); _cairo_pattern_fini (&mask_pattern.base); _cairo_pattern_fini (&source_pattern.base); } cairo_surface_destroy (mask); return status; }
cairo_status_t _cairo_surface_offset_mask (cairo_surface_t *target, int x, int y, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t clip_copy, *dev_clip = clip; cairo_pattern_union_t source_copy; cairo_pattern_union_t mask_copy; if (unlikely (target->status)) return target->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (x | y) { cairo_matrix_t m; if (clip != NULL) { cairo_matrix_init_translate (&m, -x, -y); status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); _copy_transformed_pattern (&mask_copy.base, mask, &m); source = &source_copy.base; mask = &mask_copy.base; } status = _cairo_surface_mask (target, op, &source_copy.base, &mask_copy.base, dev_clip); FINISH: if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
static void draw_grid (cairo_t *cr, cairo_pattern_t *pattern, int dst_x, int dst_y) { cairo_matrix_t m; cairo_save (cr); cairo_translate (cr, dst_x, dst_y); cairo_scale (cr, 16, 16); cairo_rotate (cr, 1); cairo_matrix_init_translate (&m, 2560-4, 1280-4); cairo_pattern_set_matrix (pattern, &m); cairo_set_source (cr, pattern); cairo_rectangle (cr, 0, 0, 4, 4); cairo_fill (cr); cairo_set_source_rgb (cr, .7, .7, .7); cairo_set_line_width (cr, 1./16); cairo_move_to (cr, 0, 0); cairo_line_to (cr, 4, 0); cairo_move_to (cr, 0, 2); cairo_line_to (cr, 4, 2); cairo_move_to (cr, 0, 4); cairo_line_to (cr, 4, 4); cairo_move_to (cr, 0, 0); cairo_line_to (cr, 0, 4); cairo_move_to (cr, 2, 0); cairo_line_to (cr, 2, 4); cairo_move_to (cr, 4, 0); cairo_line_to (cr, 4, 4); cairo_stroke (cr); cairo_restore (cr); }
void RotateEnvelope(OGREnvelope &Env, double dAngle, double dX, double dY) { cairo_matrix_t Matrix; cairo_matrix_init_translate(&Matrix, dX, dY); cairo_matrix_rotate(&Matrix, dAngle); cairo_matrix_translate(&Matrix, -dX, -dY); //cairo_matrix_init_rotate(&Matrix, dAngle); double X1 = Env.MinX; double Y1 = Env.MaxY; double X2 = Env.MaxX; double Y2 = Env.MaxY; double X3 = Env.MaxX; double Y3 = Env.MinY; double X4 = Env.MinX; double Y4 = Env.MinY; cairo_matrix_transform_point(&Matrix, &X1, &Y1); cairo_matrix_transform_point(&Matrix, &X2, &Y2); cairo_matrix_transform_point(&Matrix, &X3, &Y3); cairo_matrix_transform_point(&Matrix, &X4, &Y4); Env.MinX = wxMin(wxMin(X1, X2), wxMin(X3, X4)); Env.MinY = wxMin(wxMin(Y1, Y2), wxMin(Y3, Y4)); Env.MaxX = wxMax(wxMax(X1, X2), wxMax(X3, X4)); Env.MaxY = wxMax(wxMax(Y1, Y2), wxMax(Y3, Y4)); }
cairo_status_t _cairo_surface_offset_paint (cairo_surface_t *target, int x, int y, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t *dev_clip = (cairo_clip_t *) clip; cairo_pattern_union_t source_copy; if (unlikely (target->status)) return target->status; if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; if (x | y) { cairo_matrix_t m; dev_clip = _cairo_clip_copy_with_translation (clip, -x, -y); cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; } status = _cairo_surface_paint (target, op, source, dev_clip); if (dev_clip != clip) _cairo_clip_destroy (dev_clip); return status; }
static cairo_status_t _cairo_surface_subsurface_acquire_source_image (void *abstract_surface, cairo_image_surface_t **image_out, void **extra_out) { cairo_surface_subsurface_t *surface = abstract_surface; cairo_surface_pattern_t pattern; cairo_surface_t *image; cairo_status_t status; image = _cairo_image_surface_create_with_content (surface->base.content, surface->extents.width, surface->extents.height); if (unlikely (image->status)) return image->status; _cairo_pattern_init_for_surface (&pattern, surface->target); cairo_matrix_init_translate (&pattern.base.matrix, surface->extents.x, surface->extents.y); pattern.base.filter = CAIRO_FILTER_NEAREST; status = _cairo_surface_paint (image, CAIRO_OPERATOR_SOURCE, &pattern.base, NULL); _cairo_pattern_fini (&pattern.base); if (unlikely (status)) { cairo_surface_destroy (image); return status; } *image_out = (cairo_image_surface_t *)image; *extra_out = NULL; return CAIRO_STATUS_SUCCESS; }
static void render_border (cairo_t *cr, cairo_surface_t *surface, guint side, gdouble x, gdouble y, gdouble width, gdouble height, GtkSliceSideModifier modifier) { cairo_pattern_t *pattern; cairo_matrix_t matrix; cairo_save (cr); cairo_rectangle (cr, x, y, width, height); cairo_clip (cr); pattern = cairo_pattern_create_for_surface (surface); if (modifier == GTK_SLICE_REPEAT) { cairo_matrix_init_translate (&matrix, - x, - y); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); cairo_pattern_set_matrix (pattern, &matrix); cairo_set_source (cr, pattern); cairo_rectangle (cr, x, y, width, height); cairo_fill (cr); } else { /* Use nearest filter so borders aren't blurred */ cairo_pattern_set_filter (pattern, CAIRO_FILTER_NEAREST); if (side == SIDE_TOP || side == SIDE_BOTTOM) { gint w = cairo_image_surface_get_width (surface); cairo_translate (cr, x, y); cairo_scale (cr, width / w, 1.0); } else { gint h = cairo_image_surface_get_height (surface); cairo_translate (cr, x, y); cairo_scale (cr, 1.0, height / h); } cairo_set_source (cr, pattern); cairo_rectangle (cr, x, y, width, height); cairo_paint (cr); } cairo_restore (cr); cairo_pattern_destroy (pattern); }
static cairo_status_t _cairo_default_context_set_source_surface (void *abstract_cr, cairo_surface_t *surface, double x, double y) { cairo_default_context_t *cr = abstract_cr; cairo_pattern_t *pattern; cairo_matrix_t matrix; cairo_status_t status; /* push the current pattern to the freed lists */ _cairo_default_context_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black); pattern = cairo_pattern_create_for_surface (surface); if (unlikely (pattern->status)) return pattern->status; cairo_matrix_init_translate (&matrix, -x, -y); cairo_pattern_set_matrix (pattern, &matrix); status = _cairo_default_context_set_source (cr, pattern); cairo_pattern_destroy (pattern); return status; }
void _cairo_clip_translate (cairo_clip_t *clip, cairo_fixed_t tx, cairo_fixed_t ty) { if (clip->region) { pixman_region_translate (clip->region, _cairo_fixed_integer_part (tx), _cairo_fixed_integer_part (ty)); } if (clip->surface) { clip->surface_rect.x += _cairo_fixed_integer_part (tx); clip->surface_rect.y += _cairo_fixed_integer_part (ty); } if (clip->path) { cairo_clip_path_t *clip_path = clip->path; cairo_matrix_t matrix; cairo_matrix_init_translate (&matrix, _cairo_fixed_to_double (tx), _cairo_fixed_to_double (ty)); while (clip_path) { _cairo_path_fixed_device_transform (&clip_path->path, &matrix); clip_path = clip_path->prev; } } }
bool ScreenAreaCairo::on_draw(const Cairo::RefPtr<Cairo::Context> &poContext) { DrawingArea::on_draw(poContext); Cairo::RefPtr< Cairo::ImageSurface > poImage; Cairo::RefPtr< Cairo::SurfacePattern > poPattern; Cairo::Matrix oMatrix; const int iScaledPitch = m_iWidth * sizeof(u32); poContext->set_identity_matrix(); poContext->scale(m_dScaleFactor, m_dScaleFactor); poImage = Cairo::ImageSurface::create((u8 *)m_puiPixels, Cairo::FORMAT_RGB24, m_iWidth, m_iHeight, iScaledPitch); cairo_matrix_init_translate(&oMatrix, -m_iAreaLeft, -m_iAreaTop); poPattern = Cairo::SurfacePattern::create(poImage); poPattern->set_filter(Cairo::FILTER_NEAREST); poPattern->set_matrix (oMatrix); poContext->set_source_rgb(0.0, 0.0, 0.0); poContext->paint(); poContext->set_source(poPattern); poContext->paint(); return true; }
static cairo_surface_t * _cairo_surface_subsurface_snapshot (void *abstract_surface) { cairo_surface_subsurface_t *surface = abstract_surface; cairo_surface_pattern_t pattern; cairo_surface_t *clone; cairo_status_t status; TRACE ((stderr, "%s: target=%d\n", __FUNCTION__, surface->target->unique_id)); clone = _cairo_surface_create_similar_scratch (surface->target, surface->target->content, surface->extents.width, surface->extents.height); if (unlikely (clone->status)) return clone; _cairo_pattern_init_for_surface (&pattern, surface->target); cairo_matrix_init_translate (&pattern.base.matrix, surface->extents.x, surface->extents.y); pattern.base.filter = CAIRO_FILTER_NEAREST; status = _cairo_surface_paint (clone, CAIRO_OPERATOR_SOURCE, &pattern.base, NULL); _cairo_pattern_fini (&pattern.base); if (unlikely (status)) { cairo_surface_destroy (clone); clone = _cairo_surface_create_in_error (status); } return clone; }
static int m_cairo_matrix_init_translate(lua_State * L) { cairo_matrix_t * matrix = luaL_checkudata(L, 1, MT_NAME_CAIRO_MATRIX); double tx = luaL_checknumber(L, 2); double ty = luaL_checknumber(L, 3); cairo_matrix_init_translate(matrix, tx, ty); return 0; }
static void redraw_handler(struct widget *widget, void *data) { struct image *image = data; struct rectangle allocation; cairo_t *cr; cairo_surface_t *surface; double width, height, doc_aspect, window_aspect, scale; cairo_matrix_t matrix; cairo_matrix_t translate; surface = window_get_surface(image->window); cr = cairo_create(surface); widget_get_allocation(image->widget, &allocation); cairo_rectangle(cr, allocation.x, allocation.y, allocation.width, allocation.height); cairo_clip(cr); cairo_push_group(cr); cairo_translate(cr, allocation.x, allocation.y); cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_rgba(cr, 0, 0, 0, 1); cairo_paint(cr); if (!image->initialized) { image->initialized = true; width = cairo_image_surface_get_width(image->image); height = cairo_image_surface_get_height(image->image); doc_aspect = width / height; window_aspect = (double) allocation.width / allocation.height; if (doc_aspect < window_aspect) scale = allocation.height / height; else scale = allocation.width / width; image->width = width; image->height = height; cairo_matrix_init_scale(&image->matrix, scale, scale); clamp_view(image); } matrix = image->matrix; cairo_matrix_init_translate(&translate, allocation.x, allocation.y); cairo_matrix_multiply(&matrix, &matrix, &translate); cairo_set_matrix(cr, &matrix); cairo_set_source_surface(cr, image->image, 0, 0); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_paint(cr); cairo_pop_group_to_source(cr); cairo_paint(cr); cairo_destroy(cr); cairo_surface_destroy(surface); }
/** * cairo_matrix_translate: * @matrix: a #cairo_matrix_t * @tx: amount to translate in the X direction * @ty: amount to translate in the Y direction * * Applies a translation by @tx, @ty to the transformation in * @matrix. The effect of the new transformation is to first translate * the coordinates by @tx and @ty, then apply the original transformation * to the coordinates. **/ void cairo_matrix_translate (cairo_matrix_t *matrix, double tx, double ty) { cairo_matrix_t tmp; cairo_matrix_init_translate (&tmp, tx, ty); cairo_matrix_multiply (matrix, &tmp, matrix); }
cairo_status_t _cairo_surface_offset_glyphs (cairo_surface_t *surface, int x, int y, cairo_operator_t op, const cairo_pattern_t *source, cairo_scaled_font_t *scaled_font, cairo_glyph_t *glyphs, int num_glyphs, const cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t *dev_clip = (cairo_clip_t *) clip; cairo_pattern_union_t source_copy; cairo_glyph_t *dev_glyphs; int i; if (unlikely (surface->status)) return surface->status; if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; dev_glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t)); if (dev_glyphs == NULL) return _cairo_error (CAIRO_STATUS_NO_MEMORY); memcpy (dev_glyphs, glyphs, sizeof (cairo_glyph_t) * num_glyphs); if (x | y) { cairo_matrix_t m; dev_clip = _cairo_clip_copy_with_translation (clip, -x, -y); cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; for (i = 0; i < num_glyphs; i++) { dev_glyphs[i].x -= x; dev_glyphs[i].y -= y; } } status = _cairo_surface_show_text_glyphs (surface, op, source, NULL, 0, dev_glyphs, num_glyphs, NULL, 0, 0, scaled_font, dev_clip); if (dev_clip != clip) _cairo_clip_destroy (dev_clip); cr_free (dev_glyphs); return status; }
void gtk_css_style_render_icon_surface (GtkCssStyle *style, cairo_t *cr, cairo_surface_t *surface, double x, double y) { const GtkCssValue *shadows; cairo_matrix_t matrix, transform_matrix, saved_matrix; GdkRectangle extents; g_return_if_fail (GTK_IS_CSS_STYLE (style)); g_return_if_fail (cr != NULL); g_return_if_fail (surface != NULL); shadows = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_SHADOW); if (!get_surface_extents (surface, &extents)) { /* weird infinite surface, no special magic for you */ cairo_set_source_surface (cr, surface, x, y); _gtk_css_shadows_value_paint_icon (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_SHADOW), cr); cairo_paint (cr); return; } cairo_get_matrix (cr, &saved_matrix); cairo_translate (cr, x + extents.x, y + extents.y); if (_gtk_css_transform_value_get_matrix (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_TRANSFORM), &transform_matrix)) { cairo_pattern_t *pattern; /* XXX: Implement -gtk-icon-transform-origin instead of hardcoding "50% 50%" here */ cairo_matrix_init_translate (&matrix, extents.width / 2, extents.height / 2); cairo_matrix_multiply (&matrix, &transform_matrix, &matrix); cairo_matrix_translate (&matrix, - extents.width / 2, - extents.height / 2); if (cairo_matrix_invert (&matrix) != CAIRO_STATUS_SUCCESS) { g_assert_not_reached (); } cairo_matrix_translate (&matrix, extents.x, extents.y); pattern = cairo_pattern_create_for_surface (surface); cairo_pattern_set_matrix (pattern, &matrix); cairo_set_source (cr, pattern); cairo_pattern_destroy (pattern); _gtk_css_shadows_value_paint_icon (shadows, cr); cairo_paint (cr); } cairo_set_matrix (cr, &saved_matrix); }
cairo_status_t _cairo_surface_offset_fill (cairo_surface_t *surface, int x, int y, cairo_operator_t op, const cairo_pattern_t*source, const cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, double tolerance, cairo_antialias_t antialias, const cairo_clip_t *clip) { cairo_status_t status; cairo_path_fixed_t path_copy, *dev_path = (cairo_path_fixed_t *) path; cairo_clip_t *dev_clip = (cairo_clip_t *) clip; cairo_pattern_union_t source_copy; if (unlikely (surface->status)) return surface->status; if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; if (x | y) { cairo_matrix_t m; dev_clip = _cairo_clip_copy_with_translation (clip, -x, -y); status = _cairo_path_fixed_init_copy (&path_copy, dev_path); if (unlikely (status)) goto FINISH; _cairo_path_fixed_translate (&path_copy, _cairo_fixed_from_int (-x), _cairo_fixed_from_int (-y)); dev_path = &path_copy; cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; } status = _cairo_surface_fill (surface, op, source, dev_path, fill_rule, tolerance, antialias, dev_clip); FINISH: if (dev_path != path) _cairo_path_fixed_fini (dev_path); if (dev_clip != clip) _cairo_clip_destroy (dev_clip); return status; }
static cairo_int_status_t _cairo_gl_surface_show_glyphs_via_mask (cairo_gl_surface_t *dst, cairo_operator_t op, const cairo_pattern_t *source, cairo_glyph_t *glyphs, int num_glyphs, const cairo_rectangle_int_t *glyph_extents, cairo_scaled_font_t *scaled_font, cairo_clip_t *clip, int *remaining_glyphs) { cairo_surface_t *mask; cairo_status_t status; cairo_solid_pattern_t solid; int i; mask = cairo_gl_surface_create (dst->ctx, CAIRO_CONTENT_ALPHA, glyph_extents->width, glyph_extents->height); if (unlikely (mask->status)) return mask->status; for (i = 0; i < num_glyphs; i++) { glyphs[i].x -= glyph_extents->x; glyphs[i].y -= glyph_extents->y; } _cairo_pattern_init_solid (&solid, CAIRO_COLOR_WHITE, CAIRO_CONTENT_ALPHA); status = _render_glyphs ((cairo_gl_surface_t *) mask, 0, 0, CAIRO_OPERATOR_ADD, &solid.base, glyphs, num_glyphs, glyph_extents, scaled_font, NULL, remaining_glyphs); if (likely (status == CAIRO_STATUS_SUCCESS)) { cairo_surface_pattern_t mask_pattern; _cairo_pattern_init_for_surface (&mask_pattern, mask); cairo_matrix_init_translate (&mask_pattern.base.matrix, -glyph_extents->x, -glyph_extents->y); status = _cairo_surface_mask (&dst->base, op, source, &mask_pattern.base, clip); _cairo_pattern_fini (&mask_pattern.base); } else { for (i = 0; i < num_glyphs; i++) { glyphs[i].x += glyph_extents->x; glyphs[i].y += glyph_extents->y; } *remaining_glyphs = num_glyphs; } cairo_surface_destroy (mask); return status; }
static cairo_scaled_font_t * create_scaled_font (cairo_t * cr) { FcPattern *pattern, *resolved; FcResult result; cairo_font_face_t *font_face; cairo_scaled_font_t *scaled_font; cairo_font_options_t *font_options; cairo_matrix_t font_matrix, ctm; double pixel_size; font_options = cairo_font_options_create (); cairo_get_font_options (cr, font_options); pattern = FcPatternCreate (); FcPatternAddString (pattern, FC_FAMILY, (FcChar8 *)"Bitstream Vera Sans"); FcPatternAddDouble (pattern, FC_PIXEL_SIZE, TEXT_SIZE); FcConfigSubstitute (NULL, pattern, FcMatchPattern); cairo_ft_font_options_substitute (font_options, pattern); FcDefaultSubstitute (pattern); resolved = FcFontMatch (NULL, pattern, &result); /* set layout to vertical */ FcPatternDel (resolved, FC_VERTICAL_LAYOUT); FcPatternAddBool (resolved, FC_VERTICAL_LAYOUT, FcTrue); FcPatternGetDouble (resolved, FC_PIXEL_SIZE, 0, &pixel_size); font_face = cairo_ft_font_face_create_for_pattern (resolved); cairo_matrix_init_translate (&font_matrix, 10, 30); cairo_matrix_rotate (&font_matrix, M_PI_2/3); cairo_matrix_scale (&font_matrix, pixel_size, pixel_size); cairo_get_matrix (cr, &ctm); scaled_font = cairo_scaled_font_create (font_face, &font_matrix, &ctm, font_options); cairo_font_options_destroy (font_options); cairo_font_face_destroy (font_face); FcPatternDestroy (pattern); FcPatternDestroy (resolved); return scaled_font; }
void e_canvas_item_move_absolute (GnomeCanvasItem *item, gdouble dx, gdouble dy) { cairo_matrix_t translate; g_return_if_fail (GNOME_IS_CANVAS_ITEM (item)); cairo_matrix_init_translate (&translate, dx, dy); gnome_canvas_item_set_matrix (item, &translate); }
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 inline void _mume_bitblt_image( cairo_t *cr, int x1, int y1, int w1, int h1, cairo_pattern_t *p, int x2, int y2) { /* Similar to BitBlt in win32 GDI. */ if (w1 > 0 && h1 > 0) { cairo_matrix_t matrix; cairo_matrix_init_translate( &matrix, x2 - x1, y2 - y1); cairo_pattern_set_matrix(p, &matrix); cairo_rectangle(cr, x1, y1, w1, h1); cairo_fill(cr); } }
/** * adg_table_cell_arrange: * @table_cell: an #AdgTableCell * @layout: the new extents to use * * Rearranges the underlying #AdgTableCell owned by @table_cell using * the new extents provided in @layout. If the x or y size component * of @layout is negative, the value holded by the internal extents * struct is not overriden. * * <note><para> * table_cell->extents must be up to date if @layout->size.x or * @layout->size.y is negative in order to have a valid size. * </para></note> * * Returns: the extents of @table_cell or <constant>NULL</constant> on errors. * * Since: 1.0 **/ const CpmlExtents * adg_table_cell_arrange(AdgTableCell *table_cell, const CpmlExtents *layout) { CpmlExtents *extents; AdgAlignment *alignment; cairo_matrix_t map; /* Set the new extents */ extents = &table_cell->extents; extents->org = layout->org; if (layout->size.x > 0) extents->size.x = layout->size.x; if (layout->size.y > 0) extents->size.y = layout->size.y; extents->is_defined = TRUE; if (table_cell->title) { alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->title); cairo_matrix_init_translate(&map, extents->org.x, extents->org.y); adg_entity_set_global_map((AdgEntity *) alignment, &map); } if (table_cell->value) { CpmlPair to; alignment = (AdgAlignment *) adg_entity_get_parent(table_cell->value); to.x = extents->size.x * table_cell->value_factor.x + extents->org.x; to.y = extents->size.y * table_cell->value_factor.y + extents->org.y; cairo_matrix_init_translate(&map, to.x, to.y); adg_entity_set_global_map((AdgEntity *) alignment, &map); } return extents; }
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); }
/** * _adg_size_allocate: * @widget: an #AdgGtkArea widget * @allocation: the new allocation struct * * Scales the drawing according to the new allocation if * #AdgGtkArea:autozoom is <constant>TRUE</constant>. * * TODO: the current implementation initially centers the canvas * on the allocation space. Further allocations (due to a * window resizing, for example) use the top/left corner of the * canvas as reference point. Plan different policies for either * those situations. * * Since: 1.0 **/ static void _adg_size_allocate(GtkWidget *widget, GtkAllocation *allocation) { AdgGtkArea *area; AdgGtkAreaPrivate *data; const CpmlExtents *sheet; CpmlVector size; gdouble factor; if (_ADG_OLD_WIDGET_CLASS->size_allocate) _ADG_OLD_WIDGET_CLASS->size_allocate(widget, allocation); area = (AdgGtkArea *) widget; data = area->data; sheet = _adg_get_extents(area); if (!sheet->is_defined || sheet->size.x <= 0 || sheet->size.y <= 0) return; size.x = allocation->width; size.y = allocation->height; if (data->autozoom) { /* Adjust the zoom according to the allocation and sheet size */ factor = MIN(size.x / sheet->size.x, size.y / sheet->size.y); } else if (!data->initialized) { /* First allocation with autozoom off: keep the current zoom */ factor = 1; } else { /* Not the first allocation and autozoom off: keep the old map */ return; } if (!data->initialized) { /* TODO: plan different attachment policies other than centering */ cairo_matrix_init_translate(&data->render_map, (size.x - sheet->size.x) / 2 - sheet->org.x, (size.y - sheet->size.y) / 2 - sheet->org.y); data->initialized = TRUE; } /* TODO: plan other reference points other than left/top (x0, y0) */ data->render_map.x0 *= factor; data->render_map.y0 *= factor; data->render_map.xx *= factor; data->render_map.yy *= factor; }
static inline void _mume_stretch_image( cairo_t *cr, int x1, int y1, int w1, int h1, cairo_pattern_t *p, int x2, int y2, int w2, int h2) { /* Similar to StretchBlt in win32 GDI. */ if (w1 > 0 && h1 > 0 && w2 > 0 && h2 > 0) { cairo_matrix_t matrix; double hr = (double)w2 / (double)w1; double vr = (double)h2 / (double)h1; cairo_matrix_init_translate( &matrix, (double)x2 - x1 * hr, (double)y2 - y1 * vr); cairo_matrix_scale(&matrix, hr, vr); cairo_pattern_set_matrix(p, &matrix); cairo_rectangle(cr, x1, y1, w1, h1); cairo_fill(cr); } }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_pattern_t *pattern; cairo_matrix_t matrix; /* Paint a diagonal division as a test image */ cairo_set_source_rgb (cr, 1, 1, 1); /* White */ cairo_paint (cr); cairo_move_to (cr, SIZE, 0); cairo_line_to (cr, SIZE, SIZE); cairo_line_to (cr, 0, SIZE); cairo_set_source_rgb (cr, 0, 0, 0); cairo_fill (cr); /* Create a pattern with the target surface as the source, * offset by SIZE/2 */ pattern = cairo_pattern_create_for_surface (cairo_get_group_target (cr)); cairo_matrix_init_translate (&matrix, - SIZE / 2, - SIZE / 2); cairo_pattern_set_matrix (pattern, &matrix); cairo_set_source (cr, pattern); cairo_pattern_destroy (pattern); /* Copy two rectangles from the upper-left quarter of the image to * the lower right. It will work if we use cairo_fill(), but the * cairo_clip() cairo_paint() combination fails because the clip * on the surface as a destination affects it as the source as * well. */ cairo_rectangle (cr, 2 * SIZE / 4, 2 * SIZE / 4, SIZE / 4, SIZE / 4); cairo_rectangle (cr, 3 * SIZE / 4, 3 * SIZE / 4, SIZE / 4, SIZE / 4); cairo_clip (cr); cairo_paint (cr); return CAIRO_TEST_SUCCESS; }
cairo_status_t _cairo_surface_fallback_clone_similar (cairo_surface_t *surface, cairo_surface_t *src, cairo_content_t content, int src_x, int src_y, int width, int height, int *clone_offset_x, int *clone_offset_y, cairo_surface_t **clone_out) { cairo_surface_t *new_surface; cairo_surface_pattern_t pattern; cairo_status_t status; new_surface = _cairo_surface_create_similar_scratch (surface, src->content & content, width, height); if (new_surface->status) return new_surface->status; /* We have to copy these here, so that the coordinate spaces are correct */ new_surface->device_transform = src->device_transform; new_surface->device_transform_inverse = src->device_transform_inverse; _cairo_pattern_init_for_surface (&pattern, src); cairo_matrix_init_translate (&pattern.base.matrix, src_x, src_y); pattern.base.filter = CAIRO_FILTER_NEAREST; status = _cairo_surface_paint (new_surface, CAIRO_OPERATOR_SOURCE, &pattern.base, NULL); _cairo_pattern_fini (&pattern.base); if (unlikely (status)) { cairo_surface_destroy (new_surface); return status; } *clone_offset_x = src_x; *clone_offset_y = src_y; *clone_out = new_surface; return CAIRO_STATUS_SUCCESS; }
/** * adg_table_cell_set_text_title: * @table_cell: a valid #AdgTableCell * @title: a text string * * Convenient function to set a the title of a cell using an #AdgToyText * entity with the font dress picked from #AdgTable:table-dress with * a call to adg_table_style_get_title_dress(). * * Since: 1.0 **/ void adg_table_cell_set_text_title(AdgTableCell *table_cell, const gchar *title) { AdgTable *table; AdgEntity *entity; AdgTableStyle *table_style; const CpmlPair *padding; AdgDress table_dress, font_dress; cairo_matrix_t map; g_return_if_fail(table_cell != NULL); if (title == NULL) adg_table_cell_set_title(table_cell, NULL); if (table_cell->title) { gchar *old_title; gboolean unchanged; if (ADG_IS_TEXTUAL(table_cell->title)) old_title = adg_textual_dup_text((AdgTextual *) table_cell->title); else old_title = NULL; unchanged = g_strcmp0(title, old_title) == 0; g_free(old_title); if (unchanged) return; } table = adg_table_cell_get_table(table_cell); table_dress = adg_table_get_table_dress(table); table_style = (AdgTableStyle *) adg_entity_style((AdgEntity *) table, table_dress); padding = adg_table_style_get_cell_padding(table_style); font_dress = adg_table_style_get_title_dress(table_style); entity = g_object_new(ADG_TYPE_BEST_TEXT, "text", title, "font-dress", font_dress, NULL); cairo_matrix_init_translate(&map, padding->x, padding->y); adg_entity_set_global_map(entity, &map); adg_table_cell_set_title(table_cell, entity); }