/** * cairo_surface_create_for_rectangle: * @target: an existing surface for which the sub-surface will point to * @x: the x-origin of the sub-surface from the top-left of the target surface (in device-space units) * @y: the y-origin of the sub-surface from the top-left of the target surface (in device-space units) * @width: width of the sub-surface (in device-space units) * @height: height of the sub-surface (in device-space units) * * Create a new surface that is a rectangle within the target surface. * All operations drawn to this surface are then clipped and translated * onto the target surface. Nothing drawn via this sub-surface outside of * its bounds is drawn onto the target surface, making this a useful method * for passing constrained child surfaces to library routines that draw * directly onto the parent surface, i.e. with no further backend allocations, * double buffering or copies. * * <note><para>The semantics of subsurfaces have not been finalized yet * unless the rectangle is in full device units, is contained within * the extents of the target surface, and the target or subsurface's * device transforms are not changed.</para></note> * * Return value: a pointer to the newly allocated surface. The caller * owns the surface and should call cairo_surface_destroy() when done * with it. * * This function always returns a valid pointer, but it will return a * pointer to a "nil" surface if @other is already in an error state * or any other error occurs. * * Since: 1.10 **/ cairo_surface_t * cairo_surface_create_for_rectangle (cairo_surface_t *target, double x, double y, double width, double height) { cairo_surface_subsurface_t *surface; if (unlikely (width < 0 || height < 0)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE)); if (unlikely (target->status)) return _cairo_surface_create_in_error (target->status); if (unlikely (target->finished)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); surface = malloc (sizeof (cairo_surface_subsurface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); x *= target->device_transform.xx; y *= target->device_transform.yy; width *= target->device_transform.xx; height *= target->device_transform.yy; x += target->device_transform.x0; y += target->device_transform.y0; _cairo_surface_init (&surface->base, &_cairo_surface_subsurface_backend, NULL, /* device */ target->content); /* XXX forced integer alignment */ surface->extents.x = ceil (x); surface->extents.y = ceil (y); surface->extents.width = floor (x + width) - surface->extents.x; surface->extents.height = floor (y + height) - surface->extents.y; if ((surface->extents.width | surface->extents.height) < 0) surface->extents.width = surface->extents.height = 0; if (target->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) { /* Maintain subsurfaces as 1-depth */ cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) target; surface->extents.x += sub->extents.x; surface->extents.y += sub->extents.y; target = sub->target; } surface->target = cairo_surface_reference (target); surface->base.type = surface->target->type; surface->snapshot = NULL; cairo_surface_set_device_scale (&surface->base, target->device_transform.xx, target->device_transform.yy); return &surface->base; }
cairo_surface_t * cairo_xynth_surface_create (unsigned int width, unsigned int height, cairo_format_t cairo_format) { S_RENDER_FORMAT render_format; cairo_xynth_surface_t *surface; ENTER(); if (!CAIRO_FORMAT_VALID(cairo_format)) { _cairo_error(CAIRO_STATUS_INVALID_FORMAT); return NULL; } render_format = _cairo_xynth_format_from_cairo_format(cairo_format); if (render_format == S_RENDER_FORMAT_NONE) { _cairo_error(CAIRO_STATUS_INVALID_FORMAT); return NULL; } surface = (cairo_xynth_surface_t *) malloc(sizeof(cairo_xynth_surface_t)); if (surface == NULL) { _cairo_error(CAIRO_STATUS_NO_MEMORY); return NULL; } memset(surface, 0, sizeof(cairo_xynth_surface_t)); if (s_render_init(&surface->render, render_format, width, height)) { free(surface); _cairo_error(CAIRO_STATUS_NO_MEMORY); return NULL; } _cairo_surface_init(&surface->cairo, &cairo_xynth_surface_backend, _cairo_content_from_format(cairo_format)); LEAVE(); return &surface->cairo; }
cairo_surface_t * _cairo_gl_pattern_to_source (cairo_surface_t *dst, const cairo_pattern_t *pattern, cairo_bool_t is_mask, const cairo_rectangle_int_t *extents, const cairo_rectangle_int_t *sample, int *src_x, int *src_y) { cairo_gl_source_t *source; cairo_int_status_t status; TRACE ((stderr, "%s\n", __FUNCTION__)); if (pattern == NULL) return _cairo_gl_white_source (); source = malloc (sizeof (*source)); if (unlikely (source == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&source->base, &cairo_gl_source_backend, NULL, /* device */ CAIRO_CONTENT_COLOR_ALPHA); *src_x = *src_y = 0; status = _cairo_gl_operand_init (&source->operand, pattern, (cairo_gl_surface_t *)dst, sample, extents, FALSE); if (unlikely (status)) { cairo_surface_destroy (&source->base); return _cairo_surface_create_in_error (status); } return &source->base; }
cairo_surface_t * cairo_tee_surface_create (cairo_surface_t *master) { cairo_tee_surface_t *surface; if (unlikely (master->status)) return _cairo_surface_create_in_error (master->status); surface = malloc (sizeof (cairo_tee_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &cairo_tee_surface_backend, master->content); _cairo_surface_wrapper_init (&surface->master, master); /* we trust that these are already set and remain constant */ surface->base.device_transform = master->device_transform; surface->base.device_transform_inverse = master->device_transform_inverse; _cairo_array_init (&surface->slaves, sizeof (cairo_surface_wrapper_t)); return &surface->base; }
cairo_surface_t * _cairo_test_fallback_surface_create (cairo_content_t content, int width, int height) { test_fallback_surface_t *surface; cairo_surface_t *backing; backing = _cairo_image_surface_create_with_content (content, width, height); if (cairo_surface_status (backing)) return (cairo_surface_t*) &_cairo_surface_nil; surface = malloc (sizeof (test_fallback_surface_t)); if (surface == NULL) { cairo_surface_destroy (backing); _cairo_error (CAIRO_STATUS_NO_MEMORY); return (cairo_surface_t*) &_cairo_surface_nil; } _cairo_surface_init (&surface->base, &test_fallback_surface_backend, content); surface->backing = backing; return &surface->base; }
cairo_surface_t * _cairo_type3_glyph_surface_create (cairo_scaled_font_t *scaled_font, cairo_output_stream_t *stream, cairo_type3_glyph_surface_emit_image_t emit_image, cairo_scaled_font_subsets_t *font_subsets) { cairo_type3_glyph_surface_t *surface; cairo_matrix_t invert_y_axis; surface = malloc (sizeof (cairo_type3_glyph_surface_t)); if (surface == NULL) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &cairo_type3_glyph_surface_backend, CAIRO_CONTENT_COLOR_ALPHA); surface->scaled_font = scaled_font; surface->stream = stream; surface->emit_image = emit_image; /* Setup the transform from the user-font device space to Type 3 * font space. The Type 3 font space is defined by the FontMatrix * entry in the Type 3 dictionary. In the PDF backend this is an * identity matrix. */ surface->cairo_to_pdf = scaled_font->scale_inverse; cairo_matrix_init_scale (&invert_y_axis, 1, -1); cairo_matrix_multiply (&surface->cairo_to_pdf, &surface->cairo_to_pdf, &invert_y_axis); _cairo_pdf_operators_init (&surface->pdf_operators, surface->stream, &surface->cairo_to_pdf, font_subsets); return &surface->base; }
cairo_surface_t *cairo_quartz_surface_create(CGContextRef context, int width, int height, cairo_bool_t y_grows_down) { cairo_quartz_surface_t *surface; CGRect clip_box; surface = malloc(sizeof(cairo_quartz_surface_t)); if (surface == NULL) { _cairo_error (CAIRO_STATUS_NO_MEMORY); return (cairo_surface_t*) &_cairo_surface_nil; } /* XXX: The content value here might be totally wrong. */ _cairo_surface_init(&surface->base, &cairo_quartz_surface_backend, CAIRO_CONTENT_COLOR_ALPHA); surface->context = context; surface->clip_region = NULL; surface->y_grows_down = y_grows_down; clip_box = CGContextGetClipBoundingBox (context); surface->extents.x = clip_box.origin.x; surface->extents.y = clip_box.origin.y; surface->extents.width = clip_box.size.width; surface->extents.height = clip_box.size.height; return (cairo_surface_t *) surface; }
cairo_surface_t * _cairo_surface_create_for_rectangle_int (cairo_surface_t *target, const cairo_rectangle_int_t *extents) { cairo_surface_subsurface_t *surface; if (unlikely (target->status)) return _cairo_surface_create_in_error (target->status); if (unlikely (target->finished)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); assert (target->backend->type != CAIRO_SURFACE_TYPE_SUBSURFACE); surface = malloc (sizeof (cairo_surface_subsurface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); assert (_cairo_matrix_is_translation (&target->device_transform)); _cairo_surface_init (&surface->base, &_cairo_surface_subsurface_backend, NULL, /* device */ target->content); surface->extents = *extents; surface->extents.x += target->device_transform.x0; surface->extents.y += target->device_transform.y0; surface->target = cairo_surface_reference (target); surface->base.type = surface->target->type; surface->snapshot = NULL; return &surface->base; }
/* Currently all meta surfaces do have a size which should be passed * in as the maximum size of any target surface against which the * meta-surface will ever be replayed. * * XXX: The naming of "pixels" in the size here is a misnomer. It's * actually a size in whatever device-space units are desired (again, * according to the intended replay target). This should likely also * be changed to use doubles not ints. */ cairo_surface_t * _cairo_meta_surface_create (cairo_content_t content, int width_pixels, int height_pixels) { cairo_meta_surface_t *meta; meta = malloc (sizeof (cairo_meta_surface_t)); if (meta == NULL) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&meta->base, &cairo_meta_surface_backend, content); meta->content = content; meta->width_pixels = width_pixels; meta->height_pixels = height_pixels; _cairo_array_init (&meta->commands, sizeof (cairo_command_t *)); meta->commands_owner = NULL; meta->is_clipped = FALSE; meta->replay_start_idx = 0; return &meta->base; }
static cairo_surface_t * gallium_surface_create_internal (gallium_device_t *device, enum pipe_format pipe_format, int width, int height) { gallium_surface_t *surface; struct pipe_resource template; cairo_status_t status; cairo_format_t format; int stride, size; surface = malloc (sizeof (gallium_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); format = _cairo_format_from_pipe_format (pipe_format); _cairo_surface_init (&surface->drm.base, &gallium_surface_backend, &device->drm.base, _cairo_content_from_format (format)); _cairo_drm_surface_init (&surface->drm, format, width, height); stride = gallium_format_stride_for_width (pipe_format, width); size = stride * height; surface->drm.stride = stride; surface->drm.bo = _gallium_fake_bo_create (size, 0); memset(&template, 0, sizeof(template));
static cairo_xcb_pixmap_t * _cairo_xcb_pixmap_create (cairo_xcb_surface_t *target, int width, int height) { cairo_xcb_pixmap_t *surface; surface = malloc (sizeof (cairo_xcb_pixmap_t)); if (unlikely (surface == NULL)) return (cairo_xcb_pixmap_t *) _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &_cairo_xcb_pixmap_backend, NULL, target->base.content); surface->connection = target->connection; surface->screen = target->screen; surface->owner = NULL; surface->width = width; surface->height = height; surface->depth = target->depth; surface->x0 = surface->y0 = 0; surface->repeat = FALSE; surface->pixmap = _cairo_xcb_connection_create_pixmap (surface->connection, surface->depth, target->drawable, width, height); return surface; }
cairo_surface_t * _cairo_test_fallback16_surface_create (cairo_content_t content, int width, int height) { test_fallback16_surface_t *surface; cairo_surface_t *backing; pixman_format_code_t format; format = content & CAIRO_CONTENT_ALPHA ? PIXMAN_a1r5g5b5: PIXMAN_r5g6b5; backing = _cairo_image_surface_create_with_pixman_format (NULL, format, width, height, -1); if (cairo_surface_status (backing)) return backing; surface = malloc (sizeof (test_fallback16_surface_t)); if (unlikely (surface == NULL)) { cairo_surface_destroy (backing); return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } _cairo_surface_init (&surface->base, &test_fallback16_surface_backend, content); surface->backing = backing; return &surface->base; }
cairo_surface_t * _cairo_image_surface_create_for_pixman_image (pixman_image_t *pixman_image, cairo_format_t format) { cairo_image_surface_t *surface; surface = malloc (sizeof (cairo_image_surface_t)); if (surface == NULL) { _cairo_error (CAIRO_STATUS_NO_MEMORY); return (cairo_surface_t*) &_cairo_surface_nil; } _cairo_surface_init (&surface->base, &cairo_image_surface_backend); surface->pixman_image = pixman_image; surface->format = format; surface->data = (unsigned char *) pixman_image_get_data (pixman_image); surface->owns_data = FALSE; surface->has_clip = FALSE; surface->width = pixman_image_get_width (pixman_image); surface->height = pixman_image_get_height (pixman_image); surface->stride = pixman_image_get_stride (pixman_image); surface->depth = pixman_image_get_depth (pixman_image); return &surface->base; }
cairo_surface_t * _cairo_image_surface_create_for_pixman_image (pixman_image_t *pixman_image, pixman_format_code_t pixman_format) { cairo_image_surface_t *surface; surface = malloc (sizeof (cairo_image_surface_t)); if (surface == NULL) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &_cairo_image_surface_backend, _cairo_content_from_pixman_format (pixman_format)); surface->pixman_image = pixman_image; surface->pixman_format = pixman_format; surface->format = _cairo_format_from_pixman_format (pixman_format); surface->data = (unsigned char *) pixman_image_get_data (pixman_image); surface->owns_data = FALSE; surface->has_clip = FALSE; surface->transparency = CAIRO_IMAGE_UNKNOWN; surface->width = pixman_image_get_width (pixman_image); surface->height = pixman_image_get_height (pixman_image); surface->stride = pixman_image_get_stride (pixman_image); surface->depth = pixman_image_get_depth (pixman_image); return &surface->base; }
cairo_surface_t * _cairo_xcb_surface_create_internal (cairo_xcb_screen_t *screen, xcb_drawable_t drawable, cairo_bool_t owns_pixmap, pixman_format_code_t pixman_format, xcb_render_pictformat_t xrender_format, int width, int height) { cairo_xcb_surface_t *surface; surface = malloc (sizeof (cairo_xcb_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &_cairo_xcb_surface_backend, &screen->connection->device, _cairo_content_from_pixman_format (pixman_format)); surface->connection = _cairo_xcb_connection_reference (screen->connection); surface->screen = screen; cairo_list_add (&surface->link, &screen->surfaces); surface->fallback = NULL; surface->drawable = drawable; surface->owns_pixmap = owns_pixmap; surface->use_pixmap = 0; surface->deferred_clear = FALSE; surface->width = width; surface->height = height; surface->depth = PIXMAN_FORMAT_DEPTH (pixman_format); surface->picture = XCB_NONE; surface->pixman_format = pixman_format; surface->xrender_format = xrender_format; surface->flags = screen->connection->flags; surface->marked_dirty = FALSE; surface->drm = NULL; if (screen->device != NULL) { surface->drm = _xcb_drm_create_surface_for_drawable (surface->connection, surface->screen, drawable, pixman_format, width, height); } return &surface->base; }
/** * _cairo_surface_snapshot: * @surface: a #cairo_surface_t * * Make an immutable reference to @surface. It is an error to call a * surface-modifying function on the result of this function. The * resulting 'snapshot' is a lazily copied-on-write surface i.e. it * remains a reference to the original surface until that surface is * written to again, at which time a copy is made of the original surface * and the snapshot then points to that instead. Multiple snapshots of the * same unmodified surface point to the same copy. * * The caller owns the return value and should call * cairo_surface_destroy() when finished with it. This function will not * return %NULL, but will return a nil surface instead. * * Return value: The snapshot surface. Note that the return surface * may not necessarily be of the same type as @surface. **/ cairo_surface_t * _cairo_surface_snapshot (cairo_surface_t *surface) { cairo_surface_snapshot_t *snapshot; cairo_status_t status; TRACE ((stderr, "%s: target=%d\n", __FUNCTION__, surface->unique_id)); if (unlikely (surface->status)) return _cairo_surface_create_in_error (surface->status); if (unlikely (surface->finished)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); if (surface->snapshot_of != NULL) return cairo_surface_reference (surface); if (_cairo_surface_is_snapshot (surface)) return cairo_surface_reference (surface); snapshot = (cairo_surface_snapshot_t *) _cairo_surface_has_snapshot (surface, &_cairo_surface_snapshot_backend); if (snapshot != NULL) return cairo_surface_reference (&snapshot->base); snapshot = malloc (sizeof (cairo_surface_snapshot_t)); if (unlikely (snapshot == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); _cairo_surface_init (&snapshot->base, &_cairo_surface_snapshot_backend, NULL, /* device */ surface->content); snapshot->base.type = surface->type; CAIRO_MUTEX_INIT (snapshot->mutex); snapshot->target = surface; snapshot->clone = NULL; status = _cairo_surface_copy_mime_data (&snapshot->base, surface); if (unlikely (status)) { cairo_surface_destroy (&snapshot->base); return _cairo_surface_create_in_error (status); } snapshot->base.device_transform = surface->device_transform; snapshot->base.device_transform_inverse = surface->device_transform_inverse; _cairo_surface_attach_snapshot (surface, &snapshot->base, _cairo_surface_snapshot_copy_on_write); return &snapshot->base; }
static void radeon_surface_init (radeon_surface_t *surface, cairo_drm_device_t *device, cairo_format_t format, int width, int height) { _cairo_surface_init (&surface->base.base, &radeon_surface_backend, &device->base, _cairo_content_from_format (format)); _cairo_drm_surface_init (&surface->base, format, width, height); }
cairo_surface_t * _cairo_analysis_surface_create (cairo_surface_t *target, int width, int height) { cairo_analysis_surface_t *surface; cairo_status_t status; status = target->status; if (unlikely (status)) return _cairo_surface_create_in_error (status); surface = malloc (sizeof (cairo_analysis_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); /* I believe the content type here is truly arbitrary. I'm quite * sure nothing will ever use this value. */ _cairo_surface_init (&surface->base, &cairo_analysis_surface_backend, CAIRO_CONTENT_COLOR_ALPHA); surface->width = width; surface->height = height; cairo_matrix_init_identity (&surface->ctm); surface->has_ctm = FALSE; surface->target = cairo_surface_reference (target); surface->first_op = TRUE; surface->has_supported = FALSE; surface->has_unsupported = FALSE; surface->page_bbox.p1.x = 0; surface->page_bbox.p1.y = 0; surface->page_bbox.p2.x = 0; surface->page_bbox.p2.y = 0; _cairo_region_init (&surface->supported_region); _cairo_region_init (&surface->fallback_region); if (width == -1 && height == -1) { surface->current_clip.x = CAIRO_RECT_INT_MIN; surface->current_clip.y = CAIRO_RECT_INT_MIN; surface->current_clip.width = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN; surface->current_clip.height = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN; } else { surface->current_clip.x = 0; surface->current_clip.y = 0; surface->current_clip.width = width; surface->current_clip.height = height; } return &surface->base; }
cairo_surface_t * cairo_qt_surface_create_with_qpixmap (cairo_content_t content, int width, int height) { cairo_qt_surface_t *qs; if ((content & CAIRO_CONTENT_COLOR) == 0) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); qs = (cairo_qt_surface_t *) malloc (sizeof(cairo_qt_surface_t)); if (qs == NULL) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); memset (qs, 0, sizeof(cairo_qt_surface_t)); QPixmap *pixmap = new QPixmap (width, height); if (pixmap == NULL) { free (qs); return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } // By default, a QPixmap is opaque; however, if it's filled // with a color with a transparency component, it is converted // to a format that preserves transparency. if (content == CAIRO_CONTENT_COLOR_ALPHA) pixmap->fill(Qt::transparent); _cairo_surface_init (&qs->base, &cairo_qt_surface_backend, NULL, /* device */ content); _cairo_surface_clipper_init (&qs->clipper, _cairo_qt_surface_clipper_intersect_clip_path); qs->pixmap = pixmap; if (!pixmap->isNull()) { qs->p = new QPainter(pixmap); qs->supports_porter_duff = qs->p->paintEngine()->hasFeature(QPaintEngine::PorterDuff); } qs->window = QRect(0, 0, width, height); D(fprintf(stderr, "qpainter_surface_create: qpixmap: [%d %d %d %d] pd:%d\n", qs->window.x(), qs->window.y(), qs->window.width(), qs->window.height(), qs->supports_porter_duff)); return &qs->base; }
cairo_surface_t * _cairo_null_surface_create (cairo_content_t content) { cairo_surface_t *surface; surface = malloc (sizeof (cairo_surface_t)); if (unlikely (surface == NULL)) { return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } _cairo_surface_init (surface, &cairo_null_surface_backend, content); return surface; }
cairo_surface_t * cairo_gral_surface_create (gral_surface_t *gral_surf) { cairo_gral_surface_t *s; s = (cairo_gral_surface_t *) malloc(sizeof(cairo_gral_surface_t)); memset(s, 0, sizeof(cairo_gral_surface_t)); _cairo_surface_init(&s->base, &_cairo_gral_surface_backend, CAIRO_CONTENT_COLOR_ALPHA); s->gral_surf = gral_surf; s->gpu = _cairo_gral_gpu_resources_acquire (); return (cairo_surface_t *) s; }
cairo_surface_t * _cairo_xcb_surface_create_internal (cairo_xcb_screen_t *screen, xcb_drawable_t drawable, cairo_bool_t owns_pixmap, pixman_format_code_t pixman_format, xcb_render_pictformat_t xrender_format, int width, int height) { cairo_xcb_surface_t *surface; surface = malloc (sizeof (cairo_xcb_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &_cairo_xcb_surface_backend, &screen->connection->device, _cairo_content_from_pixman_format (pixman_format), FALSE); /* is_vector */ surface->connection = _cairo_xcb_connection_reference (screen->connection); surface->screen = screen; cairo_list_add (&surface->link, &screen->surfaces); surface->drawable = drawable; surface->owns_pixmap = owns_pixmap; surface->deferred_clear = FALSE; surface->deferred_clear_color = *CAIRO_COLOR_TRANSPARENT; surface->width = width; surface->height = height; surface->depth = PIXMAN_FORMAT_DEPTH (pixman_format); surface->picture = XCB_NONE; if (screen->connection->force_precision != -1) surface->precision = screen->connection->force_precision; else surface->precision = XCB_RENDER_POLY_MODE_IMPRECISE; surface->pixman_format = pixman_format; surface->xrender_format = xrender_format; surface->fallback = NULL; _cairo_boxes_init (&surface->fallback_damage); return &surface->base; }
void intel_surface_init (intel_surface_t *surface, const cairo_surface_backend_t *backend, cairo_drm_device_t *device, cairo_format_t format, int width, int height) { _cairo_surface_init (&surface->drm.base, backend, &device->base, _cairo_content_from_format (format)); _cairo_drm_surface_init (&surface->drm, format, width, height); surface->snapshot_cache_entry.hash = 0; }
/** * cairo_recording_surface_create: * @content: the content of the recording surface * @extents: the extents to record in pixels, can be %NULL to record * unbounded operations. * * Creates a recording-surface which can be used to record all drawing operations * at the highest level (that is, the level of paint, mask, stroke, fill * and show_text_glyphs). The recording surface can then be "replayed" against * any target surface by using it as a source to drawing operations. * * The recording phase of the recording surface is careful to snapshot all * necessary objects (paths, patterns, etc.), in order to achieve * accurate replay. * * Return value: a pointer to the newly created surface. The caller * owns the surface and should call cairo_surface_destroy() when done * with it. * * Since: 1.10 **/ cairo_surface_t * cairo_recording_surface_create (cairo_content_t content, const cairo_rectangle_t *extents) { cairo_recording_surface_t *recording_surface; cairo_status_t status; recording_surface = malloc (sizeof (cairo_recording_surface_t)); if (unlikely (recording_surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&recording_surface->base, &cairo_recording_surface_backend, NULL, /* device */ content); recording_surface->content = content; recording_surface->unbounded = TRUE; _cairo_clip_init (&recording_surface->clip); /* unbounded -> 'infinite' extents */ if (extents != NULL) { recording_surface->extents_pixels = *extents; /* XXX check for overflow */ recording_surface->extents.x = floor (extents->x); recording_surface->extents.y = floor (extents->y); recording_surface->extents.width = ceil (extents->x + extents->width) - recording_surface->extents.x; recording_surface->extents.height = ceil (extents->y + extents->height) - recording_surface->extents.y; status = _cairo_clip_rectangle (&recording_surface->clip, &recording_surface->extents); if (unlikely (status)) { free (recording_surface); return _cairo_surface_create_in_error (status); } recording_surface->unbounded = FALSE; } _cairo_array_init (&recording_surface->commands, sizeof (cairo_command_t *)); recording_surface->replay_start_idx = 0; recording_surface->base.is_clear = TRUE; return &recording_surface->base; }
/* XXX The integer width,height here should be doubles and all uses updated */ cairo_surface_t * _cairo_paginated_surface_create (cairo_surface_t *target, cairo_content_t content, int width, int height, const cairo_paginated_surface_backend_t *backend) { cairo_paginated_surface_t *surface; cairo_status_t status; surface = malloc (sizeof (cairo_paginated_surface_t)); if (surface == NULL) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto FAIL; } _cairo_surface_init (&surface->base, &cairo_paginated_surface_backend, content); /* Override surface->base.type with target's type so we don't leak * evidence of the paginated wrapper out to the user. */ surface->base.type = cairo_surface_get_type (target); surface->target = cairo_surface_reference (target); surface->content = content; surface->width = width; surface->height = height; surface->backend = backend; surface->meta = _cairo_meta_surface_create (content, width, height); status = cairo_surface_status (surface->meta); if (status) goto FAIL_CLEANUP_SURFACE; surface->page_num = 1; surface->page_is_blank = TRUE; return &surface->base; FAIL_CLEANUP_SURFACE: free (surface); FAIL: return _cairo_surface_create_in_error (status); }
static cairo_surface_t * attach_proxy (cairo_surface_t *source, cairo_surface_t *target) { struct proxy *proxy; proxy = malloc (sizeof (*proxy)); if (unlikely (proxy == NULL)) return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY); _cairo_surface_init (&proxy->base, &proxy_backend, NULL, target->content, target->is_vector); proxy->target = target; _cairo_surface_attach_snapshot (source, &proxy->base, NULL); return &proxy->base; }
static cairo_surface_t * test_compositor_surface_create (const cairo_compositor_t *compositor, cairo_content_t content, int width, int height) { test_compositor_surface_t *surface; pixman_image_t *pixman_image; pixman_format_code_t pixman_format; switch (content) { case CAIRO_CONTENT_ALPHA: pixman_format = PIXMAN_a8; break; case CAIRO_CONTENT_COLOR: pixman_format = PIXMAN_x8r8g8b8; break; case CAIRO_CONTENT_COLOR_ALPHA: pixman_format = PIXMAN_a8r8g8b8; break; default: return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); } pixman_image = pixman_image_create_bits (pixman_format, width, height, NULL, 0); if (unlikely (pixman_image == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); surface = malloc (sizeof (test_compositor_surface_t)); if (unlikely (surface == NULL)) { pixman_image_unref (pixman_image); return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } _cairo_surface_init (&surface->base.base, &test_compositor_surface_backend, NULL, /* device */ content, FALSE); /* is_vector */ _cairo_image_surface_init (&surface->base, pixman_image, pixman_format); surface->base.compositor = compositor; return &surface->base.base; }
cairo_surface_t * cairo_qt_surface_create_with_qimage (cairo_format_t format, int width, int height) { cairo_qt_surface_t *qs; qs = (cairo_qt_surface_t *) malloc (sizeof(cairo_qt_surface_t)); if (qs == NULL) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); memset (qs, 0, sizeof(cairo_qt_surface_t)); _cairo_surface_init (&qs->base, &cairo_qt_surface_backend, NULL, /* device */ _cairo_content_from_format (format)); _cairo_surface_clipper_init (&qs->clipper, _cairo_qt_surface_clipper_intersect_clip_path); QImage *image = new QImage (width, height, _qimage_format_from_cairo_format (format)); qs->image = image; if (!image->isNull()) { qs->p = new QPainter(image); qs->supports_porter_duff = qs->p->paintEngine()->hasFeature(QPaintEngine::PorterDuff); } qs->image_equiv = cairo_image_surface_create_for_data (image->bits(), format, width, height, image->bytesPerLine()); qs->window = QRect(0, 0, width, height); D(fprintf(stderr, "qpainter_surface_create: qimage: [%d %d %d %d] pd:%d\n", qs->window.x(), qs->window.y(), qs->window.width(), qs->window.height(), qs->supports_porter_duff)); return &qs->base; }
static cairo_skia_surface_t * _cairo_skia_surface_create_internal (SkBitmap::Config config, bool opaque, unsigned char *data, int width, int height, int stride) { cairo_skia_surface_t *surface; cairo_format_t format; surface = (cairo_skia_surface_t *) malloc (sizeof (cairo_skia_surface_t)); if (surface == NULL) return (cairo_skia_surface_t *) _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); memset (surface, 0, sizeof (cairo_skia_surface_t)); format = sk_config_to_format (config, opaque); assert (format != -1); _cairo_surface_init (&surface->base, &cairo_skia_surface_backend, NULL, /* device */ _cairo_content_from_format (format)); _cairo_surface_clipper_init (&surface->clipper, _cairo_skia_surface_clipper_intersect_clip_path); surface->bitmap = new SkBitmap; if (data == NULL) stride = cairo_format_stride_for_width (format, width); surface->bitmap->setConfig (config, width, height, stride); surface->bitmap->setIsOpaque (opaque); if (data != NULL) surface->bitmap->setPixels (data); else surface->bitmap->allocPixels (); surface->canvas = new SkCanvas (*surface->bitmap); //surface->canvas->translate (SkIntToScalar (0), SkIntToScalar (height)); //surface->canvas->scale (SkIntToScalar (1), SkIntToScalar (-1)); surface->canvas->save (); return surface; }
cairo_surface_t * _cairo_null_surface_create (cairo_content_t content) { cairo_surface_t *surface; surface = malloc (sizeof (cairo_surface_t)); if (unlikely (surface == NULL)) { return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } _cairo_surface_init (surface, &cairo_null_surface_backend, NULL, /* device */ content, TRUE); /* is_vector */ return surface; }