static void export_svg () { cairo_surface_t *surface; cairo_rectangle_t extents; cairo_matrix_t mtx; cairo_t *cr; /* Create a surface and run export_layout_page() to figure out * the picture extents and set up the cairo transformation * matrix. The surface is created only in order to force * eda_renderer_default_get_user_bounds() to behave quietly. */ surface = cairo_svg_surface_create (settings.outfile, 0, 0); cr = cairo_create (surface); g_object_set (renderer, "cairo-context", cr, NULL); export_layout_page (NULL, &extents, &mtx); cairo_destroy (cr); /* Now create a new surface with the known extents. */ surface = cairo_svg_surface_create (settings.outfile, extents.width, extents.height); cr = cairo_create (surface); g_object_set (renderer, "cairo-context", cr, NULL); cairo_set_matrix (cr, &mtx); export_draw_page (NULL); cairo_show_page (cr); cairo_surface_finish (surface); export_cairo_check_error (cairo_surface_status (surface)); }
static cairo_status_t _cairo_paginated_surface_finish (void *abstract_surface) { cairo_paginated_surface_t *surface = abstract_surface; cairo_status_t status = CAIRO_STATUS_SUCCESS; if (! surface->base.is_clear || surface->page_num == 1) { /* Bypass some of the sanity checking in cairo-surface.c, as we * know that the surface is finished... */ status = (cairo_status_t)_cairo_paginated_surface_show_page (surface); } /* XXX We want to propagate any errors from destroy(), but those are not * returned via the api. So we need to explicitly finish the target, * and check the status afterwards. However, we can only call finish() * on the target, if we own it. */ if (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->target->ref_count) == 1) cairo_surface_finish (surface->target); if (status == CAIRO_STATUS_SUCCESS) status = cairo_surface_status (surface->target); cairo_surface_destroy (surface->target); cairo_surface_finish (surface->recording_surface); if (status == CAIRO_STATUS_SUCCESS) status = cairo_surface_status (surface->recording_surface); cairo_surface_destroy (surface->recording_surface); return status; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { const cairo_test_context_t *ctx = cairo_test_get_context (cr); cairo_surface_t *surface; cairo_status_t status; surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1); cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status != CAIRO_STATUS_SUCCESS) return cairo_test_status_from_status (ctx, status); cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status != CAIRO_STATUS_SUCCESS) return cairo_test_status_from_status (ctx, status); cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status != CAIRO_STATUS_SUCCESS) return cairo_test_status_from_status (ctx, status); cairo_surface_destroy (surface); return CAIRO_TEST_SUCCESS; }
static cairo_status_t _cairo_paginated_surface_finish (void *abstract_surface) { cairo_paginated_surface_t *surface = abstract_surface; cairo_status_t status = CAIRO_STATUS_SUCCESS; if (surface->page_is_blank == FALSE || surface->page_num == 1) { cairo_surface_show_page (abstract_surface); status = cairo_surface_status (abstract_surface); } if (status == CAIRO_STATUS_SUCCESS) { cairo_surface_finish (surface->target); status = cairo_surface_status (surface->target); } if (status == CAIRO_STATUS_SUCCESS) { cairo_surface_finish (surface->meta); status = cairo_surface_status (surface->meta); } cairo_surface_destroy (surface->target); cairo_surface_destroy (surface->meta); return status; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_surface_t *surface; uint32_t colors[4] = { 0xffffffff, 0xffff0000, 0xff00ff00, 0xff0000ff }; int i; for (i=0; i < 4; i++) { surface = cairo_image_surface_create_for_data ((unsigned char *) &colors[i], CAIRO_FORMAT_RGB24, 1, 1, 4); cairo_save (cr); { cairo_translate (cr, i % 2, i / 2); cairo_set_source_surface (cr, surface, 0, 0); cairo_paint (cr); } cairo_restore (cr); cairo_surface_finish (surface); /* colors will go out of scope */ cairo_surface_destroy (surface); } return CAIRO_TEST_SUCCESS; }
static cairo_int_status_t _cairo_qt_surface_unmap_image (void *abstract_surface, cairo_image_surface_t *image) { cairo_qt_surface_t *qs = (cairo_qt_surface_t *) abstract_surface; D(fprintf(stderr, "q[%p] release_dest_image\n", abstract_surface)); if (!qs->image_equiv) { struct _qimage_surface *qimage = (struct _qimage_surface *)image; // XXX should I be using setBackgroundMode here instead of setCompositionMode? if (qs->supports_porter_duff) qs->p->setCompositionMode (QPainter::CompositionMode_Source); qs->p->drawImage ((int)qimage->image.base.device_transform.x0, (int)qimage->image.base.device_transform.y0, *qimage->qimg, (int)qimage->image.base.device_transform.x0, (int)qimage->image.base.device_transform.y0, (int)qimage->image.width, (int)qimage->image.height); if (qs->supports_porter_duff) qs->p->setCompositionMode (QPainter::CompositionMode_SourceOver); delete qimage->qimg; } cairo_surface_finish (&image->base); cairo_surface_destroy (&image->base); return CAIRO_INT_STATUS_SUCCESS; }
// Draw a single frame, do all your drawing/animation from in here. void drawFrame(buffer *buffer, long frame) { cairo_t *cr; /* We are just going to attach cairo directly to the buffer in the rsx memory. * If this gets too slow later with blending, we will need to create a buffer * on cell then copy the finished result accross. */ //cairo_surface_t *surface = cairo_image_surface_create_for_data((u8 *) buffer->ptr, // CAIRO_FORMAT_RGB24, buffer->width, buffer->height, buffer->width * 4); cairo_surface_t *surface = cairo_image_surface_create_for_data((u8 *) buffer, CAIRO_FORMAT_RGB16_565, offWidth, offHeight, offWidth * 2); assert(surface != NULL); cr = cairo_create(surface); assert(cr != NULL); // Lets start by clearing everything cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); // White cairo_paint(cr); cairo_set_line_width(cr, 10.0); // 30 pixel wide line cairo_set_source_rgb (cr, 1.0, 0.5, 0.0); // Orange float angle = (frame % 600) / 100.0; // Rotation animaton, rotate once every 10 seconds. cairo_arc(cr, offWidth/2, offHeight/2, offHeight/3, angle*M_PI, (angle-0.3)*M_PI); cairo_stroke(cr); // Stroke the arc with our 30px wide orange line cairo_destroy(cr); // Realease Surface cairo_surface_finish(surface); cairo_surface_destroy(surface); // Flush and destroy the cairo surface }
static void portal_end_run (GtkPrintOperation *op, gboolean wait, gboolean cancelled) { GtkPrintOperationPortal *op_portal = op->priv->platform_data; cairo_surface_finish (op_portal->surface); if (cancelled) return; if (wait) op_portal->loop = g_main_loop_new (NULL, FALSE); /* TODO: Check for error */ if (op_portal->job != NULL) { g_object_ref (op); gtk_print_job_send (op_portal->job, portal_job_complete, op, NULL); } if (wait) { g_object_ref (op); if (!op_portal->file_written) { gdk_threads_leave (); g_main_loop_run (op_portal->loop); gdk_threads_enter (); } g_object_unref (op); } }
static inline void clutter_cairo_texture_surface_resize_internal (ClutterCairoTexture *cairo) { ClutterCairoTexturePrivate *priv = cairo->priv; if (priv->cr_surface != NULL) { cairo_surface_t *surface = priv->cr_surface; /* if the surface is an image one, and the size is already the * same, then we don't need to do anything */ if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_IMAGE) { gint surface_width = cairo_image_surface_get_width (surface); gint surface_height = cairo_image_surface_get_height (surface); if (priv->width == surface_width && priv->height == surface_height) return; } cairo_surface_finish (surface); cairo_surface_destroy (surface); priv->cr_surface = NULL; } if (priv->width == 0 || priv->height == 0) return; g_signal_emit (cairo, cairo_signals[CREATE_SURFACE], 0, priv->width, priv->height, &priv->cr_surface); }
static cairo_status_t gallium_surface_flush (void *abstract_surface) { gallium_surface_t *surface = abstract_surface; gallium_device_t *device = gallium_device (surface); cairo_status_t status; if (surface->fallback == NULL) { device->pipe->flush (device->pipe, PIPE_FLUSH_RENDER_CACHE, NULL); return CAIRO_STATUS_SUCCESS; } /* kill any outstanding maps */ cairo_surface_finish (surface->fallback); status = cairo_device_acquire (&device->drm.base); if (likely (status == CAIRO_STATUS_SUCCESS)) { device->pipe->transfer_unmap (device->pipe, surface->map_transfer); device->pipe->transfer_destroy (device->pipe, surface->map_transfer); surface->map_transfer = NULL; cairo_device_release (&device->drm.base); } status = cairo_surface_status (surface->fallback); cairo_surface_destroy (surface->fallback); surface->fallback = NULL; return status; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { const cairo_test_context_t *ctx = cairo_test_get_context (cr); cairo_format_t format = CAIRO_FORMAT_ARGB32; cairo_t *cr_src; cairo_surface_t *png, *src; uint8_t *data; int stride; png = cairo_test_create_surface_from_png (ctx, png_filename); stride = cairo_format_stride_for_width (format, width) + 12; data = xcalloc (stride, height); src = cairo_image_surface_create_for_data (data, format, width, height, stride); cr_src = cairo_create (src); cairo_set_source_surface (cr_src, png, 0, 0); cairo_paint (cr_src); cairo_destroy (cr_src); cairo_set_source_surface (cr, src, 0, 0); cairo_paint (cr); cairo_surface_destroy (png); cairo_surface_finish (src); cairo_surface_destroy (src); free (data); return CAIRO_TEST_SUCCESS; }
static void _cairo_boilerplate_xcb_cleanup (void *closure) { xcb_target_closure_t *xtc = closure; cairo_status_t status; cairo_surface_finish (xtc->surface); if (xtc->is_pixmap) xcb_free_pixmap (xtc->c, xtc->drawable); else xcb_destroy_window (xtc->c, xtc->drawable); cairo_surface_destroy (xtc->surface); cairo_device_finish (xtc->device); cairo_device_destroy (xtc->device); /* First synchronize with the X server to make sure there are no more errors * in-flight which we would miss otherwise */ _cairo_boilerplate_xcb_sync_server (xtc); status = _cairo_boilerplate_xcb_handle_errors (xtc); assert (status == CAIRO_STATUS_SUCCESS); xcb_disconnect (xtc->c); free (xtc); }
static cairo_status_t _cairo_win32_display_surface_finish (void *abstract_surface) { cairo_win32_display_surface_t *surface = abstract_surface; if (surface->image && to_image_surface(surface->image)->parent) { assert (to_image_surface(surface->image)->parent == &surface->win32.base); /* Unhook ourselves first to avoid the double-unref from the image */ to_image_surface(surface->image)->parent = NULL; cairo_surface_finish (surface->image); cairo_surface_destroy (surface->image); } /* If we created the Bitmap and DC, destroy them */ if (surface->bitmap) { SelectObject (surface->win32.dc, surface->saved_dc_bitmap); DeleteObject (surface->bitmap); DeleteDC (surface->win32.dc); } _cairo_win32_display_surface_discard_fallback (surface); if (surface->initial_clip_rgn) DeleteObject (surface->initial_clip_rgn); return CAIRO_STATUS_SUCCESS; }
static void drawin_update_drawing(drawin_t *w) { /* If this drawin isn't visible, we don't need an up-to-date cairo surface * for it. (drawin_map() will later make sure we are called again) */ if(!w->visible) return; /* Clean up old stuff */ if(w->surface) { /* In case lua still got a reference to the surface, it still won't be * able to do anything with it because we finish it. */ cairo_surface_finish(w->surface); cairo_surface_destroy(w->surface); } if(w->pixmap) xcb_free_pixmap(globalconf.connection, w->pixmap); /* Create a pixmap */ xcb_screen_t *s = globalconf.screen; w->pixmap = xcb_generate_id(globalconf.connection); xcb_create_pixmap(globalconf.connection, globalconf.default_depth, w->pixmap, s->root, w->geometry.width, w->geometry.height); /* and create a surface for that pixmap */ w->surface = cairo_xcb_surface_create(globalconf.connection, w->pixmap, globalconf.visual, w->geometry.width, w->geometry.height); /* Make sure the pixmap doesn't contain garbage by filling it with black */ cairo_t *cr = cairo_create(w->surface); cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_paint(cr); cairo_destroy(cr); }
static void export_pdf (void) { cairo_surface_t *surface; cairo_rectangle_t extents; cairo_matrix_t mtx; cairo_t *cr; GList *iter; /* Create a surface. To begin with, we don't know the size. */ surface = cairo_pdf_surface_create (settings.outfile, 1, 1); cr = cairo_create (surface); g_object_set (renderer, "cairo-context", cr, NULL); for (iter = geda_list_get_glist (toplevel->pages); iter != NULL; iter = g_list_next (iter)) { PAGE *page = (PAGE *) iter->data; export_layout_page (page, &extents, &mtx); cairo_pdf_surface_set_size (surface, extents.width, extents.height); cairo_set_matrix (cr, &mtx); export_draw_page (page); cairo_show_page (cr); } cairo_surface_finish (surface); export_cairo_check_error (cairo_surface_status (surface)); }
static void drawin_wipe(drawin_t *w) { /* The drawin must already be unmapped, else it * couldn't be garbage collected -> no unmap needed */ p_delete(&w->cursor); if(w->surface) { /* Make sure that cairo knows that this surface can't be unused anymore. * This is needed since lua could still have a reference to it. */ cairo_surface_finish(w->surface); cairo_surface_destroy(w->surface); w->surface = NULL; } if(w->window) { /* Activate BMA */ client_ignore_enterleave_events(); /* Make sure we don't accidentally kill the systray window */ drawin_systray_kickout(w); xcb_destroy_window(globalconf.connection, w->window); /* Deactivate BMA */ client_restore_enterleave_events(); w->window = XCB_NONE; } if(w->pixmap) { xcb_free_pixmap(globalconf.connection, w->pixmap); w->pixmap = XCB_NONE; } }
int conv_pdf (RioData *data, const char *filename) { int status; /* Determine original image height & width */ uint32_t height, width; status = rio_data_get_metadata_uint32 (data, RIO_KEY_IMAGE_ROWS, &height) && rio_data_get_metadata_uint32 (data, RIO_KEY_IMAGE_COLS, &width); if (!status) { fprintf (stderr, "ERROR: Could not determine image dimensions.\n"); return 0; } /* Create output surface */ cairo_surface_t *pdf = cairo_pdf_surface_create (filename, width, height); if (cairo_surface_status (pdf) != CAIRO_STATUS_SUCCESS) { fprintf (stderr, "ERROR: Could not create PDF surface for %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (pdf))); return 0; } /* FIXME naively assumes that all will be fine from now on. */ svg_draw (data, pdf); cairo_surface_finish (pdf); return 1; }
static cairo_status_t _cairo_xcb_surface_finish (void *abstract_surface) { cairo_xcb_surface_t *surface = abstract_surface; cairo_status_t status; if (surface->fallback != NULL) { cairo_surface_finish (&surface->fallback->base); cairo_surface_destroy (&surface->fallback->base); } _cairo_boxes_fini (&surface->fallback_damage); cairo_list_del (&surface->link); status = _cairo_xcb_connection_acquire (surface->connection); if (status == CAIRO_STATUS_SUCCESS) { if (surface->picture != XCB_NONE) { _cairo_xcb_connection_render_free_picture (surface->connection, surface->picture); } if (surface->owns_pixmap) _cairo_xcb_connection_free_pixmap (surface->connection, surface->drawable); _cairo_xcb_connection_release (surface->connection); } _cairo_xcb_connection_destroy (surface->connection); return status; }
int mergeRasterBufferCairo(imageObj *img, rasterBufferObj *rb, double opacity, int srcX, int srcY, int dstX, int dstY, int width, int height) { cairo_surface_t *src; cairo_renderer *r; /* not implemented for src,dst,width and height */ if(rb->type != MS_BUFFER_BYTE_RGBA) { return MS_FAILURE; } r = CAIRO_RENDERER(img); src = cairo_image_surface_create_for_data(rb->data.rgba.pixels,CAIRO_FORMAT_ARGB32, rb->width,rb->height, rb->data.rgba.row_step); if(dstX||dstY||srcX||srcY||width!=img->width||height!=img->height) { cairo_set_source_surface (r->cr, src, dstX - srcX, dstY - srcY); cairo_rectangle (r->cr, dstX, dstY, width, height); cairo_fill (r->cr); } else { cairo_set_source_surface (r->cr,src,0,0); cairo_paint_with_alpha(r->cr,opacity); } cairo_surface_finish(src); cairo_surface_destroy(src); return MS_SUCCESS; }
static PyObject * surface_finish (PycairoSurface *o) { cairo_surface_finish (o->surface); Py_CLEAR(o->base); RETURN_NULL_IF_CAIRO_SURFACE_ERROR(o->surface); Py_RETURN_NONE; }
cairo_int_status_t _cairo_image_surface_unmap_image (void *abstract_surface, cairo_image_surface_t *image) { cairo_surface_finish (&image->base); cairo_surface_destroy (&image->base); return CAIRO_INT_STATUS_SUCCESS; }
int saveImageCairo(imageObj *img, FILE *fp, outputFormatObj *format) { cairo_renderer *r = CAIRO_RENDERER(img); if(!strcasecmp(img->format->driver,"cairo/pdf") || !strcasecmp(img->format->driver,"cairo/svg")) { cairo_surface_finish (r->surface); fwrite(r->outputStream->data,r->outputStream->size,1,fp); } else { // not supported } return MS_SUCCESS; }
CanvasCairo::~CanvasCairo() { if (_context) { cairo_destroy(_context); _context = nullptr; } if (_surface) { cairo_surface_finish(_surface); _surface = nullptr; } }
static PyObject * surface_finish (PycairoSurface *o) { cairo_surface_finish (o->surface); Py_CLEAR(o->base); if (Pycairo_Check_Status (cairo_surface_status(o->surface))) return NULL; Py_RETURN_NONE; }
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_status_t _cairo_skia_surface_finish (void *asurface) { cairo_skia_surface_t *surface = (cairo_skia_surface_t *) asurface; cairo_surface_finish (&surface->image.base); delete surface->bitmap; return CAIRO_STATUS_SUCCESS; }
int gt_graphics_cairo_save_to_file(const GtGraphics *gg, const char *filename, GtError *err) { const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg; cairo_surface_t *bgsurf = NULL; cairo_t *bgc = NULL; cairo_status_t rval; GtFile *outfile; gt_error_check(err); gt_assert(g && filename); /* do nothing if no surface was created */ if (g->from_context) return 0; switch (g->type) { case GT_GRAPHICS_PNG: /* blend rendered image with background color */ bgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, g->width, g->height); bgc = cairo_create(bgsurf); cairo_set_source_rgba(bgc, g->bg_color.red, g->bg_color.green, g->bg_color.blue, g->bg_color.alpha); cairo_paint(bgc); cairo_set_source_surface(bgc, g->surf, 0, 0); cairo_paint(bgc); rval = cairo_surface_write_to_png(bgsurf, filename); gt_assert(rval == CAIRO_STATUS_SUCCESS || rval == CAIRO_STATUS_WRITE_ERROR); if (rval == CAIRO_STATUS_WRITE_ERROR) { cairo_destroy(bgc); cairo_surface_destroy(bgsurf); gt_error_set(err, "an I/O error occurred while attempting " "to write image file \"%s\"", filename); return -1; } cairo_destroy(bgc); cairo_surface_destroy(bgsurf); break; default: cairo_show_page(g->cr); cairo_surface_flush(g->surf); cairo_surface_finish(g->surf); outfile = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, filename, "w+", err); if (outfile) { gt_file_xwrite(outfile, gt_str_get_mem(g->outbuf), gt_str_length(g->outbuf)); gt_file_delete(outfile); } else return -1; break; } return 0; }
static void drawable_unset_surface(drawable_t *d) { cairo_surface_finish(d->surface); cairo_surface_destroy(d->surface); if (d->pixmap) xcb_free_pixmap(globalconf.connection, d->pixmap); d->refreshed = false; d->surface = NULL; d->pixmap = XCB_NONE; }
unsigned char* saveImageBufferCairo(imageObj *img, int *size_ptr, outputFormatObj *format) { cairo_renderer *r = CAIRO_RENDERER(img); unsigned char *data; assert(!strcasecmp(img->format->driver,"cairo/pdf") || !strcasecmp(img->format->driver,"cairo/svg")); cairo_surface_finish (r->surface); data = msSmallMalloc(r->outputStream->size); memcpy(data,r->outputStream->data,r->outputStream->size); *size_ptr = (int)r->outputStream->size; return data; }
static void _cairo_boilerplate_ps_cleanup (void *closure) { ps_target_closure_t *ptc = closure; if (ptc->target) { cairo_surface_finish (ptc->target); cairo_surface_destroy (ptc->target); } free (ptc->filename); free (ptc); }