static int
rsvg_defs_load_extern (const RsvgDefs * defs, const char *name)
{
RsvgHandle *handle;
gchar *filename, *base_uri;
GByteArray *chars;
filename = rsvg_get_file_path (name, defs->base_uri);
chars = _rsvg_acquire_xlink_href_resource (name, defs->base_uri, NULL);
if (chars) {
handle = rsvg_handle_new ();
base_uri = rsvg_get_base_uri_from_filename (filename);
rsvg_handle_set_base_uri (handle, base_uri);
g_free (base_uri);
if (rsvg_handle_write (handle, chars->data, chars->len, NULL) &&
rsvg_handle_close (handle, NULL)) {
g_hash_table_insert (defs->externs, g_strdup (name), handle);
}
g_byte_array_free (chars, TRUE);
}
g_free (filename);
return 0;
}
static GdkPixbuf *
pixbuf_from_data_with_size_data (const guchar * buff,
size_t len,
struct RsvgSizeCallbackData *data,
const char *base_uri,
const char *id,
GError ** error)
{
RsvgHandle *handle;
GdkPixbuf *retval;
handle = rsvg_handle_new ();
if (!handle) {
g_set_error (error, rsvg_error_quark (), 0, _("Error creating SVG reader"));
return NULL;
}
rsvg_handle_set_size_callback (handle, _rsvg_size_callback, data, NULL);
rsvg_handle_set_base_uri (handle, base_uri);
if (!rsvg_handle_write (handle, buff, len, error)) {
g_object_unref (G_OBJECT (handle));
return NULL;
}
if (!rsvg_handle_close (handle, error)) {
g_object_unref (G_OBJECT (handle));
return NULL;
}
retval = rsvg_handle_get_pixbuf_sub (handle, id);
g_object_unref (G_OBJECT (handle));
return retval;
}
/* 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 = rsvg_handle_new ();
rsvg_handle_set_dpi (handle, 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);
g_object_unref (handle);
return pixbuf;
}
static gboolean
gdk_pixbuf__svg_image_load_increment (gpointer data,
const guchar *buf, guint size,
GError **error)
{
SvgContext *context = (SvgContext *)data;
if (error)
*error = NULL;
if (context->first_write == TRUE) {
context->first_write = FALSE;
context->handle = rsvg_handle_new ();
if (!context->handle) {
rsvg_propegate_error (error, _("Error displaying image"), ERROR_DISPLAYING_IMAGE);
return FALSE;
}
rsvg_handle_set_size_callback (context->handle, context->size_func, context->user_data, NULL);
}
if (!context->handle) {
rsvg_propegate_error (error, _("Error displaying image"), ERROR_DISPLAYING_IMAGE);
return FALSE;
}
if (!rsvg_handle_write (context->handle, buf, size, error)) {
rsvg_propegate_error (error, _("Error writing"), ERROR_WRITING);
return FALSE;
}
return TRUE;
}
UT_Error _importGraphic(const UT_ConstByteBufPtr & pBB)
{
GdkPixbuf * pixbuf = NULL;
GError * err = NULL;
RsvgHandle * rsvg = rsvg_handle_new ();
if ( FALSE == rsvg_handle_write ( rsvg, static_cast<const guchar *>(pBB->getPointer (0)),
static_cast<gsize>(pBB->getLength ()), &err ) )
{
UT_DEBUGMSG(("DOM: couldn't write to loader: %s\n", err->message));
g_error_free(err);
return UT_ERROR ;
}
if ( FALSE == rsvg_handle_close ( rsvg, &err ) )
{
UT_DEBUGMSG(("DOM: couldn't write to loader: %s\n", err->message));
g_error_free(err);
g_object_unref(G_OBJECT(rsvg));
return UT_ERROR ;
}
pixbuf = rsvg_handle_get_pixbuf ( rsvg ) ;
g_object_unref(G_OBJECT(rsvg));
if (!pixbuf)
{
return UT_ERROR;
}
g_object_ref (pixbuf);
// Initialize stuff to create our PNG.
UT_Error error = Initialize_PNG();
if (error)
{
return error;
}
if (setjmp(png_jmpbuf(m_pPNG)))
{
g_object_unref(G_OBJECT(pixbuf));
png_destroy_write_struct(&m_pPNG, &m_pPNGInfo);
return UT_ERROR;
}
//
// Build the png member variables.
//
_createPNGFromPixbuf(pixbuf);
//
// Get rid of these now that they are no longer needed
//
g_object_unref(G_OBJECT(pixbuf));
png_destroy_write_struct(&m_pPNG, &m_pPNGInfo);
return UT_OK;
}
CAMLprim value ml_rsvg_handle_write(value h, value s, value off, value len)
{
GError *err = NULL;
check_substring(s, off, len);
rsvg_handle_write(RsvgHandle_val(h),
(guchar *) String_val(s)+Int_val(off), Int_val(len), &err);
if (err != NULL)
ml_raise_gerror (err);
return Val_unit;
}
static VALUE
rb_rsvg_handle_write(VALUE self, VALUE buf)
{
gboolean result;
GError *error = NULL;
result = rsvg_handle_write(_SELF(self), (const guchar*)RVAL2CSTR(buf),
RSTRING_LEN(buf), &error);
if (!result) RAISE_GERROR(error);
return CBOOL2RVAL(result);
}
static bool rsvg_process_data(struct content *c, const char *data,
unsigned int size)
{
rsvg_content *d = (rsvg_content *) c;
GError *err = NULL;
if (rsvg_handle_write(d->rsvgh, (const guchar *)data, (gsize)size,
&err) == FALSE) {
NSLOG(netsurf, INFO,
"rsvg_handle_write returned an error: %s", err->message);
content_broadcast_errorcode(c, NSERROR_SVG_ERROR);
return false;
}
return true;
}
static bool rsvg_process_data(struct content *c, const char *data,
unsigned int size)
{
rsvg_content *d = (rsvg_content *) c;
union content_msg_data msg_data;
GError *err = NULL;
if (rsvg_handle_write(d->rsvgh, (const guchar *)data, (gsize)size,
&err) == FALSE) {
LOG(("rsvg_handle_write returned an error: %s", err->message));
msg_data.error = err->message;
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
return true;
}
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 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;
}
/* 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 = rsvg_handle_new ();
rsvg_handle_set_dpi (handle, 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);
g_object_unref (handle);
if (vals->width < 1) vals->width = 1;
if (vals->height < 1) vals->height = 1;
return success;
}
