static cairo_surface_t * byzanz_recorder_create_snapshot (ByzanzRecorder *recorder, const cairo_region_t *invalid) { cairo_rectangle_int_t extents; cairo_surface_t *surface; cairo_t *cr; GSequenceIter *iter; int i, num_rects; cairo_region_get_extents (invalid, &extents); cr = gdk_cairo_create (recorder->window); surface = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR, extents.width, extents.height); cairo_destroy (cr); cairo_surface_set_device_offset (surface, -extents.x, -extents.y); cr = cairo_create (surface); num_rects = cairo_region_num_rectangles (invalid); for (i = 0; i < num_rects; i++) { cairo_rectangle_int_t rect; cairo_region_get_rectangle (invalid, i, &rect); cairo_rectangle (cr, rect.x, rect.y, rect.width, rect.height); } cairo_clip (cr); for (iter = g_sequence_get_begin_iter (recorder->layers); !g_sequence_iter_is_end (iter); iter = g_sequence_iter_next (iter)) { ByzanzLayer *layer = g_sequence_get (iter); ByzanzLayerClass *klass = BYZANZ_LAYER_GET_CLASS (layer); cairo_save (cr); klass->render (layer, cr); if (cairo_status (cr)) g_critical ("error capturing image: %s", cairo_status_to_string (cairo_status (cr))); cairo_restore (cr); } cairo_destroy (cr); surface = ensure_image_surface (surface, invalid); /* adjust device offset here - the layers work in GdkScreen coordinates, the rest * of the code works in coordinates realtive to the passed in area. */ cairo_surface_set_device_offset (surface, recorder->area.x - extents.x, recorder->area.y - extents.y); return surface; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_surface_t *surface, *target; cairo_t *cr2; /* First draw a shape in blue on the original destination. */ cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ draw_square (cr); /* Then, create an offset surface and repeat the drawing in red. */ target = cairo_get_group_target (cr); surface = cairo_surface_create_similar (target, cairo_surface_get_content (target), SIZE / 2, SIZE / 2); cr2 = cairo_create (surface); cairo_set_source_rgb (cr2, 1, 0, 0); /* red */ draw_square (cr2); cairo_destroy (cr2); cairo_surface_set_device_offset (surface, + SIZE / 2, + SIZE / 2); /* Finally, copy the offset surface to the original destination. * The final result should be a blue square with the upper-left * quarter red. */ cairo_set_source_surface (cr, surface, SIZE / 2, SIZE / 2); cairo_paint (cr); cairo_surface_destroy (surface); return CAIRO_TEST_SUCCESS; }
static int surface_set_device_offset (lua_State *L) { cairo_surface_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_SURFACE); cairo_surface_set_device_offset(*obj, luaL_checknumber(L, 2), luaL_checknumber(L, 3)); return 0; }
static cairo_surface_t * _cairo_xcb_surface_map_to_image (void *abstract_surface, const cairo_rectangle_int_t *extents) { cairo_xcb_surface_t *surface = abstract_surface; cairo_surface_t *image; if (surface->fallback) return surface->fallback->base.backend->map_to_image (&surface->fallback->base, extents); image = _get_image (surface, TRUE, extents->x, extents->y, extents->width, extents->height); if (unlikely (image->status)) return image; /* Do we have a deferred clear and this image surface does NOT cover the * whole xcb surface? Have to apply the clear in that case, else * uploading the image will handle the problem for us. */ if (surface->deferred_clear && ! (extents->width == surface->width && extents->height == surface->height)) { cairo_status_t status = _cairo_xcb_surface_clear (surface); if (unlikely (status)) { cairo_surface_destroy(image); return _cairo_surface_create_in_error (status); } } surface->deferred_clear = FALSE; cairo_surface_set_device_offset (image, -extents->x, -extents->y); return image; }
/* A convenience function for when one needs to coerce an image * surface to an alternate format. */ cairo_image_surface_t * _cairo_image_surface_clone (cairo_image_surface_t *surface, cairo_format_t format) { cairo_image_surface_t *clone; cairo_status_t status; cairo_t *cr; double x, y; clone = (cairo_image_surface_t *) cairo_image_surface_create (format, surface->width, surface->height); cairo_surface_get_device_offset (&surface->base, &x, &y); cairo_surface_set_device_offset (&clone->base, x, y); clone->transparency = CAIRO_IMAGE_UNKNOWN; /* XXX Use _cairo_surface_composite directly */ cr = cairo_create (&clone->base); cairo_set_source_surface (cr, &surface->base, 0, 0); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_paint (cr); status = cairo_status (cr); cairo_destroy (cr); if (status) { cairo_surface_destroy (&clone->base); return (cairo_image_surface_t *) _cairo_surface_create_in_error (status); } return clone; }
static gboolean seed_cairo_surface_set_device_offset(SeedContext ctx, SeedObject this_object, SeedString property_name, SeedValue value, SeedException *exception) { cairo_surface_t *surf; gdouble x, y; SeedValue jsx, jsy; CHECK_THIS_BOOL(); if (!seed_value_is_object (ctx, value)) { seed_make_exception(ctx, exception, "ArgumentError", "Cairo.Surface.device_offset must be an array [x,y]"); return FALSE; } jsx = seed_object_get_property_at_index (ctx, (SeedObject) value, 0, exception); jsy = seed_object_get_property_at_index (ctx, (SeedObject) value, 1, exception); surf = seed_object_to_cairo_surface (ctx, this_object, exception); x = seed_value_to_double (ctx, jsx, exception); y = seed_value_to_double (ctx, jsy, exception); cairo_surface_set_device_offset (surf, x, y); return TRUE; }
static cairo_surface_t * ensure_image_surface (cairo_surface_t *surface, const cairo_region_t *region) { cairo_rectangle_int_t extents; cairo_surface_t *image; cairo_t *cr; int i, num_rects; if (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE) return surface; cairo_region_get_extents (region, &extents); image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, extents.width, extents.height); cairo_surface_set_device_offset (image, -extents.x, -extents.y); cr = cairo_create (image); cairo_set_source_surface (cr, surface, 0, 0); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); num_rects = cairo_region_num_rectangles (region); for (i = 0; i < num_rects; i++) { cairo_rectangle_int_t rect; cairo_region_get_rectangle (region, i, &rect); cairo_rectangle (cr, rect.x, rect.y, rect.width, rect.height); } cairo_fill (cr); cairo_destroy (cr); cairo_surface_destroy (surface); return image; }
void draw_tile(cairo_t *cr, cairo_matrix_t m, cairo_rectangle_t r, int tx, int ty) { if (cr !=NULL) { cairo_save(cr); /* Use the rect and pattern */ c_rect(cr, r); cairo_set_source (cr, tile_pattern); /* Pull the tile we need */ cairo_surface_set_device_offset(graphical_tiles, tx - r.x, ty - r.y); /* Use transparency */ cairo_set_operator(cr, CAIRO_OPERATOR_ADD); /* Use the matrix with our pattern */ cairo_pattern_set_matrix(tile_pattern, &m); /* Draw it */ cairo_fill(cr); cairo_restore(cr); } }
static void drag_begin_callback (GtkWidget *widget, GdkDragContext *context, gpointer data) { NemoIconContainer *container; cairo_surface_t *surface; double x1, y1, x2, y2, winx, winy; int x_offset, y_offset; int start_x, start_y; container = NEMO_ICON_CONTAINER (widget); start_x = container->details->dnd_info->drag_info.start_x + gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container))); start_y = container->details->dnd_info->drag_info.start_y + gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container))); /* create a pixmap and mask to drag with */ surface = nemo_icon_canvas_item_get_drag_surface (container->details->drag_icon->item); /* compute the image's offset */ eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (container->details->drag_icon->item), &x1, &y1, &x2, &y2); eel_canvas_world_to_window (EEL_CANVAS (container), x1, y1, &winx, &winy); x_offset = start_x - winx; y_offset = start_y - winy; cairo_surface_set_device_offset (surface, -x_offset, -y_offset); gtk_drag_set_icon_surface (context, surface); cairo_surface_destroy (surface); }
void DragAndDropHandler::startDrag(Ref<SelectionData>&& selection, DragOperation dragOperation, RefPtr<ShareableBitmap>&& dragImage) { #if GTK_CHECK_VERSION(3, 16, 0) m_draggingSelectionData = WTFMove(selection); GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForSelectionData(*m_draggingSelectionData); #else RefPtr<SelectionData> selectionData = WTFMove(selection); GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForSelectionData(*selectionData); #endif GUniquePtr<GdkEvent> currentEvent(gtk_get_current_event()); GdkDragContext* context = gtk_drag_begin(m_page.viewWidget(), targetList.get(), dragOperationToGdkDragActions(dragOperation), GDK_BUTTON_PRIMARY, currentEvent.get()); #if GTK_CHECK_VERSION(3, 16, 0) // WebCore::EventHandler does not support more than one DnD operation at the same time for // a given page, so we should cancel any previous operation whose context we might have // stored, should we receive a new startDrag event before finishing a previous DnD operation. if (m_dragContext) gtk_drag_cancel(m_dragContext.get()); m_dragContext = context; #else // We don't have gtk_drag_cancel() in GTK+ < 3.16, so we use the old code. // See https://bugs.webkit.org/show_bug.cgi?id=138468 m_draggingSelectionDataMap.set(context, WTFMove(selectionData)); #endif if (dragImage) { RefPtr<cairo_surface_t> image(dragImage->createCairoSurface()); // Use the center of the drag image as hotspot. cairo_surface_set_device_offset(image.get(), -cairo_image_surface_get_width(image.get()) / 2, -cairo_image_surface_get_height(image.get()) / 2); gtk_drag_set_icon_surface(context, image.get()); } else gtk_drag_set_icon_default(context); }
static VALUE cr_surface_set_device_offset (VALUE self, VALUE x_offset, VALUE y_offset) { cairo_surface_set_device_offset (_SELF, NUM2DBL (x_offset), NUM2DBL (y_offset)); cr_surface_check_status (_SELF); return self; }
IoObject *IoCairoSurface_setDeviceOffset(IoCairoSurface *self, IoObject *locals, IoMessage *m) { double x = IoMessage_locals_doubleArgAt_(m, locals, 0); double y = IoMessage_locals_doubleArgAt_(m, locals, 1); cairo_surface_set_device_offset(SURFACE(self), x, y); CHECK_STATUS(self); return self; }
cairo_t * gsk_cairo_blur_start_drawing (cairo_t *cr, float radius, GskBlurFlags blur_flags) { cairo_rectangle_int_t clip_rect; cairo_surface_t *surface; cairo_t *blur_cr; gdouble clip_radius; gdouble x_scale, y_scale; gboolean blur_x = (blur_flags & GSK_BLUR_X) != 0; gboolean blur_y = (blur_flags & GSK_BLUR_Y) != 0; if (!needs_blur (radius)) return cr; gdk_cairo_get_clip_rectangle (cr, &clip_rect); clip_radius = gsk_cairo_blur_compute_pixels (radius); x_scale = y_scale = 1; cairo_surface_get_device_scale (cairo_get_target (cr), &x_scale, &y_scale); if (blur_flags & GSK_BLUR_REPEAT) { if (!blur_x) clip_rect.width = 1; if (!blur_y) clip_rect.height = 1; } /* Create a larger surface to center the blur. */ surface = cairo_surface_create_similar_image (cairo_get_target (cr), CAIRO_FORMAT_A8, x_scale * (clip_rect.width + (blur_x ? 2 * clip_radius : 0)), y_scale * (clip_rect.height + (blur_y ? 2 * clip_radius : 0))); cairo_surface_set_device_scale (surface, x_scale, y_scale); cairo_surface_set_device_offset (surface, x_scale * ((blur_x ? clip_radius : 0) - clip_rect.x), y_scale * ((blur_y ? clip_radius : 0) - clip_rect.y)); blur_cr = cairo_create (surface); cairo_set_user_data (blur_cr, &original_cr_key, cairo_reference (cr), (cairo_destroy_func_t) cairo_destroy); if (cairo_has_current_point (cr)) { double x, y; cairo_get_current_point (cr, &x, &y); cairo_move_to (blur_cr, x, y); } return blur_cr; }
static cairo_status_t _cairo_boilerplate_xcb_finish_surface (cairo_surface_t *surface) { xcb_target_closure_t *xtc = cairo_surface_get_user_data (surface, &xcb_closure_key); xcb_generic_event_t *ev; if (xtc->surface != NULL) { cairo_t *cr; cr = cairo_create (xtc->surface); cairo_surface_set_device_offset (surface, 0, 0); cairo_set_source_surface (cr, surface, 0, 0); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_paint (cr); cairo_destroy (cr); surface = xtc->surface; } cairo_surface_flush (surface); if (cairo_surface_status (surface)) return cairo_surface_status (surface); while ((ev = xcb_poll_for_event (xtc->c)) != NULL) { cairo_status_t status = CAIRO_STATUS_SUCCESS; if (ev->response_type == 0 /* trust me! */) { xcb_generic_error_t *error = (xcb_generic_error_t *) ev; #if XCB_GENERIC_ERROR_HAS_MAJOR_MINOR_CODES fprintf (stderr, "Detected error during xcb run: %d major=%d, minor=%d\n", error->error_code, error->major_code, error->minor_code); #else fprintf (stderr, "Detected error during xcb run: %d\n", error->error_code); #endif free (error); status = CAIRO_STATUS_WRITE_ERROR; } if (status) return status; } if (xcb_connection_has_error (xtc->c)) return CAIRO_STATUS_WRITE_ERROR; return CAIRO_STATUS_SUCCESS; }
static PyObject * surface_set_device_offset (PycairoSurface *o, PyObject *args) { double x_offset, y_offset; if (!PyArg_ParseTuple (args, "dd:Surface.set_device_offset", &x_offset, &y_offset)) return NULL; cairo_surface_set_device_offset (o->surface, x_offset, y_offset); Py_RETURN_NONE; }
cairo_status_t cairo_xml_for_recording_surface (cairo_device_t *device, cairo_surface_t *recording_surface) { cairo_box_t bbox; cairo_rectangle_int_t extents; cairo_surface_t *surface; cairo_xml_t *xml; cairo_status_t status; if (unlikely (device->status)) return device->status; if (unlikely (recording_surface->status)) return recording_surface->status; if (unlikely (device->backend->type != CAIRO_DEVICE_TYPE_XML)) return _cairo_error (CAIRO_STATUS_DEVICE_TYPE_MISMATCH); if (unlikely (! _cairo_surface_is_recording (recording_surface))) return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); status = _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface, &bbox, NULL); if (unlikely (status)) return status; _cairo_box_round_to_rectangle (&bbox, &extents); surface = _cairo_xml_surface_create_internal (device, recording_surface->content, extents.width, extents.height); if (unlikely (surface->status)) return surface->status; xml = (cairo_xml_t *) device; _cairo_xml_printf (xml, "<surface content='%s' width='%d' height='%d'>", _content_to_string (recording_surface->content), extents.width, extents.height); _cairo_xml_indent (xml, 2); cairo_surface_set_device_offset (surface, -extents.x, -extents.y); status = _cairo_recording_surface_replay (recording_surface, surface); cairo_surface_destroy (surface); _cairo_xml_indent (xml, -2); _cairo_xml_printf (xml, "</surface>"); return status; }
static cairo_test_status_t preamble (cairo_test_context_t *ctx) { cairo_surface_t *surface; /* get the error surface */ surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, INT_MAX, INT_MAX); #if CAIRO_HAS_GL_SURFACE cairo_gl_surface_set_size (surface, 0, 0); cairo_gl_surface_swapbuffers (surface); #endif #if CAIRO_HAS_OS2_SURFACE cairo_os2_surface_set_hwnd (surface, 0); cairo_os2_surface_set_size (surface, 0, 0); cairo_os2_surface_set_manual_window_refresh (surface, FALSE); #endif #if CAIRO_HAS_PDF_SURFACE cairo_pdf_surface_restrict_to_version (surface, CAIRO_PDF_VERSION_1_4); cairo_pdf_surface_set_size (surface, 0, 0); #endif #if CAIRO_HAS_PS_SURFACE cairo_ps_surface_set_eps (surface, FALSE); cairo_ps_surface_set_size (surface, 0, 0); cairo_ps_surface_restrict_to_level (surface, CAIRO_PS_LEVEL_2); cairo_ps_surface_dsc_comment (surface, NULL); cairo_ps_surface_dsc_begin_setup (surface); cairo_ps_surface_dsc_begin_page_setup (surface); #endif #if CAIRO_HAS_XCB_SURFACE cairo_xcb_surface_set_size (surface, 0, 0); #endif #if CAIRO_HAS_XLIB_SURFACE cairo_xlib_surface_set_size (surface, 0, 0); cairo_xlib_surface_set_drawable (surface, 0, 0, 0); #endif cairo_surface_set_mime_data (surface, NULL, NULL, 0, NULL, 0); cairo_surface_set_device_offset (surface, 0, 0); cairo_surface_set_fallback_resolution (surface, 0, 0); cairo_surface_destroy (surface); return CAIRO_TEST_SUCCESS; }
Context::Surface::~Surface () { if (surface) { /* restore device offset */ if (!box.IsEmpty ()) cairo_surface_set_device_offset (surface, device_offset.x, device_offset.y); cairo_surface_destroy (surface); } native->unref (); }
void draw_tile(term_data* td, int x, int y, int tx, int ty, bool trans) { cairo_t* cr; cr = cairo_create(td->surface); cairo_rectangle(cr, x * td->font.w, y * td->font.h, td->font.w, td->font.h); cairo_set_source(cr, tile_pattern); cairo_surface_set_device_offset(graphical_tiles, (tx - x) * td->font.w, (ty - y) * td->font.h); // Use transparency. if (trans) cairo_set_operator(cr, CAIRO_OPERATOR_ADD); /* Draw it */ cairo_fill(cr); }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_matrix_t m; int xoffset = 50; int yoffset = 50; cairo_surface_t *shadow; cairo_t *shadow_cr; cairo_path_t *path; cairo_set_source_rgb (cr, 1, 1, 1); cairo_paint (cr); cairo_translate (cr, 130, 130); cairo_rotate (cr, .5);//2*M_PI*angle/360); cairo_rectangle (cr, 0, 0, 50, 100); cairo_get_matrix (cr, &m); shadow = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, 600 - xoffset, 600 - yoffset); cairo_surface_set_device_offset (shadow, xoffset, yoffset); shadow_cr = cairo_create (shadow); cairo_surface_destroy (shadow); cairo_set_source_rgb (shadow_cr, 0, 1, 0); cairo_set_matrix (shadow_cr, &m); path = cairo_copy_path (cr); cairo_new_path (shadow_cr); cairo_append_path (shadow_cr, path); cairo_fill (shadow_cr); cairo_path_destroy (path); cairo_identity_matrix (cr); cairo_translate (cr, 10, 50); cairo_set_source_surface (cr, cairo_get_target (shadow_cr), 0, 0); cairo_paint (cr); cairo_set_matrix (cr, &m); cairo_set_source_rgb (cr, 1, 0, 0); cairo_fill (cr); cairo_destroy (shadow_cr); return CAIRO_TEST_SUCCESS; }
cairo_surface_t * _cairo_boilerplate_svg_get_image_surface (cairo_surface_t *surface, int width, int height) { cairo_surface_t *image; image = _cairo_boilerplate_svg_convert_to_image (surface); cairo_surface_set_device_offset (image, cairo_image_surface_get_width (image) - width, cairo_image_surface_get_height (image) - height); surface = _cairo_boilerplate_get_image_surface (image, width, height); cairo_surface_destroy (image); return surface; }
static cairo_int_status_t _paint_fallback_image (cairo_paginated_surface_t *surface, cairo_rectangle_int_t *rect) { double x_scale = surface->base.x_fallback_resolution / surface->target->x_resolution; double y_scale = surface->base.y_fallback_resolution / surface->target->y_resolution; int x, y, width, height; cairo_status_t status; cairo_surface_t *image; cairo_surface_pattern_t pattern; cairo_clip_t *clip; x = rect->x; y = rect->y; width = rect->width; height = rect->height; image = _cairo_paginated_surface_create_image_surface (surface, ceil (width * x_scale), ceil (height * y_scale)); _cairo_surface_set_device_scale (image, x_scale, y_scale); /* set_device_offset just sets the x0/y0 components of the matrix; * so we have to do the scaling manually. */ cairo_surface_set_device_offset (image, -x*x_scale, -y*y_scale); status = _cairo_recording_surface_replay (surface->recording_surface, image); if (unlikely (status)) goto CLEANUP_IMAGE; _cairo_pattern_init_for_surface (&pattern, image); cairo_matrix_init (&pattern.base.matrix, x_scale, 0, 0, y_scale, -x*x_scale, -y*y_scale); /* the fallback should be rendered at native resolution, so disable * filtering (if possible) to avoid introducing potential artifacts. */ pattern.base.filter = CAIRO_FILTER_NEAREST; clip = _cairo_clip_intersect_rectangle (NULL, rect); status = _cairo_surface_paint (surface->target, CAIRO_OPERATOR_SOURCE, &pattern.base, clip); _cairo_clip_destroy (clip); _cairo_pattern_fini (&pattern.base); CLEANUP_IMAGE: cairo_surface_destroy (image); return (cairo_int_status_t)status; }
static void drag_set_color_icon (GdkDragContext *context, const GdkRGBA *color) { cairo_surface_t *surface; cairo_t *cr; surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 48, 32); cr = cairo_create (surface); gdk_cairo_set_source_rgba (cr, color); cairo_paint (cr); cairo_surface_set_device_offset (surface, -4, -4); gtk_drag_set_icon_surface (context, surface); cairo_destroy (cr); cairo_surface_destroy (surface); }
cairo_surface_t * Context::Surface::Cairo () { if (!surface) { surface = native->Cairo (); /* replace device offset */ if (!box.IsEmpty ()) { cairo_surface_get_device_offset (surface, &device_offset.x, &device_offset.y); cairo_surface_set_device_offset (surface, -box.x, -box.y); } } return cairo_surface_reference (surface); }
cairo_status_t _cairo_boilerplate_svg_finish_surface (cairo_surface_t *surface) { svg_target_closure_t *ptc = cairo_surface_get_user_data (surface, &svg_closure_key); cairo_status_t status; /* Both surface and ptc->target were originally created at the * same dimensions. We want a 1:1 copy here, so we first clear any * device offset on surface. * * In a more realistic use case of device offsets, the target of * this copying would be of a different size than the source, and * the offset would be desirable during the copy operation. */ cairo_surface_set_device_offset (surface, 0, 0); if (ptc->target) { cairo_t *cr; cr = cairo_create (ptc->target); cairo_set_source_surface (cr, surface, 0, 0); cairo_paint (cr); cairo_show_page (cr); status = cairo_status (cr); cairo_destroy (cr); if (status) return status; cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status) return status; surface = ptc->target; } cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status) return status; return CAIRO_STATUS_SUCCESS; }
static cairo_int_status_t _paint_fallback_image (cairo_paginated_surface_t *surface, cairo_box_int_t *box) { double x_scale = surface->base.x_fallback_resolution / surface->target->x_resolution; double y_scale = surface->base.y_fallback_resolution / surface->target->y_resolution; cairo_matrix_t matrix; int x, y, width, height; cairo_status_t status; cairo_surface_t *image; cairo_pattern_t *pattern; x = box->p1.x; y = box->p1.y; width = box->p2.x - x; height = box->p2.y - y; image = _cairo_paginated_surface_create_image_surface (surface, ceil (width * x_scale), ceil (height * y_scale)); _cairo_surface_set_device_scale (image, x_scale, y_scale); /* set_device_offset just sets the x0/y0 components of the matrix; * so we have to do the scaling manually. */ cairo_surface_set_device_offset (image, -x*x_scale, -y*y_scale); status = _cairo_meta_surface_replay (surface->meta, image); if (status) goto CLEANUP_IMAGE; pattern = cairo_pattern_create_for_surface (image); cairo_matrix_init (&matrix, x_scale, 0, 0, y_scale, -x*x_scale, -y*y_scale); cairo_pattern_set_matrix (pattern, &matrix); status = _cairo_surface_paint (surface->target, CAIRO_OPERATOR_SOURCE, pattern); cairo_pattern_destroy (pattern); CLEANUP_IMAGE: cairo_surface_destroy (image); return status; }
cairo_surface_t * _cairo_boilerplate_svg_get_image_surface (cairo_surface_t *surface, int page, int width, int height) { cairo_surface_t *image; if (page != 0) return cairo_boilerplate_surface_create_in_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); image = _cairo_boilerplate_svg_convert_to_image (surface); cairo_surface_set_device_offset (image, cairo_image_surface_get_width (image) - width, cairo_image_surface_get_height (image) - height); surface = _cairo_boilerplate_get_image_surface (image, 0, width, height); cairo_surface_destroy (image); return surface; }
static cairo_status_t _cairo_skia_context_push_group (void *abstract_cr, cairo_content_t content) { cairo_skia_context_t *cr = (cairo_skia_context_t *) abstract_cr; cairo_surface_t *group_surface; cairo_status_t status; int width, height; //clip = _cairo_gstate_get_clip (cr->gstate); width = cr->target->image.width; height = cr->target->image.height; group_surface = cr->target->image.base.backend->create_similar (&cr->target->image.base, content, width, height); #if 0 /* Set device offsets on the new surface so that logically it appears at * the same location on the parent surface -- when we pop_group this, * the source pattern will get fixed up for the appropriate target surface * device offsets, so we want to set our own surface offsets from /that/, * and not from the device origin. */ cairo_surface_set_device_offset (group_surface, parent_surface->device_transform.x0 - extents.x, parent_surface->device_transform.y0 - extents.y); /* If we have a current path, we need to adjust it to compensate for * the device offset just applied. */ _cairo_path_fixed_transform (cr->path, &group_surface->device_transform); #endif status = _cairo_skia_context_save (cr); if (unlikely (status)) { cairo_surface_destroy (group_surface); return status; } cairo_surface_destroy (&cr->target->image.base); cr->target = (cairo_skia_surface_t *) group_surface; return CAIRO_STATUS_SUCCESS; }
static cairo_surface_t * red_acquire (cairo_pattern_t *pattern, void *closure, cairo_surface_t *target, const cairo_rectangle_int_t *extents) { cairo_surface_t *image; cairo_t *cr; image = cairo_surface_create_similar_image (target, CAIRO_FORMAT_RGB24, extents->width, extents->height); cairo_surface_set_device_offset (image, extents->x, extents->y); cr = cairo_create (image); cairo_set_source_rgb (cr, 1, 0, 0); cairo_paint (cr); cairo_destroy (cr); return image; }
cairo_image_surface_t * _cairo_image_surface_map_to_image (void *abstract_other, const cairo_rectangle_int_t *extents) { cairo_image_surface_t *other = abstract_other; cairo_surface_t *surface; uint8_t *data; data = other->data; data += extents->y * other->stride; data += extents->x * PIXMAN_FORMAT_BPP (other->pixman_format)/ 8; surface = _cairo_image_surface_create_with_pixman_format (data, other->pixman_format, extents->width, extents->height, other->stride); cairo_surface_set_device_offset (surface, -extents->x, -extents->y); return (cairo_image_surface_t *) surface; }