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;
}
