static Bool readSvgFileToImage(char *file, int *width, int *height, void **data) { cairo_surface_t *surface; FILE *fp; GError *error = NULL; RsvgHandle *svgHandle; RsvgDimensionData svgDimension; fp = fopen(file, "r"); if (!fp) return FALSE; fclose(fp); svgHandle = rsvg_handle_new_from_file(file, &error); if (!svgHandle) return FALSE; rsvg_handle_get_dimensions(svgHandle, &svgDimension); *width = svgDimension.width; *height = svgDimension.height; *data = malloc(svgDimension.width * svgDimension.height * 4); if (!*data) { rsvg_handle_free(svgHandle); return FALSE; } surface = cairo_image_surface_create_for_data(*data, CAIRO_FORMAT_ARGB32, svgDimension.width, svgDimension.height, svgDimension.width * 4); if (surface) { cairo_t *cr; cr = cairo_create(surface); cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_paint(cr); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); rsvg_handle_render_cairo(svgHandle, cr); cairo_destroy(cr); cairo_surface_destroy(surface); } rsvg_handle_free(svgHandle); return TRUE; }
void SvgWindow::setSvg (CompString &data, decor_point_t p[2]) { RsvgHandle *svg = NULL; GError *error = NULL; if (!gWindow) return; svg = rsvg_handle_new_from_data ((guint8 *) data.c_str (), data.length (), &error); if (source) { rsvg_handle_free (source->svg); source->svg = svg; } else { source = new SvgSource; if (source) source->svg = svg; } if (source && source->svg) { source->p1 = p[0]; source->p2 = p[1]; source->svg = svg; gWindow->glDrawSetEnabled (this, true); rsvg_handle_get_dimensions (svg, &source->dimension); updateSvgContext (); } else { if (svg) rsvg_handle_free (svg); if (source) { delete source; source = NULL; } if (context) { finiTexture (context->texture[0]); delete context; context = NULL; } gWindow->glDrawSetEnabled (this, false); } }
bool SvgScreen::readSvgToImage (const char *file, CompSize &size, void *&data) { cairo_surface_t *surface; std::ifstream svgFile; GError *error = NULL; RsvgHandle *svgHandle; RsvgDimensionData svgDimension; svgFile.open (file); if (!svgFile.is_open ()) return false; svgFile.close (); svgHandle = rsvg_handle_new_from_file (file, &error); if (!svgHandle) return false; rsvg_handle_get_dimensions (svgHandle, &svgDimension); size.setWidth (svgDimension.width); size.setHeight (svgDimension.height); data = malloc (svgDimension.width * svgDimension.height * 4); if (!data) { rsvg_handle_free (svgHandle); return false; } surface = cairo_image_surface_create_for_data ((unsigned char *) data, CAIRO_FORMAT_ARGB32, svgDimension.width, svgDimension.height, svgDimension.width * 4); if (surface) { cairo_t *cr; cr = cairo_create (surface); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); rsvg_handle_render_cairo (svgHandle, cr); cairo_destroy (cr); cairo_surface_destroy (surface); } rsvg_handle_free (svgHandle); return true; }
static cairo_surface_t * fill_image_buffer_from_file (cairo_t *cr, const char *filePath) { GError *error = NULL; RsvgHandle *handle; cairo_surface_t *tmp_surface; cairo_t *tmp_cr; handle = rsvg_handle_new_from_file (filePath, &error); if (handle == NULL) { g_warning("rsvg_handle_new_from_file(\"%s\") failed: %s", filePath, (error ? error->message : "unknown error")); if (error) g_error_free(error); return NULL; } tmp_surface = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, 32, 32); tmp_cr = cairo_create (tmp_surface); rsvg_handle_render_cairo (handle, tmp_cr); cairo_destroy (tmp_cr); rsvg_handle_free (handle); return tmp_surface; }
static void rb_rsvg_handle_free(RsvgHandle *handle) { if (handle) { rsvg_handle_free(handle); } }
ImagesStorage::ImagesStorage() { GError* error = 0; RsvgHandle* rsvgCards = rsvg_handle_new_from_file("PreferansData/svg-cards-2.0.svg", &error); loadFrenchDeck(rsvgCards); rsvg_handle_free(rsvgCards); }
SvgWindow::~SvgWindow () { if (source) { rsvg_handle_free (source->svg); delete source; } if (context) { finiTexture (context->texture[0]); delete context; } }
PyObject * render_svg_to_buffer(PyObject *module, PyObject *args, PyObject *kwargs) { int len, w, h, i; guchar *svgdata; GError *error; RsvgHandle *svg; GdkPixbuf *pixbuf; gboolean res; size_cb_data cbdata; PyObject *buffer; guchar *buffer_ptr; if (!PyArg_ParseTuple(args, "iis#", &w, &h, &svgdata, &len)) return NULL; cbdata.w = w; cbdata.h = h; svg = rsvg_handle_new(); rsvg_handle_set_size_callback(svg, size_cb, &cbdata, NULL); res = rsvg_handle_write(svg, svgdata, len, &error); res = rsvg_handle_close(svg, &error); pixbuf = rsvg_handle_get_pixbuf(svg); rsvg_handle_free(svg); w = gdk_pixbuf_get_width(pixbuf); h = gdk_pixbuf_get_height(pixbuf); buffer = PyBuffer_New(w*h*4); PyObject_AsWriteBuffer(buffer, (void **)&buffer_ptr, &len); memcpy(buffer_ptr, gdk_pixbuf_get_pixels(pixbuf), w*h*4); g_object_unref(pixbuf); // RGBA to BGRA conversion. // FIXME: MMXify. for (i = 0; i < w*h*4; i+=4) { guchar save = buffer_ptr[i+2]; buffer_ptr[i+2] = buffer_ptr[i]; buffer_ptr[i] = save; } return Py_BuildValue("(iiO)", w, h, buffer); }
static void svgFiniWindow(CompPlugin *p, CompWindow *w) { SVG_WINDOW(w); if (sw->source) { rsvg_handle_free(sw->source->svg); free(sw->source); } if (sw->context) { finiSvgTexture(w->screen, &sw->context->texture[0]); free(sw->context); } free(sw); }
void freeSVGCache(symbolObj *s) { #if defined(USE_SVG_CAIRO) || defined(USE_RSVG) struct svg_symbol_cache *cache = s->renderer_cache; assert(cache->svgc); #ifdef USE_SVG_CAIRO svg_cairo_destroy(cache->svgc); #else rsvg_handle_close(cache->svgc, NULL); #if LIBRSVG_CHECK_VERSION(2,35,0) g_object_unref(cache->svgc); #else rsvg_handle_free(cache->svgc); #endif #endif if(cache->pixmap_buffer) { msFreeRasterBuffer(cache->pixmap_buffer); free(cache->pixmap_buffer); } msFree(s->renderer_cache); #endif }
int main (int argc, char** argv) { cairo_t* cr3; cairo_surface_t* image; RsvgHandle* r_svg; RsvgError rs_err; RsvgDimensionData svgdim; cairo_matrix_t matrix; rsvg_init(); r_svg = rsvg_handle_new_from_file(argv[1], NULL); rsvg_handle_get_dimensions(r_svg, &svgdim); int width = svgdim.width; int height = svgdim.height; unsigned char* buf = (unsigned char*)malloc(width * height * 4); image = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32, width, height, width * 4); cr3 = cairo_create(image); cairo_set_source_rgb(cr3, 1.0, 0.0, 0.0); cairo_paint(cr3); rsvg_handle_render_cairo(r_svg, cr3); cairo_surface_write_to_png(image, "output.png"); rsvg_handle_free(r_svg); rsvg_term(); cairo_destroy(cr3); cairo_surface_destroy(image); free(buf); return 0; }
void cd_clock_clear_theme (CairoDockModuleInstance *myApplet, gboolean bClearAll) { if (myData.pBackgroundSurface != NULL) { cairo_surface_destroy (myData.pBackgroundSurface); myData.pBackgroundSurface = NULL; } if (myData.pForegroundSurface != NULL) { cairo_surface_destroy (myData.pForegroundSurface); myData.pForegroundSurface = NULL; } if (myData.iBgTexture != 0) { _cairo_dock_delete_texture (myData.iBgTexture); myData.iBgTexture = 0; } if (myData.iFgTexture != 0) { _cairo_dock_delete_texture (myData.iFgTexture); myData.iFgTexture = 0; } if (myData.iHourNeedleTexture != 0) { _cairo_dock_delete_texture (myData.iHourNeedleTexture); myData.iHourNeedleTexture = 0; } if (myData.iMinuteNeedleTexture != 0) { _cairo_dock_delete_texture (myData.iMinuteNeedleTexture); myData.iMinuteNeedleTexture = 0; } if (myData.iSecondNeedleTexture != 0) { _cairo_dock_delete_texture (myData.iSecondNeedleTexture); myData.iSecondNeedleTexture = 0; } if (myData.iDateTexture != 0) { _cairo_dock_delete_texture (myData.iDateTexture); myData.iDateTexture = 0; } if (myData.pNumericBgSurface != NULL) { cairo_surface_destroy (myData.pNumericBgSurface); myData.pNumericBgSurface = NULL; } if (bClearAll) { int i; for (i = 0; i < CLOCK_ELEMENTS; i ++) { if (myData.pSvgHandles[i] != NULL) { rsvg_handle_free (myData.pSvgHandles[i]); myData.pSvgHandles[i] = NULL; } } } }
static Bool svgSet (BananaArgument *arg, int nArg) { CompWindow *w; Window xid; BananaValue *window = getArgNamed ("window", arg, nArg); if (window != NULL) xid = window->i; else xid = 0; w = findWindowAtDisplay (xid); if (w) { decor_point_t p[2]; char *data; RsvgHandle *svg = NULL; GError *error = NULL; SVG_WINDOW (w); memset (p, 0, sizeof (p)); BananaValue *gravity0 = getArgNamed ("gravity0", arg, nArg); if (gravity0 != NULL) p[0].gravity = gravity0->i; else p[0].gravity = GRAVITY_NORTH | GRAVITY_WEST; BananaValue *x0 = getArgNamed ("x0", arg, nArg); if (x0 != NULL) p[0].x = x0->i; else p[0].x = 0; BananaValue *y0 = getArgNamed ("y0", arg, nArg); if (y0 != NULL) p[0].y = y0->i; else p[0].y = 0; BananaValue *gravity1 = getArgNamed ("gravity1", arg, nArg); if (gravity1 != NULL) p[1].gravity = gravity1->i; else p[1].gravity = GRAVITY_SOUTH | GRAVITY_EAST; BananaValue *x1 = getArgNamed ("x1", arg, nArg); if (x0 != NULL) p[1].x = x1->i; else p[1].x = 0; BananaValue *y1 = getArgNamed ("y1", arg, nArg); if (y1 != NULL) p[1].y = y1->i; else p[1].y = 0; BananaValue *b_data = getArgNamed ("data", arg, nArg); if (b_data != NULL) data = b_data->s; else data = NULL; if (data) svg = rsvg_handle_new_from_data ((guint8 *) data, strlen (data), &error); if (sw->source) { rsvg_handle_free (sw->source->svg); sw->source->svg = svg; } else { sw->source = malloc (sizeof (SvgSource)); if (sw->source) sw->source->svg = svg; } if (sw->source && sw->source->svg) { sw->source->p1 = p[0]; sw->source->p2 = p[1]; sw->source->svg = svg; rsvg_handle_get_dimensions (svg, &sw->source->dimension); updateWindowSvgContext (w, sw->source); } else { if (svg) rsvg_handle_free (svg); if (sw->source) { free (sw->source); sw->source = NULL; } if (sw->context) { finiSvgTexture (w->screen, &sw->context->texture[0]); free (sw->context); sw->context = NULL; } } } return FALSE; }
/* This function renders a pixbuf from an SVG file according to vals. */ static GdkPixbuf * load_rsvg_pixbuf (const gchar *filename, SvgLoadVals *vals, GError **error) { GdkPixbuf *pixbuf = NULL; RsvgHandle *handle; GIOChannel *io; gchar *uri; GIOStatus status = G_IO_STATUS_NORMAL; gboolean success = TRUE; io = g_io_channel_new_file (filename, "r", error); if (!io) return NULL; g_io_channel_set_encoding (io, NULL, NULL); handle = load_rsvg_handle_new (vals->resolution, vals->resolution); /* set the base URI so that librsvg can resolve relative paths */ uri = g_filename_to_uri (filename, NULL, NULL); if (uri) { gchar *p = strrchr (uri, '/'); if (p) *p = '\0'; rsvg_handle_set_base_uri (handle, uri); g_free (uri); } rsvg_handle_set_size_callback (handle, load_set_size_callback, vals, NULL); while (success && status != G_IO_STATUS_EOF) { gchar buf[8192]; gsize len; status = g_io_channel_read_chars (io, buf, sizeof (buf), &len, error); switch (status) { case G_IO_STATUS_ERROR: success = FALSE; break; case G_IO_STATUS_EOF: success = rsvg_handle_close (handle, error); break; case G_IO_STATUS_NORMAL: success = rsvg_handle_write (handle, (const guchar *) buf, len, error); break; case G_IO_STATUS_AGAIN: break; } } g_io_channel_unref (io); if (success) pixbuf = rsvg_handle_get_pixbuf (handle); rsvg_handle_free (handle); return pixbuf; }
/* This function retrieves the pixel size from an SVG file. Parsing * stops after the first chunk that provided the parser with enough * information to determine the size. This is usally the opening * <svg> element and should thus be in the first chunk (1024 bytes). */ static gboolean load_rsvg_size (const gchar *filename, SvgLoadVals *vals, GError **error) { RsvgHandle *handle; GIOChannel *io; GIOStatus status = G_IO_STATUS_NORMAL; gboolean success = TRUE; gboolean done = FALSE; io = g_io_channel_new_file (filename, "r", error); if (!io) return FALSE; g_io_channel_set_encoding (io, NULL, NULL); handle = load_rsvg_handle_new (vals->resolution, vals->resolution); vals->width = SVG_DEFAULT_SIZE; vals->height = SVG_DEFAULT_SIZE; while (success && status != G_IO_STATUS_EOF && (! done)) { gchar buf[1024]; gsize len; RsvgDimensionData dim = { 0, 0, 0.0, 0.0 }; status = g_io_channel_read_chars (io, buf, sizeof (buf), &len, error); switch (status) { case G_IO_STATUS_ERROR: success = FALSE; break; case G_IO_STATUS_EOF: success = rsvg_handle_close (handle, error); break; case G_IO_STATUS_NORMAL: success = rsvg_handle_write (handle, (const guchar *) buf, len, error); rsvg_handle_get_dimensions (handle, &dim); if (dim.width > 0 && dim.height > 0) { vals->width = dim.width; vals->height = dim.height; done = TRUE; } break; case G_IO_STATUS_AGAIN: break; } } if (size_label) { if (done) { gchar *text = g_strdup_printf (_("%d × %d"), vals->width, vals->height); gtk_label_set_text (GTK_LABEL (size_label), text); g_free (text); } else { gtk_label_set_text (GTK_LABEL (size_label), _("SVG file does not\nspecify a size!")); } } g_io_channel_unref (io); rsvg_handle_free (handle); if (vals->width < 1) vals->width = 1; if (vals->height < 1) vals->height = 1; return success; }
static Bool svgSet(CompDisplay *d, CompAction *action, CompActionState state, CompOption *option, int nOption) { CompWindow *w; Window xid; xid = getIntOptionNamed(option, nOption, "window", 0); w = findWindowAtDisplay(d, xid); if (w) { decor_point_t p[2]; char *data; RsvgHandle *svg = NULL; GError *error = NULL; SVG_WINDOW(w); memset(p, 0, sizeof (p)); p[0].gravity = getIntOptionNamed(option, nOption, "gravity0", GRAVITY_NORTH | GRAVITY_WEST); p[0].x = getIntOptionNamed(option, nOption, "x0", 0); p[0].y = getIntOptionNamed(option, nOption, "y0", 0); p[1].gravity = getIntOptionNamed(option, nOption, "gravity1", GRAVITY_SOUTH | GRAVITY_EAST); p[1].x = getIntOptionNamed(option, nOption, "x1", 0); p[1].y = getIntOptionNamed(option, nOption, "y1", 0); data = getStringOptionNamed(option, nOption, "data", 0); if (data) svg = rsvg_handle_new_from_data((guint8 *)data, strlen(data), &error); if (sw->source) { rsvg_handle_free(sw->source->svg); sw->source->svg = svg; } else { sw->source = malloc(sizeof (SvgSource)); if (sw->source) sw->source->svg = svg; } if (sw->source && sw->source->svg) { sw->source->p1 = p[0]; sw->source->p2 = p[1]; sw->source->svg = svg; rsvg_handle_get_dimensions(svg, &sw->source->dimension); updateWindowSvgContext(w, sw->source); } else { if (svg) rsvg_handle_free(svg); if (sw->source) { free(sw->source); sw->source = NULL; } if (sw->context) { finiSvgTexture(w->screen, &sw->context->texture[0]); free(sw->context); sw->context = NULL; } } } return FALSE; }
static RsvgHandle* gvloadimage_rsvg_load(GVJ_t * job, usershape_t *us) { RsvgHandle* rsvgh = NULL; guchar *fileBuf = NULL; GError *err = NULL; gsize fileSize; gint result; int fd; struct stat stbuf; assert(job); assert(us); assert(us->name); if (us->data) { if (us->datafree == gvloadimage_rsvg_free) rsvgh = (RsvgHandle*)(us->data); /* use cached data */ else { us->datafree(us); /* free incompatible cache data */ us->data = NULL; } } if (!rsvgh) { /* read file into cache */ if (!gvusershape_file_access(us)) return NULL; switch (us->type) { case FT_SVG: rsvg_init(); rsvgh = rsvg_handle_new(); if (rsvgh == NULL) { fprintf(stderr, "rsvg_handle_new_from_file returned an error: %s\n", err->message); rsvg_term(); return NULL; } fd = fileno(us->f); fstat(fd, &stbuf); fileSize = stbuf.st_size; fileBuf = calloc(fileSize + 1, sizeof(guchar)); if (fileBuf == NULL) { rsvg_handle_free(rsvgh); rsvg_term(); return NULL; } rewind(us->f); if ((result = fread(fileBuf, 1, fileSize, us->f)) < fileSize) { rsvg_handle_free(rsvgh); rsvg_term(); return NULL; } if (rsvg_handle_write(rsvgh, (const guchar *)fileBuf, (gsize)fileSize, &err) == FALSE) { fprintf(stderr, "rsvg_handle_write returned an error: %s\n", err->message); free(fileBuf); rsvg_handle_free(rsvgh); rsvg_term(); return NULL; } free(fileBuf); rsvg_handle_close(rsvgh, &err); rsvg_handle_set_dpi(rsvgh, POINTS_PER_INCH); break; default: rsvgh = NULL; } if (rsvgh) { us->data = (void*)rsvgh; us->datafree = gvloadimage_rsvg_free; } gvusershape_file_release(us); } return rsvgh; }