static void
free_pixbuf_load_handle (GnomeGdkPixbufAsyncHandle *handle)
{
if (handle->done_callback)
(* handle->done_callback) (handle, handle->callback_data);
if (handle->loader != NULL) {
gdk_pixbuf_loader_close (handle->loader, NULL);
g_object_unref (G_OBJECT (handle->loader));
}
if (handle->file_input_stream != NULL) {
g_input_stream_close (G_INPUT_STREAM (handle->file_input_stream), NULL, NULL);
g_object_unref (handle->file_input_stream);
}
if (handle->file != NULL) {
g_object_unref (handle->file);
}
if (handle->cancellable != NULL) {
g_object_unref (handle->cancellable);
}
g_free (handle);
}
static GObject*
hippo_pixbuf_cache_parse(HippoObjectCache *cache,
const char *url,
const char *content_type,
GString *content,
GError **error_p)
{
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf;
loader = gdk_pixbuf_loader_new();
if (!gdk_pixbuf_loader_write(loader, (guchar*) content->str, content->len, error_p))
goto failed;
if (!gdk_pixbuf_loader_close(loader, error_p))
goto failed;
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf == NULL) {
g_set_error(error_p,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Could not load pixbuf"));
goto failed;
}
g_object_ref(pixbuf);
g_object_unref(loader);
return G_OBJECT(pixbuf);
failed:
g_assert(error_p == NULL || *error_p != NULL);
if (loader)
g_object_unref(loader);
return NULL;
}
static GdkPixbuf *
totem_gst_buffer_to_pixbuf (GstBuffer *buffer)
{
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf = NULL;
GError *err = NULL;
loader = gdk_pixbuf_loader_new ();
if (gdk_pixbuf_loader_write (loader, buffer->data, buffer->size, &err) &&
gdk_pixbuf_loader_close (loader, &err)) {
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf)
g_object_ref (pixbuf);
} else {
GST_WARNING("could not convert tag image to pixbuf: %s", err->message);
g_error_free (err);
}
g_object_unref (loader);
return pixbuf;
}
/** Convert Base64 to pixbuf
* @param b64 Base64 encoded data
*/
GdkPixbuf *
pixbuf_decode_base64 (const gchar *b64)
{
/* see lib/prop_pixbuf.c(data_pixbuf) for a very similiar implementation */
GdkPixbuf *pixbuf = NULL;
GdkPixbufLoader *loader;
GError *error = NULL;
loader = gdk_pixbuf_loader_new ();
if (loader) {
gint state = 0;
guint save = 0;
# define BUF_SIZE 4096
guchar buf[BUF_SIZE];
gchar *in = (gchar *)b64; /* direct access, not involving another xmlStrDup/xmlFree */
gssize len = strlen (b64);
do {
gsize step = g_base64_decode_step (in,
len > BUF_SIZE ? BUF_SIZE : len,
buf, &state, &save);
if (!gdk_pixbuf_loader_write (loader, buf, step, &error))
break;
in += BUF_SIZE;
len -= BUF_SIZE;
} while (len > 0);
if (gdk_pixbuf_loader_close (loader, error ? NULL : &error)) {
pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
} else {
message_warning (_("Failed to load image form diagram:\n%s"), error->message);
g_error_free (error);
}
g_object_unref (loader);
}
return pixbuf;
# undef BUF_SIZE
}
static void
avatar_cache_close_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GiggleAvatarCacheLoader *loader = user_data;
GInputStream *stream = G_INPUT_STREAM (object);
GError *error = NULL;
if (g_input_stream_close_finish (stream, result, &error) &&
gdk_pixbuf_loader_close (loader->pixbuf_loader, &error)) {
loader->pixbuf = gdk_pixbuf_loader_get_pixbuf (loader->pixbuf_loader);
avatar_cache_insert (loader->cache, loader->uri, loader->pixbuf);
g_object_unref (loader->pixbuf_loader);
loader->pixbuf_loader = NULL;
}
if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("%s: %s", G_STRFUNC, error->message);
avatar_cache_loader_finish (loader, error);
}
static void
load_finished (NemoImagePropertiesPage *page)
{
GtkWidget *label;
label = gtk_grid_get_child_at (GTK_GRID (page->details->grid), 0, 0);
gtk_container_remove (GTK_CONTAINER (page->details->grid), label);
if (page->details->loader != NULL) {
gdk_pixbuf_loader_close (page->details->loader, NULL);
}
if (page->details->got_size) {
append_basic_info (page);
append_options_info (page);
append_exif_info (page);
append_xmp_info (page);
} else {
append_item (page, _("Failed to load image information"), NULL);
}
if (page->details->loader != NULL) {
g_object_unref (page->details->loader);
page->details->loader = NULL;
}
#ifdef HAVE_EXIF
if (page->details->exifldr != NULL) {
exif_loader_unref (page->details->exifldr);
page->details->exifldr = NULL;
}
#endif /*HAVE_EXIF*/
#ifdef HAVE_EXEMPI
if (page->details->xmp != NULL) {
xmp_free (page->details->xmp);
page->details->xmp = NULL;
}
#endif
}
static void
cleanup_callback (GObject *object,
gpointer data)
{
if (load_timeout)
{
g_source_remove (load_timeout);
load_timeout = 0;
}
if (pixbuf_loader)
{
gdk_pixbuf_loader_close (pixbuf_loader, NULL);
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
}
if (image_stream)
{
g_object_unref (image_stream);
image_stream = NULL;
}
}
static GdkPixbuf*
parse_pixbuf(const char *url,
GString *image_data)
{
GdkPixbufLoader *loader;
GError *error;
GdkPixbuf *pixbuf;
loader = gdk_pixbuf_loader_new();
error = NULL;
if (!gdk_pixbuf_loader_write(loader, (guchar*) image_data->str, image_data->len, &error))
goto failed;
g_assert(error == NULL);
if (!gdk_pixbuf_loader_close(loader, &error))
goto failed;
g_assert(error == NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf == NULL)
goto failed;
g_object_ref(pixbuf);
g_object_unref(loader);
return pixbuf;
failed:
if (loader)
g_object_unref(loader);
if (error) {
g_debug("Failed to load image '%s': %s", url, error->message);
g_error_free(error);
}
return NULL;
}
static struct graphics_image_priv *
image_new(struct graphics_priv *gr, struct graphics_image_methods *meth, char *name, int *w, int *h, struct point *hot, int rotation)
{
GdkPixbuf *pixbuf;
struct graphics_image_priv *ret;
const char *option;
if (!strcmp(name,"buffer:")) {
struct graphics_image_buffer *buffer=(struct graphics_image_buffer *)name;
GdkPixbufLoader *loader=gdk_pixbuf_loader_new();
if (!loader)
return NULL;
if (*w != -1 || *h != -1)
gdk_pixbuf_loader_set_size(loader, *w, *h);
gdk_pixbuf_loader_write(loader, buffer->start, buffer->len, NULL);
gdk_pixbuf_loader_close(loader, NULL);
pixbuf=gdk_pixbuf_loader_get_pixbuf(loader);
g_object_ref(pixbuf);
g_object_unref(loader);
} else {
if (*w == -1 && *h == -1)
pixbuf=gdk_pixbuf_new_from_file(name, NULL);
else
pixbuf=gdk_pixbuf_new_from_file_at_size(name, *w, *h, NULL);
}
if (!pixbuf)
return NULL;
if (rotation) {
GdkPixbuf *tmp;
switch (rotation) {
case 90:
rotation=270;
break;
case 180:
break;
case 270:
rotation=90;
break;
default:
return NULL;
}
tmp=gdk_pixbuf_rotate_simple(pixbuf, rotation);
if (!tmp) {
g_object_unref(pixbuf);
return NULL;
}
g_object_unref(pixbuf);
pixbuf=tmp;
}
ret=g_new0(struct graphics_image_priv, 1);
ret->pixbuf=pixbuf;
ret->w=gdk_pixbuf_get_width(pixbuf);
ret->h=gdk_pixbuf_get_height(pixbuf);
*w=ret->w;
*h=ret->h;
if (hot) {
option=gdk_pixbuf_get_option(pixbuf, "x_hot");
if (option)
hot->x=atoi(option);
else
hot->x=ret->w/2-1;
option=gdk_pixbuf_get_option(pixbuf, "y_hot");
if (option)
hot->y=atoi(option);
else
hot->y=ret->h/2-1;
}
return ret;
}
GdkPixbuf * IE_ImpGraphic_GdkPixbuf::pixbufForByteBuf (UT_ByteBuf * pBB,
std::string & mimetype)
{
if ( !pBB || !pBB->getLength() )
return NULL;
GdkPixbuf * pixbuf = NULL;
bool bIsXPM = false;
const char * szBuf = reinterpret_cast<const char *>(pBB->getPointer(0));
if((pBB->getLength() > 9) && (strncmp (szBuf, "/* XPM */", 9) == 0))
{
bIsXPM = true;
}
if(bIsXPM)
{
pixbuf = _loadXPM(pBB);
}
else
{
GError * err = 0;
GdkPixbufLoader * ldr = 0;
ldr = gdk_pixbuf_loader_new ();
if (!ldr)
{
UT_DEBUGMSG (("GdkPixbuf: couldn't create loader! WTF?\n"));
UT_ASSERT (ldr);
return NULL ;
}
if (!gdk_pixbuf_loader_write (ldr, 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);
gdk_pixbuf_loader_close (ldr, NULL);
g_object_unref (G_OBJECT(ldr));
mimetype.clear();
return NULL ;
}
gdk_pixbuf_loader_close (ldr, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf (ldr);
GdkPixbufFormat * format = gdk_pixbuf_loader_get_format(ldr);
gchar ** mime_types = gdk_pixbuf_format_get_mime_types(format);
gchar ** current = mime_types;
while(*current) {
if((strcmp(*current, "image/jpeg") == 0)
|| (strcmp(*current, "image/png") == 0)) {
mimetype = *current;
break;
}
current++;
}
g_strfreev(mime_types);
// ref before closing the loader
if ( pixbuf )
g_object_ref (G_OBJECT(pixbuf));
g_object_unref (G_OBJECT(ldr));
}
return pixbuf;
}
/**
* be sure to unref the result if it is non-NULL
*
* TODO : this is really overkill for now.
* only wmf/emf will require regenerating the pixbuf for different scale
* factors. And even then we should cache them.
*/
static GdkPixbuf *
soi_get_pixbuf (SheetObjectImage *soi, double scale)
{
GError *err = NULL;
guint8 *data;
guint32 data_len;
GdkPixbufLoader *loader = NULL;
GdkPixbuf *pixbuf = NULL;
gboolean ret;
g_return_val_if_fail (IS_SHEET_OBJECT_IMAGE (soi), NULL);
data = soi->bytes.data;
data_len = soi->bytes.len;
if (data == NULL || data_len == 0)
return pixbuf;
if (soi->type != NULL && !strcmp (soi->type, "wmf"))
loader = gdk_pixbuf_loader_new_with_type (soi->type, &err);
else
loader = gdk_pixbuf_loader_new ();
if (soi->type == NULL || strlen (soi->type) == 0)
g_signal_connect (loader, "size-prepared",
G_CALLBACK (soi_info_cb), soi);
if (loader) {
ret = gdk_pixbuf_loader_write (loader,
soi->bytes.data, soi->bytes.len,
&err);
/* Close in any case. But don't let error during closing
* shadow error from loader_write. */
gdk_pixbuf_loader_close (loader, ret ? &err : NULL);
if (ret)
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf) {
g_object_ref (G_OBJECT (pixbuf));
d (printf ("pixbuf width=%d, height=%d\n",
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf)));
if (soi->crop_top != 0.0 || soi->crop_bottom != 0.0 ||
soi->crop_left != 0.0 || soi->crop_right != 0.0) {
d (printf ("crop rect top=%g, bottom=%g, "
"left=%g, right=%g\n",
soi->crop_top, soi->crop_bottom,
soi->crop_left, soi->crop_right));
pixbuf = soi_get_cropped_pixbuf (soi, pixbuf);
}
}
g_object_unref (G_OBJECT (loader));
}
if (!pixbuf) {
if (!soi->dumped) {
static int count = 0;
char *filename = g_strdup_printf ("unknown%d.%s",
count++, soi->type);
#if 0
GsfOutput *file = gsf_output_stdio_new (filename, NULL);
if (file) {
gsf_output_write (GSF_OUTPUT (file),
soi->bytes.len,
soi->bytes.data);
gsf_output_close (GSF_OUTPUT (file));
g_object_unref (file);
}
#endif
g_free (filename);
soi->dumped = TRUE;
}
if (err != NULL) {
g_warning ("%s", err->message);
g_error_free (err);
err = NULL;
} else {
g_warning ("Unable to display image");
}
}
return pixbuf;
}
void ArticleView::AppendData(gchar *data, const gchar *oword,
const gchar *real_oword)
{
std::string mark;
guint32 sec_size=0;
const guint32 data_size=get_uint32(data);
data+=sizeof(guint32);
const gchar *p=data;
bool first_time = true;
size_t iPlugin;
size_t nPlugins = gpAppFrame->oStarDictPlugins->ParseDataPlugins.nplugins();
unsigned int parsed_size;
ParseResult parse_result;
while (guint32(p - data)<data_size) {
if (first_time)
first_time=false;
else
mark+= "\n";
for (iPlugin = 0; iPlugin < nPlugins; iPlugin++) {
parse_result.clear();
if (gpAppFrame->oStarDictPlugins->ParseDataPlugins.parse(iPlugin, p, &parsed_size, parse_result, oword)) {
p += parsed_size;
break;
}
}
if (iPlugin != nPlugins) {
append_and_mark_orig_word(mark, real_oword, LinksPosList());
mark.clear();
append_data_parse_result(real_oword, parse_result);
parse_result.clear();
continue;
}
switch (*p) {
case 'm':
//case 'l': //TODO: convert from local encoding to utf-8
p++;
sec_size = strlen(p);
if (sec_size) {
gchar *m_str = g_markup_escape_text(p, sec_size);
mark+=m_str;
g_free(m_str);
}
sec_size++;
break;
case 'g':
p++;
sec_size=strlen(p);
if (sec_size) {
mark+=p;
}
sec_size++;
break;
case 'x':
p++;
sec_size = strlen(p) + 1;
mark+= _("XDXF data parsing plug-in is not found!");
break;
case 'k':
p++;
sec_size = strlen(p) + 1;
mark+= _("PowerWord data parsing plug-in is not found!");
break;
case 'w':
p++;
sec_size = strlen(p) + 1;
mark+= _("Wiki data parsing plug-in is not found!");
break;
case 'h':
p++;
sec_size = strlen(p) + 1;
mark+= _("HTML data parsing plug-in is not found!");
break;
case 'n':
p++;
sec_size = strlen(p) + 1;
mark+= _("WordNet data parsing plug-in is not found!");
break;
case 't':
p++;
sec_size = strlen(p);
if (sec_size) {
mark += "[<span foreground=\"blue\">";
gchar *m_str = g_markup_escape_text(p, sec_size);
mark += m_str;
g_free(m_str);
mark += "</span>]";
}
sec_size++;
break;
case 'y':
p++;
sec_size = strlen(p);
if (sec_size) {
mark += "[<span foreground=\"red\">";
gchar *m_str = g_markup_escape_text(p, sec_size);
mark += m_str;
g_free(m_str);
mark += "</span>]";
}
sec_size++;
break;
case 'r':
p++;
sec_size = strlen(p);
if(sec_size) {
append_and_mark_orig_word(mark, real_oword, LinksPosList());
mark.clear();
append_resource_file_list(p);
}
sec_size++;
break;
/*case 'W':
{
p++;
sec_size=g_ntohl(get_uint32(p));
//TODO: sound button.
sec_size += sizeof(guint32);
}
break;*/
case 'P':
{
p++;
sec_size=g_ntohl(get_uint32(p));
if (sec_size) {
if (for_float_win) {
append_and_mark_orig_word(mark, real_oword, LinksPosList());
mark.clear();
append_pixbuf(NULL);
} else {
GdkPixbufLoader* loader = gdk_pixbuf_loader_new();
gdk_pixbuf_loader_write(loader, (const guchar *)(p+sizeof(guint32)), sec_size, NULL);
gdk_pixbuf_loader_close(loader, NULL);
GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf) {
append_and_mark_orig_word(mark, real_oword, LinksPosList());
mark.clear();
append_pixbuf(pixbuf);
} else {
mark += _("<span foreground=\"red\">[Load image error!]</span>");
}
g_object_unref(loader);
}
} else {
mark += _("<span foreground=\"red\">[Missing Image]</span>");
}
sec_size += sizeof(guint32);
}
break;
default:
if (g_ascii_isupper(*p)) {
p++;
sec_size=g_ntohl(get_uint32(p));
sec_size += sizeof(guint32);
} else {
p++;
sec_size = strlen(p)+1;
}
mark += _("Unknown data type, please upgrade StarDict!");
break;
}
p += sec_size;
}
append_and_mark_orig_word(mark, real_oword, LinksPosList());
}
bool _openslide_gdkpixbuf_read(const char *format,
const char *filename,
int64_t offset,
int64_t length,
uint32_t *dest,
int32_t w, int32_t h,
GError **err) {
GdkPixbufLoader *loader = NULL;
uint8_t *buf = g_slice_alloc(BUFSIZE);
bool success = false;
struct load_state state = {
.w = w,
.h = h,
};
// open and seek
FILE *f = _openslide_fopen(filename, "rb", err);
if (!f) {
goto DONE;
}
if (fseeko(f, offset, SEEK_SET)) {
_openslide_io_error(err, "Couldn't fseek %s", filename);
goto DONE;
}
// create loader
loader = gdk_pixbuf_loader_new_with_type(format, err);
if (!loader) {
goto DONE;
}
g_signal_connect(loader, "area-prepared", G_CALLBACK(area_prepared), &state);
// read data
while (length) {
size_t count = fread(buf, 1, MIN(length, BUFSIZE), f);
if (!count) {
g_set_error(err, OPENSLIDE_ERROR, OPENSLIDE_ERROR_FAILED,
"Short read loading pixbuf from %s", filename);
goto DONE;
}
if (!gdk_pixbuf_loader_write(loader, buf, count, err)) {
g_prefix_error(err, "gdk-pixbuf error: ");
goto DONE;
}
if (state.err) {
goto DONE;
}
length -= count;
}
// finish load
if (!gdk_pixbuf_loader_close(loader, err)) {
g_prefix_error(err, "gdk-pixbuf error: ");
goto DONE;
}
if (state.err) {
goto DONE;
}
g_assert(state.pixbuf);
// copy pixels
uint8_t *pixels = gdk_pixbuf_get_pixels(state.pixbuf);
int rowstride = gdk_pixbuf_get_rowstride(state.pixbuf);
for (int32_t y = 0; y < h; y++) {
for (int32_t x = 0; x < w; x++) {
dest[y * w + x] = 0xFF000000 | // A
pixels[y * rowstride + x * 3 + 0] << 16 | // R
pixels[y * rowstride + x * 3 + 1] << 8 | // G
pixels[y * rowstride + x * 3 + 2]; // B
}
}
success = true;
DONE:
// clean up
if (loader) {
gdk_pixbuf_loader_close(loader, NULL);
g_object_unref(loader);
}
if (f) {
fclose(f);
}
g_slice_free1(BUFSIZE, buf);
// now that the loader is closed, we know state.err won't be set
// behind our back
if (state.err) {
// signal handler validation errors override GdkPixbuf errors
g_clear_error(err);
g_propagate_error(err, state.err);
// signal handler errors should have been noticed before falling through
g_assert(!success);
}
return success;
}
void remmina_rdp_cliprdr_process_data_response(RemminaProtocolWidget* gp, RDP_CB_DATA_RESPONSE_EVENT* event)
{
UINT8* data;
size_t size;
rfContext* rfi = GET_DATA(gp);
GdkPixbufLoader *pixbuf;
gpointer output = NULL;
data = event->data;
size = event->size;
if (size > 0)
{
switch (rfi->format)
{
case CB_FORMAT_UNICODETEXT:
{
size = ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)data, size / 2, (CHAR**)&data, 0, NULL, NULL);
crlf2lf(data, &size);
output = data;
break;
}
case CB_FORMAT_TEXT:
case CB_FORMAT_HTML:
{
crlf2lf(data, &size);
output = data;
break;
}
case CB_FORMAT_DIB:
{
wStream* s;
UINT16 bpp;
UINT32 offset;
UINT32 ncolors;
s = Stream_New(data, size);
Stream_Seek(s, 14);
Stream_Read_UINT16(s, bpp);
Stream_Read_UINT32(s, ncolors);
offset = 14 + 40 + (bpp <= 8 ? (ncolors == 0 ? (1 << bpp) : ncolors) * 4 : 0);
Stream_Free(s, TRUE);
s = Stream_New(NULL, 14 + size);
Stream_Write_UINT8(s, 'B');
Stream_Write_UINT8(s, 'M');
Stream_Write_UINT32(s, 14 + size);
Stream_Write_UINT32(s, 0);
Stream_Write_UINT32(s, offset);
Stream_Write(s, data, size);
data = Stream_Buffer(s);
size = Stream_Length(s);
pixbuf = gdk_pixbuf_loader_new();
gdk_pixbuf_loader_write(pixbuf, data, size, NULL);
gdk_pixbuf_loader_close(pixbuf, NULL);
Stream_Free(s, TRUE);
output = g_object_ref(gdk_pixbuf_loader_get_pixbuf(pixbuf));
g_object_unref(pixbuf);
break;
}
case CB_FORMAT_PNG:
case CB_FORMAT_JPEG:
{
pixbuf = gdk_pixbuf_loader_new();
gdk_pixbuf_loader_write(pixbuf, data, size, NULL);
output = g_object_ref(gdk_pixbuf_loader_get_pixbuf(pixbuf));
gdk_pixbuf_loader_close(pixbuf, NULL);
g_object_unref(pixbuf);
break;
}
}
}
g_async_queue_push(rfi->clipboard_queue, output);
}
static void
sanity_check(const gchar *filename)
{
GdkPixbufLoader *loader;
GSList *formats, *l;
GError *err = NULL;
GdkPixbuf *pixbuf;
gchar *buf = NULL;
gsize size;
FILE *fh;
gboolean ok, fileok = TRUE;
g_printerr("Performing sanity check for %s.\n", filename);
fileok &= ok = g_file_test(filename, G_FILE_TEST_EXISTS);
g_printerr("Does it exist: %s\n", ok ? "YES" : "NO");
fileok &= ok = g_file_test(filename, G_FILE_TEST_IS_REGULAR);
g_printerr("Is it a regular file: %s\n", ok ? "YES" : "NO");
fh = fopen(filename, "rb");
fileok &= ok = !!fh;
g_printerr("Can we open it for reading: %s\n", ok ? "YES" : "NO");
if (fh)
fclose(fh);
else
g_printerr("fopen() fails with: %s\n", g_strerror(errno));
fileok &= ok = g_file_get_contents(filename, &buf, &size, &err);
g_printerr("Can we use g_file_get_contents(): %s\n", ok ? "YES" : "NO");
if (!ok) {
g_printerr("g_file_get_contents() fails with: %s\n", err->message);
g_clear_error(&err);
}
if (!fileok) {
if (buf)
g_free(buf);
g_printerr("The file does not seem OK. No point continuing.\n");
return;
}
g_printerr("The file seems OK, continuing checks.\n");
pixbuf = gdk_pixbuf_new_from_file(filename, &err);
if (pixbuf) {
g_printerr("Apparently we can load the pixbuf (%dx%d) now?!\n",
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
g_printerr("What has changed?\n");
g_printerr("This is completely f****d up.\n");
g_object_unref(pixbuf);
}
else {
g_printerr("gdk_pixbuf_new_from_file() fails with: %s\n", err->message);
g_clear_error(&err);
}
g_printerr("Checking the pixbuf loaders.\n");
formats = gdk_pixbuf_get_formats();
for (l = formats; l; l = g_slist_next(l)) {
GdkPixbufFormat *pixbuf_format = (GdkPixbufFormat*)l->data;
gchar **ext;
gchar *fmtname, *desc, *exts;
fmtname = gdk_pixbuf_format_get_name(pixbuf_format);
desc = gdk_pixbuf_format_get_description(pixbuf_format);
ext = gdk_pixbuf_format_get_extensions(pixbuf_format);
exts = g_strjoinv(" ", ext);
g_printerr("Found format %s: %s (%s)\n", fmtname, desc, exts);
g_free(exts);
g_strfreev(ext);
g_free(desc);
format_check(pixbuf_format, buf, size);
loader = gdk_pixbuf_loader_new_with_type(fmtname, &err);
if (!loader) {
g_printerr(" Cannot create loader for %s: %s\n",
fmtname, err->message);
g_clear_error(&err);
g_free(fmtname);
continue;
}
ok = gdk_pixbuf_loader_write(loader, buf, size, &err);
if (ok) {
g_printerr(" Loader %s accepts the file content.\n", fmtname);
ok = gdk_pixbuf_loader_close(loader, &err);
if (ok) {
g_printerr(" Loader %s accepts the entire file.\n", fmtname);
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf) {
g_printerr(" Obtained pixbuf %dx%d from the loader.\n",
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
}
else {
g_printerr(" Cannot obtain pixbuf from the loader.\n");
}
}
else {
g_printerr(" Loader %s fails at close(): %s.\n",
fmtname, err->message);
g_clear_error(&err);
}
}
else {
g_printerr(" Loader %s does not accept the file content: %s\n",
fmtname, err->message);
g_clear_error(&err);
}
g_object_unref(loader);
g_free(fmtname);
}
g_slist_free(formats);
}
// maybe this should be (partly) in common/imageio.[c|h]?
static void _lib_import_update_preview(GtkFileChooser *file_chooser, gpointer data)
{
GtkWidget *preview;
char *filename;
GdkPixbuf *pixbuf = NULL;
gboolean have_preview = FALSE, no_preview_fallback = FALSE;
preview = GTK_WIDGET(data);
filename = gtk_file_chooser_get_preview_filename(file_chooser);
if(!g_file_test(filename, G_FILE_TEST_IS_REGULAR))
{
no_preview_fallback = TRUE;
}
else
{
// don't create dng thumbnails to avoid crashes in libtiff when these are hdr:
char *c = filename + strlen(filename);
while(c > filename && *c != '.') c--;
if(!strcasecmp(c, ".dng")) no_preview_fallback = TRUE;
}
// unfortunately we can not use following, because frequently it uses wrong orientation
// pixbuf = gdk_pixbuf_new_from_file_at_size(filename, 128, 128, NULL);
have_preview = (pixbuf != NULL);
if(!have_preview && !no_preview_fallback)
{
uint8_t *buffer = NULL;
size_t size;
char *mime_type = NULL;
if(!dt_exif_get_thumbnail(filename, &buffer, &size, &mime_type))
{
// Scale the image to the correct size
GdkPixbuf *tmp;
GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
if (!gdk_pixbuf_loader_write(loader, buffer, size, NULL)) goto cleanup;
if (!(tmp = gdk_pixbuf_loader_get_pixbuf(loader))) goto cleanup;
float ratio = 1.0 * gdk_pixbuf_get_height(tmp) / gdk_pixbuf_get_width(tmp);
int width = 128, height = 128 * ratio;
pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_BILINEAR);
have_preview = TRUE;
cleanup:
gdk_pixbuf_loader_close(loader, NULL);
free(mime_type);
free(buffer);
g_object_unref(loader); // This should clean up tmp as well
}
}
if(have_preview && !no_preview_fallback)
{
// get image orientation
dt_image_t img = { 0 };
(void)dt_exif_read(&img, filename);
// Rotate the image to the correct orientation
GdkPixbuf *tmp = pixbuf;
if(img.orientation == ORIENTATION_ROTATE_CCW_90_DEG)
{
tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
}
else if(img.orientation == ORIENTATION_ROTATE_CW_90_DEG)
{
tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_CLOCKWISE);
}
else if(img.orientation == ORIENTATION_ROTATE_180_DEG)
{
tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
}
if(pixbuf != tmp)
{
g_object_unref(pixbuf);
pixbuf = tmp;
}
}
if(no_preview_fallback || !have_preview)
{
guint8 *image_buffer = NULL;
/* load the dt logo as a brackground */
char filename[PATH_MAX] = { 0 };
char datadir[PATH_MAX] = { 0 };
char *logo;
dt_logo_season_t season = get_logo_season();
if(season != DT_LOGO_SEASON_NONE)
logo = g_strdup_printf("%%s/pixmaps/idbutton-%d.svg", (int)season);
else
logo = g_strdup("%s/pixmaps/idbutton.svg");
dt_loc_get_datadir(datadir, sizeof(datadir));
snprintf(filename, sizeof(filename), logo, datadir);
g_free(logo);
RsvgHandle *svg = rsvg_handle_new_from_file(filename, NULL);
if(svg)
{
cairo_surface_t *surface;
cairo_t *cr;
RsvgDimensionData dimension;
rsvg_handle_get_dimensions(svg, &dimension);
float svg_size = MAX(dimension.width, dimension.height);
float final_size = 128;
float factor = final_size / svg_size;
float final_width = dimension.width * factor * darktable.gui->ppd,
final_height = dimension.height * factor * darktable.gui->ppd;
int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, final_width);
image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8));
surface = dt_cairo_image_surface_create_for_data(image_buffer, CAIRO_FORMAT_ARGB32, final_width,
final_height, stride);
if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS)
{
free(image_buffer);
image_buffer = NULL;
}
else
{
cr = cairo_create(surface);
cairo_scale(cr, factor, factor);
rsvg_handle_render_cairo(svg, cr);
cairo_surface_flush(surface);
pixbuf = gdk_pixbuf_get_from_surface(surface, 0, 0, final_width / darktable.gui->ppd,
final_height / darktable.gui->ppd);
}
g_object_unref(svg);
}
have_preview = TRUE;
}
if(have_preview) gtk_image_set_from_pixbuf(GTK_IMAGE(preview), pixbuf);
if(pixbuf) g_object_unref(pixbuf);
g_free(filename);
gtk_file_chooser_set_preview_widget_active(file_chooser, have_preview);
}
void
Tetris::dragDrop(GtkWidget *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *data, guint info,
guint time, Tetris * t)
{
const char *fileuri;
GError *error = NULL;
GFile *file;
GFile *outfile;
GFileInfo *fileinfo;
GFileInputStream *istream;
GFileOutputStream *outstream;
goffset filesize;
gssize bytesread, byteswrote;
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf;
guchar *buffer;
/* Accept a dropped filename and try and load it as the
background image. In the event of any kind of failure we
silently ignore it. */
/* FIXME: We don't handle colour gradients (e.g. from the gimp) */
/* FIXME: Dropped URLs from mozilla don't work (see below). */
if (data->length < 0) {
gtk_drag_finish (context, FALSE, FALSE, time);
return;
}
gtk_drag_finish (context, TRUE, FALSE, time);
if (info == COLOUR) {
if (data->length == 8)
decodeColour ((guint16 *)data->data, t);
return;
}
if (info == RESET) {
resetColour (t);
return;
}
fileuri = decodeDropData ((char *)data->data, info);
/* Silently ignore bad data. */
if (fileuri == NULL)
goto error_exit;
/* Now that we have a URI we load it and test it to see if it is
* an image file. */
file = g_file_new_for_uri (fileuri);
istream = g_file_read (file, NULL, &error);
if (error)
goto error_exit;
fileinfo = g_file_input_stream_query_info (istream, (char *)G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &error);
if (error)
goto error_exit_handle;
filesize = g_file_info_get_size (fileinfo);
buffer = (guchar *)g_malloc (filesize);
if (buffer == NULL)
goto error_exit_handle;
bytesread = g_input_stream_read (G_INPUT_STREAM (istream), buffer, filesize, NULL, &error);
/* FIXME: We should reread if not enough was read. */
if (error || (bytesread != filesize))
goto error_exit_buffer;
loader = gdk_pixbuf_loader_new ();
if (!gdk_pixbuf_loader_write (loader, buffer, filesize, NULL))
goto error_exit_loader;
gdk_pixbuf_loader_close (loader, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf == NULL)
goto error_exit_loader;
g_object_ref (pixbuf);
/* We now have an image file, in memory, that we know gdk-pixbuf
* can handle. Now we save it to disk. This is necessary so that
* "slow" URIs (e.g. http) behave well in the long run. */
outfile = g_file_new_for_path (t->bgPixmap);
outstream = g_file_replace (outfile, NULL, FALSE, G_FILE_CREATE_PRIVATE,
NULL, &error);
if (error)
goto error_exit_loader;
byteswrote = g_output_stream_write (G_OUTPUT_STREAM (outstream), buffer,
bytesread, NULL, &error);
if (byteswrote != filesize)
goto error_exit_saver;
t->usebg = TRUE;
t->saveBgOptions ();
error_exit_saver:
g_object_unref(outstream);
error_exit_loader:
g_object_unref (loader);
error_exit_buffer:
g_free (buffer);
error_exit_handle:
g_object_unref(istream);
error_exit:
if(error)
g_error_free(error);
return;
}
cairo_surface_t *
rsvg_cairo_surface_new_from_href (RsvgHandle *handle,
const char *href,
GError **error)
{
char *data;
gsize data_len;
char *mime_type = NULL;
GdkPixbufLoader *loader = NULL;
GdkPixbuf *pixbuf = NULL;
cairo_surface_t *surface = NULL;
data = _rsvg_handle_acquire_data (handle, href, &mime_type, &data_len, error);
if (data == NULL)
return NULL;
if (mime_type) {
loader = gdk_pixbuf_loader_new_with_mime_type (mime_type, error);
} else {
loader = gdk_pixbuf_loader_new ();
}
if (loader == NULL)
goto out;
if (!gdk_pixbuf_loader_write (loader, (guchar *) data, data_len, error)) {
gdk_pixbuf_loader_close (loader, NULL);
goto out;
}
if (!gdk_pixbuf_loader_close (loader, error))
goto out;
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (!pixbuf) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Failed to load image '%s': reason not known, probably a corrupt image file"),
href);
goto out;
}
surface = rsvg_cairo_surface_from_pixbuf (pixbuf);
if (mime_type == NULL) {
/* Try to get the information from the loader */
GdkPixbufFormat *format;
char **mime_types;
if ((format = gdk_pixbuf_loader_get_format (loader)) != NULL) {
mime_types = gdk_pixbuf_format_get_mime_types (format);
if (mime_types != NULL)
mime_type = g_strdup (mime_types[0]);
g_strfreev (mime_types);
}
}
if ((handle->priv->flags & RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA) != 0 &&
mime_type != NULL &&
cairo_surface_set_mime_data (surface, mime_type, (guchar *) data,
data_len, g_free, data) == CAIRO_STATUS_SUCCESS) {
data = NULL; /* transferred to the surface */
}
out:
if (loader)
g_object_unref (loader);
g_free (mime_type);
g_free (data);
return surface;
}
GdkPixbuf*
hybrid_create_round_pixbuf(const guchar *pixbuf_data, gint pixbuf_len,
gint scale_size)
{
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf;
GdkPixbuf *newpixbuf;
gint orig_width;
gint orig_height;
guchar *default_pixbuf_data;
gsize default_pixbuf_size;
loader = gdk_pixbuf_loader_new();
if (!pixbuf_data || pixbuf_len == 0) { /**< Load the default. */
g_file_get_contents(PIXMAPS_DIR"icons/icon.png",
(gchar**)&default_pixbuf_data, &default_pixbuf_size, NULL);
gdk_pixbuf_loader_write(loader, default_pixbuf_data,
default_pixbuf_size, NULL);
g_free(default_pixbuf_data);
} else {
gdk_pixbuf_loader_write(loader, pixbuf_data, pixbuf_len, NULL);
}
gdk_pixbuf_loader_close(loader, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf) {
g_object_ref(loader);
}
g_object_unref(loader);
if (!pixbuf) {
hybrid_debug_error("blist", "get pixbuf from loader");
return NULL;
}
orig_width = gdk_pixbuf_get_width(pixbuf);
orig_height = gdk_pixbuf_get_height(pixbuf);
newpixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, scale_size, scale_size);
gdk_pixbuf_fill(newpixbuf, 0x00000000);
gdk_pixbuf_scale(pixbuf, newpixbuf, 0, 0, scale_size, scale_size, 0, 0,
(double)scale_size/(double)orig_width,
(double)scale_size/(double)orig_height, GDK_INTERP_BILINEAR);
g_object_unref(pixbuf);
if (pixbuf_is_opaque(newpixbuf)) {
pixbuf_make_round(newpixbuf);
}
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, scale_size, scale_size);
gdk_pixbuf_fill(pixbuf, 0x00000000);
gdk_pixbuf_copy_area(newpixbuf, 0, 0, scale_size, scale_size,
pixbuf, 0, 0);
g_object_unref(newpixbuf);
return pixbuf;
}
static void image_decode_data (video_decoder_t *this_gen, buf_element_t *buf) {
image_decoder_t *this = (image_decoder_t *) this_gen;
GError *error = NULL;
if (!this->video_open) {
lprintf("opening video\n");
(this->stream->video_out->open) (this->stream->video_out, this->stream);
this->video_open = 1;
}
if (this->loader == NULL) {
this->loader = gdk_pixbuf_loader_new ();
}
if (gdk_pixbuf_loader_write (this->loader, buf->mem, buf->size, &error) == FALSE) {
lprintf("error loading image: %s\n", error->message);
g_error_free (error);
gdk_pixbuf_loader_close (this->loader, NULL);
g_object_unref (G_OBJECT (this->loader));
this->loader = NULL;
return;
}
if (buf->decoder_flags & BUF_FLAG_FRAME_END) {
GdkPixbuf *pixbuf;
int width, height, rowstride, n_channels;
guchar *img_buf;
vo_frame_t *img;
int color_matrix, flags;
void *rgb2yuy2;
/*
* this->image -> rgb data
*/
if (gdk_pixbuf_loader_close (this->loader, &error) == FALSE) {
lprintf("error loading image: %s\n", error->message);
g_error_free (error);
g_object_unref (G_OBJECT (this->loader));
this->loader = NULL;
return;
}
pixbuf = gdk_pixbuf_loader_get_pixbuf (this->loader);
if (pixbuf != NULL)
g_object_ref (G_OBJECT (pixbuf));
g_object_unref (this->loader);
this->loader = NULL;
if (pixbuf == NULL) {
lprintf("error loading image\n");
return;
}
width = gdk_pixbuf_get_width (pixbuf) & ~1; /* must be even for init_yuv_planes */
height = gdk_pixbuf_get_height (pixbuf);
img_buf = gdk_pixbuf_get_pixels (pixbuf);
_x_stream_info_set(this->stream, XINE_STREAM_INFO_VIDEO_WIDTH, width);
_x_stream_info_set(this->stream, XINE_STREAM_INFO_VIDEO_HEIGHT, height);
lprintf("image loaded successfully\n");
flags = VO_BOTH_FIELDS;
color_matrix =
this->stream->video_out->get_capabilities (this->stream->video_out) & VO_CAP_FULLRANGE ? 11 : 10;
VO_SET_FLAGS_CM (color_matrix, flags);
/*
* alloc video frame
*/
img = this->stream->video_out->get_frame (this->stream->video_out, width, height,
(double)width / (double)height,
XINE_IMGFMT_YUY2,
flags);
/* crop if allocated frame is smaller than requested */
if (width > img->width)
width = img->width;
if (height > img->height)
height = img->height;
img->ratio = (double)width / (double)height;
/* rgb data -> yuv */
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
rgb2yuy2 = rgb2yuy2_alloc (color_matrix, n_channels > 3 ? "rgba" : "rgb");
if (!img->proc_slice || (img->height & 15)) {
/* do all at once */
rgb2yuy2_slice (rgb2yuy2, img_buf, rowstride, img->base[0], img->pitches[0], width, height);
} else {
/* sliced */
uint8_t *sptr[1];
int y, h = 16;
for (y = 0; y < height; y += 16) {
if (y + 16 > height)
h = height & 15;
sptr[0] = img->base[0] + y * img->pitches[0];
rgb2yuy2_slice (rgb2yuy2, img_buf + y * rowstride, rowstride, sptr[0], img->pitches[0],
width, h);
img->proc_slice (img, sptr);
}
}
rgb2yuy2_free (rgb2yuy2);
g_object_unref (pixbuf);
/*
* draw video frame
*/
img->pts = buf->pts;
img->duration = 3600;
img->bad_frame = 0;
_x_stream_info_set(this->stream, XINE_STREAM_INFO_FRAME_DURATION, img->duration);
img->draw(img, this->stream);
img->free(img);
}
}
static void _camera_process_job(const dt_camctl_t *c,const dt_camera_t *camera, gpointer job)
{
dt_camera_t *cam=(dt_camera_t *)camera;
_camctl_camera_job_t *j = (_camctl_camera_job_t *)job;
switch( j->type )
{
case _JOB_TYPE_EXECUTE_CAPTURE:
{
dt_print (DT_DEBUG_CAMCTL,"[camera_control] executing remote camera capture job\n");
CameraFilePath fp;
int res=GP_OK;
if( (res = gp_camera_capture (camera->gpcam, GP_CAPTURE_IMAGE,&fp, c->gpcontext)) == GP_OK )
{
CameraFile *destination;
const char *output_path = _dispatch_request_image_path(c,camera);
if( !output_path ) output_path="/tmp";
const char *fname = _dispatch_request_image_filename(c,fp.name,cam);
if( !fname ) fname=fp.name;
char *output = g_build_filename (output_path,fname,(char *)NULL);
int handle = open (output, O_CREAT | O_WRONLY,0666);
gp_file_new_from_fd (&destination , handle);
gp_camera_file_get (camera->gpcam, fp.folder , fp.name, GP_FILE_TYPE_NORMAL, destination, c->gpcontext);
close (handle);
// Notify listerners of captured image
_dispatch_camera_image_downloaded (c,camera,output);
g_free (output);
}
else
dt_print (DT_DEBUG_CAMCTL,"[camera_control] capture job failed to capture image: %s\n",gp_result_as_string(res));
}
break;
case _JOB_TYPE_EXECUTE_LIVE_VIEW:
{
CameraFile *fp = NULL;
int res = GP_OK;
const gchar* data = NULL;
unsigned long int data_size = 0;
gp_file_new(&fp);
if( (res = gp_camera_capture_preview (cam->gpcam, fp, c->gpcontext)) != GP_OK )
{
dt_print (DT_DEBUG_CAMCTL,"[camera_control] live view failed to capture preview: %s\n", gp_result_as_string(res));
}
else if( (res = gp_file_get_data_and_size(fp, &data, &data_size)) != GP_OK )
{
dt_print (DT_DEBUG_CAMCTL,"[camera_control] live view failed to get preview data: %s\n", gp_result_as_string(res));
}
else
{
// everything worked
GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
if(gdk_pixbuf_loader_write(loader, (guchar*)data, data_size, NULL) == TRUE)
{
dt_pthread_mutex_lock(&cam->live_view_pixbuf_mutex);
if(cam->live_view_pixbuf != NULL)
g_object_unref(cam->live_view_pixbuf);
cam->live_view_pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
dt_pthread_mutex_unlock(&cam->live_view_pixbuf_mutex);
}
gdk_pixbuf_loader_close(loader, NULL);
}
if(fp)
gp_file_free(fp);
dt_pthread_mutex_unlock(&cam->live_view_synch);
dt_control_queue_redraw_center();
}
break;
case _JOB_TYPE_SET_PROPERTY:
{
_camctl_camera_set_property_job_t *spj=(_camctl_camera_set_property_job_t *)job;
dt_print(DT_DEBUG_CAMCTL,"[camera_control] executing set camera config job %s=%s\n",spj->name,spj->value);
CameraWidget *config; // Copy of camera configuration
CameraWidget *widget;
gp_camera_get_config( cam->gpcam, &config, c->gpcontext );
if( gp_widget_get_child_by_name ( config, spj->name, &widget) == GP_OK)
{
gp_widget_set_value ( widget , spj->value);
gp_camera_set_config( cam->gpcam, config, c->gpcontext );
}
/* dt_pthread_mutex_lock( &cam->config_lock );
CameraWidget *widget;
if( gp_widget_get_child_by_name ( camera->configuration, spj->name, &widget) == GP_OK) {
gp_widget_set_value ( widget , spj->value);
//gp_widget_set_changed( widget, 1 );
cam->config_changed=TRUE;
}
dt_pthread_mutex_unlock( &cam->config_lock);*/
}
break;
default:
dt_print(DT_DEBUG_CAMCTL,"[camera_control] process of unknown job type %lx\n",(unsigned long int)j->type);
break;
}
g_free(j);
}
static gint
progressive_timeout (gpointer data)
{
GtkWidget *image;
LoadContext *lc;
image = GTK_WIDGET (data);
lc = get_load_context (image);
/* This shows off fully-paranoid error handling, so looks scary.
* You could factor out the error handling code into a nice separate
* function to make things nicer.
*/
if (lc->image_stream)
{
size_t bytes_read;
guchar buf[256];
GError *error = NULL;
bytes_read = fread (buf, 1, 256, lc->image_stream);
if (ferror (lc->image_stream))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failure reading image file 'alphatest.png': %s",
g_strerror (errno));
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
fclose (lc->image_stream);
lc->image_stream = NULL;
gtk_widget_show (dialog);
lc->load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
if (!gdk_pixbuf_loader_write (lc->pixbuf_loader,
buf, bytes_read,
&error))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load image: %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
fclose (lc->image_stream);
lc->image_stream = NULL;
gtk_widget_show (dialog);
lc->load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
if (feof (lc->image_stream))
{
fclose (lc->image_stream);
lc->image_stream = NULL;
/* Errors can happen on close, e.g. if the image
* file was truncated we'll know on close that
* it was incomplete.
*/
error = NULL;
if (!gdk_pixbuf_loader_close (lc->pixbuf_loader,
&error))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load image: %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
g_object_unref (lc->pixbuf_loader);
lc->pixbuf_loader = NULL;
lc->load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
g_object_unref (lc->pixbuf_loader);
lc->pixbuf_loader = NULL;
}
}
else
{
lc->image_stream = fopen (lc->filename, "r");
if (lc->image_stream == NULL)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Unable to open image file '%s': %s",
lc->filename,
g_strerror (errno));
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
lc->load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
if (lc->pixbuf_loader)
{
gdk_pixbuf_loader_close (lc->pixbuf_loader, NULL);
g_object_unref (lc->pixbuf_loader);
lc->pixbuf_loader = NULL;
}
lc->pixbuf_loader = gdk_pixbuf_loader_new ();
g_signal_connect (lc->pixbuf_loader, "area_prepared",
G_CALLBACK (progressive_prepared_callback), image);
g_signal_connect (lc->pixbuf_loader, "area_updated",
G_CALLBACK (progressive_updated_callback), image);
}
/* leave timeout installed */
return TRUE;
}
static GdkPixbuf *
_gdk_pixbuf_new_from_uri_at_scale (const char *uri,
gint size,
GError **error)
{
gboolean result;
guchar buffer[LOAD_BUFFER_SIZE];
gssize bytes_read;
GdkPixbufLoader *loader = NULL;
GdkPixbuf *pixbuf;
GdkPixbufAnimation *animation;
GdkPixbufAnimationIter *iter;
gboolean has_frame;
SizePrepareContext info;
GFile *file;
GInputStream *input_stream;
g_return_val_if_fail (uri != NULL, NULL);
file = g_file_new_for_uri (uri);
input_stream = G_INPUT_STREAM (g_file_read (file, NULL, error));
if (input_stream == NULL) {
g_object_unref (file);
return NULL;
}
has_frame = FALSE;
result = FALSE;
while (!has_frame) {
bytes_read = g_input_stream_read (input_stream,
buffer,
sizeof (buffer),
NULL,
error);
if (bytes_read == -1) {
break;
}
result = TRUE;
if (bytes_read == 0) {
break;
}
if (loader == NULL) {
loader = create_loader (file, buffer, bytes_read);
if (1 <= size) {
info.size = size;
info.input_width = info.input_height = 0;
g_signal_connect (loader, "size-prepared", G_CALLBACK (size_prepared_cb), &info);
}
g_assert (loader != NULL);
}
if (!gdk_pixbuf_loader_write (loader,
(unsigned char *)buffer,
bytes_read,
error)) {
result = FALSE;
break;
}
animation = gdk_pixbuf_loader_get_animation (loader);
if (animation) {
iter = gdk_pixbuf_animation_get_iter (animation, NULL);
if (!gdk_pixbuf_animation_iter_on_currently_loading_frame (iter)) {
has_frame = TRUE;
}
g_object_unref (iter);
}
}
if (loader == NULL) {
/* This can happen if the above loop was exited due to the
* g_input_stream_read() call failing. */
result = FALSE;
} else if (*error != NULL) {
gdk_pixbuf_loader_close (loader, NULL);
result = FALSE;
} else if (gdk_pixbuf_loader_close (loader, error) == FALSE) {
if (!g_error_matches (*error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INCOMPLETE_ANIMATION))
result = FALSE;
else
g_clear_error (error);
}
if (!result) {
g_clear_object (&loader);
g_input_stream_close (input_stream, NULL, NULL);
g_object_unref (input_stream);
g_object_unref (file);
return NULL;
}
g_input_stream_close (input_stream, NULL, NULL);
g_object_unref (input_stream);
g_object_unref (file);
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf != NULL) {
g_object_ref (G_OBJECT (pixbuf));
g_object_set_data (G_OBJECT (pixbuf), "gnome-original-width",
GINT_TO_POINTER (info.input_width));
g_object_set_data (G_OBJECT (pixbuf), "gnome-original-height",
GINT_TO_POINTER (info.input_height));
}
g_object_unref (G_OBJECT (loader));
return pixbuf;
}
static void
load_sliced_image (GTask *result,
gpointer object,
gpointer task_data,
GCancellable *cancellable)
{
AsyncImageData *data;
GList *res = NULL;
GdkPixbuf *pix;
gint width, height, y, x;
GdkPixbufLoader *loader;
GError *error = NULL;
gchar *buffer = NULL;
gsize length;
g_assert (!cancellable);
data = task_data;
g_assert (data);
loader = gdk_pixbuf_loader_new ();
g_signal_connect (loader, "size-prepared", G_CALLBACK (on_loader_size_prepared), data);
if (!g_file_load_contents (data->gfile, NULL, &buffer, &length, NULL, &error))
{
g_warning ("Failed to open sliced image: %s", error->message);
goto out;
}
if (!gdk_pixbuf_loader_write (loader, (const guchar *) buffer, length, &error))
{
g_warning ("Failed to load image: %s", error->message);
goto out;
}
if (!gdk_pixbuf_loader_close (loader, NULL))
goto out;
pix = gdk_pixbuf_loader_get_pixbuf (loader);
width = gdk_pixbuf_get_width (pix);
height = gdk_pixbuf_get_height (pix);
for (y = 0; y < height; y += data->grid_height * data->scale_factor)
{
for (x = 0; x < width; x += data->grid_width * data->scale_factor)
{
GdkPixbuf *pixbuf = gdk_pixbuf_new_subpixbuf (pix, x, y,
data->grid_width * data->scale_factor,
data->grid_height * data->scale_factor);
g_assert (pixbuf != NULL);
res = g_list_append (res, pixbuf);
}
}
out:
/* We don't need the original pixbuf anymore, which is owned by the loader,
* though the subpixbufs will hold a reference. */
g_object_unref (loader);
g_free (buffer);
g_clear_pointer (&error, g_error_free);
g_task_return_pointer (result, res, free_glist_unref_gobjects);
}
static void
load_finished (CajaImagePropertiesPage *page)
{
GdkPixbufFormat *format;
char *name, *desc;
gtk_widget_destroy (page->details->loading_label);
if (page->details->loader != NULL) {
gdk_pixbuf_loader_close (page->details->loader, NULL);
}
if (page->details->got_size)
{
#ifdef HAVE_EXIF
ExifData *exif_data;
#endif /*HAVE_EXIF*/
format = gdk_pixbuf_loader_get_format (page->details->loader);
name = gdk_pixbuf_format_get_name (format);
desc = gdk_pixbuf_format_get_description (format);
append_label_take_str
(page->details->vbox,
g_strdup_printf ("<b>%s</b> %s (%s)",
_("Image Type:"), name, desc));
append_label_take_str
(page->details->vbox,
g_strdup_printf (ngettext ("<b>Width:</b> %d pixel",
"<b>Width:</b> %d pixels",
page->details->width),
page->details->width));
append_label_take_str
(page->details->vbox,
g_strdup_printf (ngettext ("<b>Height:</b> %d pixel",
"<b>Height:</b> %d pixels",
page->details->height),
page->details->height));
g_free (name);
g_free (desc);
#ifdef HAVE_EXIF
exif_data = exif_loader_get_data (page->details->exifldr);
append_exifdata_string (exif_data, page);
exif_data_unref (exif_data);
#endif /*HAVE_EXIF*/
#ifdef HAVE_EXEMPI
append_xmpdata_string (page->details->xmp, page);
#endif /*HAVE_EXEMPI*/
}
else
{
append_label (page->details->vbox,
_("Failed to load image information"));
}
if (page->details->loader != NULL)
{
g_object_unref (page->details->loader);
page->details->loader = NULL;
}
#ifdef HAVE_EXIF
if (page->details->exifldr != NULL)
{
exif_loader_unref (page->details->exifldr);
page->details->exifldr = NULL;
}
#endif /*HAVE_EXIF*/
#ifdef HAVE_EXEMPI
if (page->details->xmp != NULL)
{
xmp_free(page->details->xmp);
page->details->xmp = NULL;
}
#endif /*HAVE_EXEMPI*/
}
static GdkPixbuf *
impl_load_pixbuf_data (const guchar *data,
gsize size,
int available_width,
int available_height,
int scale,
GError **error)
{
GdkPixbufLoader *pixbuf_loader = NULL;
GdkPixbuf *rotated_pixbuf = NULL;
GdkPixbuf *pixbuf;
gboolean success;
Dimensions available_dimensions;
int width_before_rotation, width_after_rotation;
pixbuf_loader = gdk_pixbuf_loader_new ();
available_dimensions.width = available_width;
available_dimensions.height = available_height;
available_dimensions.scale = scale;
g_signal_connect (pixbuf_loader, "size-prepared",
G_CALLBACK (on_image_size_prepared), &available_dimensions);
success = gdk_pixbuf_loader_write (pixbuf_loader, data, size, error);
if (!success)
goto out;
success = gdk_pixbuf_loader_close (pixbuf_loader, error);
if (!success)
goto out;
pixbuf = gdk_pixbuf_loader_get_pixbuf (pixbuf_loader);
width_before_rotation = gdk_pixbuf_get_width (pixbuf);
rotated_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf);
width_after_rotation = gdk_pixbuf_get_width (rotated_pixbuf);
/* There is currently no way to tell if the pixbuf will need to be rotated before it is loaded,
* so we only check that once it is loaded, and reload it again if it needs to be rotated in order
* to use the available width and height correctly.
* See http://bugzilla.gnome.org/show_bug.cgi?id=579003
*/
if (width_before_rotation != width_after_rotation)
{
g_object_unref (pixbuf_loader);
g_object_unref (rotated_pixbuf);
rotated_pixbuf = NULL;
pixbuf_loader = gdk_pixbuf_loader_new ();
/* We know that the image will later be rotated, so we reverse the available dimensions. */
available_dimensions.width = available_height;
available_dimensions.height = available_width;
available_dimensions.scale = scale;
g_signal_connect (pixbuf_loader, "size-prepared",
G_CALLBACK (on_image_size_prepared), &available_dimensions);
success = gdk_pixbuf_loader_write (pixbuf_loader, data, size, error);
if (!success)
goto out;
success = gdk_pixbuf_loader_close (pixbuf_loader, error);
if (!success)
goto out;
pixbuf = gdk_pixbuf_loader_get_pixbuf (pixbuf_loader);
rotated_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf);
}
out:
if (pixbuf_loader)
g_object_unref (pixbuf_loader);
return rotated_pixbuf;
}
static gint
progressive_timeout (gpointer data)
{
GtkWidget *picture;
picture = GTK_WIDGET (data);
/* This shows off fully-paranoid error handling, so looks scary.
* You could factor out the error handling code into a nice separate
* function to make things nicer.
*/
if (image_stream)
{
gssize bytes_read;
guchar buf[256];
GError *error = NULL;
bytes_read = g_input_stream_read (image_stream, buf, 256, NULL, &error);
if (bytes_read < 0)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failure reading image file 'alphatest.png': %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_object_unref (image_stream);
image_stream = NULL;
gtk_widget_show (dialog);
load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
if (!gdk_pixbuf_loader_write (pixbuf_loader,
buf, bytes_read,
&error))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load image: %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_object_unref (image_stream);
image_stream = NULL;
gtk_widget_show (dialog);
load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
if (bytes_read == 0)
{
/* Errors can happen on close, e.g. if the image
* file was truncated we'll know on close that
* it was incomplete.
*/
error = NULL;
if (!g_input_stream_close (image_stream, NULL, &error))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load image: %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
g_object_unref (image_stream);
image_stream = NULL;
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
g_object_unref (image_stream);
image_stream = NULL;
/* Errors can happen on close, e.g. if the image
* file was truncated we'll know on close that
* it was incomplete.
*/
error = NULL;
if (!gdk_pixbuf_loader_close (pixbuf_loader,
&error))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load image: %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
}
}
else
{
GError *error = NULL;
image_stream = g_resources_open_stream ("/images/alphatest.png", 0, &error);
if (image_stream == NULL)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
load_timeout = 0;
return FALSE; /* uninstall the timeout */
}
if (pixbuf_loader)
{
gdk_pixbuf_loader_close (pixbuf_loader, NULL);
g_object_unref (pixbuf_loader);
}
pixbuf_loader = gdk_pixbuf_loader_new ();
g_signal_connect (pixbuf_loader, "area-prepared",
G_CALLBACK (progressive_prepared_callback), picture);
g_signal_connect (pixbuf_loader, "area-updated",
G_CALLBACK (progressive_updated_callback), picture);
}
/* leave timeout installed */
return TRUE;
}
static void
render_compact (EABContactFormatter *formatter,
EContact *contact,
GString *buffer)
{
const gchar *str;
gchar *html;
EContactPhoto *photo;
g_string_append (buffer, HTML_HEADER);
g_string_append (buffer,"<body class=\"-e-web-view-background-color -e-web-view-text-color\">");
if (contact == NULL) {
g_string_append (buffer, "</body></html>");
return;
}
g_string_append_printf (
buffer,
"<table><tr><td valign=\"top\">");
photo = e_contact_get (contact, E_CONTACT_PHOTO);
if (photo == NULL)
photo = e_contact_get (contact, E_CONTACT_LOGO);
if (photo != NULL) {
gint calced_width = MAX_COMPACT_IMAGE_DIMENSION;
gint calced_height = MAX_COMPACT_IMAGE_DIMENSION;
GdkPixbufLoader *loader = gdk_pixbuf_loader_new ();
GdkPixbuf *pixbuf;
/* figure out if we need to downscale the
* image here. we don't scale the pixbuf
* itself, just insert width/height tags in
* the html */
if (photo->type == E_CONTACT_PHOTO_TYPE_INLINED) {
gdk_pixbuf_loader_write (
loader, photo->data.inlined.data,
photo->data.inlined.length, NULL);
} else if (photo->type == E_CONTACT_PHOTO_TYPE_URI &&
photo->data.uri &&
g_ascii_strncasecmp (photo->data.uri, "file://", 7) == 0) {
gchar *filename, *contents = NULL;
gsize length;
filename = g_filename_from_uri (photo->data.uri, NULL, NULL);
if (filename) {
if (g_file_get_contents (filename, &contents, &length, NULL)) {
gdk_pixbuf_loader_write (loader, (const guchar *) contents, length, NULL);
g_free (contents);
}
g_free (filename);
}
}
gdk_pixbuf_loader_close (loader, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf)
g_object_ref (pixbuf);
g_object_unref (loader);
if (pixbuf) {
gint max_dimension;
calced_width = gdk_pixbuf_get_width (pixbuf);
calced_height = gdk_pixbuf_get_height (pixbuf);
max_dimension = calced_width;
if (max_dimension < calced_height)
max_dimension = calced_height;
if (max_dimension > MAX_COMPACT_IMAGE_DIMENSION) {
calced_width *= ((gfloat) MAX_COMPACT_IMAGE_DIMENSION / max_dimension);
calced_height *= ((gfloat) MAX_COMPACT_IMAGE_DIMENSION / max_dimension);
}
g_object_unref (pixbuf);
}
if (photo->type == E_CONTACT_PHOTO_TYPE_URI &&
photo->data.uri && *photo->data.uri) {
gboolean is_local = g_str_has_prefix (photo->data.uri, "file://");
const gchar *uri = photo->data.uri;
/* WebKit 2.2.x doesn't re-escape URIs, thus do this for versions before and after this */
#if !(WEBKIT_MAJOR_VERSION == 2 && WEBKIT_MINOR_VERSION == 2)
gchar *unescaped = g_uri_unescape_string (uri, NULL);
uri = unescaped;
#endif
g_string_append_printf (
buffer,
"<img id=\"__evo-contact-photo\" width=\"%d\" height=\"%d\" src=\"%s%s\">",
calced_width, calced_height,
is_local ? "evo-" : "", uri);
#if !(WEBKIT_MAJOR_VERSION == 2 && WEBKIT_MINOR_VERSION == 2)
g_free (unescaped);
#endif
} else {
gchar *photo_data;
photo_data = g_base64_encode (
photo->data.inlined.data,
photo->data.inlined.length);
g_string_append_printf (
buffer,
"<img id=\"__evo-contact-photo\" border=\"1\" src=\"data:%s;base64,%s\" "
"width=\"%d\" height=\"%d\">",
photo->data.inlined.mime_type,
photo_data,
calced_width, calced_height);
g_free (photo_data);
}
e_contact_photo_free (photo);
}
g_string_append (buffer, "</td><td width=\"5\"></td><td valign=\"top\">\n");
str = e_contact_get_const (contact, E_CONTACT_FILE_AS);
if (str) {
html = e_text_to_html (str, 0);
g_string_append_printf (buffer, "<b>%s</b>", html);
g_free (html);
} else {
str = e_contact_get_const (contact, E_CONTACT_FULL_NAME);
if (str) {
html = e_text_to_html (str, 0);
g_string_append_printf (buffer, "<b>%s</b>", html);
g_free (html);
}
}
g_string_append (buffer, "<hr>");
if (e_contact_get (contact, E_CONTACT_IS_LIST)) {
GList *email_list;
GList *l;
g_string_append (
buffer,
"<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">"
"<tr><td valign=\"top\">");
g_string_append_printf (
buffer,
"<b>%s:</b> <td>", _ ("List Members"));
email_list = e_contact_get (contact, E_CONTACT_EMAIL);
for (l = email_list; l; l = l->next) {
if (l->data) {
html = e_text_to_html (l->data, 0);
g_string_append_printf (buffer, "%s, ", html);
g_free (html);
}
}
g_string_append (buffer, "</td></tr></table>");
} else {
gboolean comma = FALSE;
str = e_contact_get_const (contact, E_CONTACT_TITLE);
if (str) {
html = e_text_to_html (str, 0);
g_string_append_printf (buffer, "<b>%s:</b> %s<br>", _ ("Job Title"), str);
g_free (html);
}
#define print_email() { \
html = eab_parse_qp_email_to_html (str); \
\
if (!html) \
html = e_text_to_html (str, 0); \
\
g_string_append_printf (buffer, "%s%s", comma ? ", " : "", html); \
g_free (html); \
comma = TRUE; \
}
g_string_append_printf (buffer, "<b>%s:</b> ", _ ("Email"));
str = e_contact_get_const (contact, E_CONTACT_EMAIL_1);
if (str)
print_email ();
str = e_contact_get_const (contact, E_CONTACT_EMAIL_2);
if (str)
print_email ();
str = e_contact_get_const (contact, E_CONTACT_EMAIL_3);
if (str)
print_email ();
g_string_append (buffer, "<br>");
#undef print_email
str = e_contact_get_const (contact, E_CONTACT_HOMEPAGE_URL);
if (str) {
html = e_text_to_html (str, E_TEXT_TO_HTML_CONVERT_URLS);
g_string_append_printf (
buffer, "<b>%s:</b> %s<br>",
_ ("Home page"), html);
g_free (html);
}
str = e_contact_get_const (contact, E_CONTACT_BLOG_URL);
if (str) {
html = e_text_to_html (str, E_TEXT_TO_HTML_CONVERT_URLS);
g_string_append_printf (
buffer, "<b>%s:</b> %s<br>",
_ ("Blog"), html);
}
}
g_string_append (buffer, "</td></tr></table>\n");
g_string_append (buffer, "</body></html>\n");
}
static GdkPixbuf*
compose_splash(const gchar *version)
{
gint xpos = 224;
gint ypos = 36;
GdkPixbufLoader *loader;
GdkPixbuf *base, *digit;
GError *err = NULL;
guint i;
gchar *p, *filename;
p = gwy_find_self_dir("pixmaps");
filename = g_build_filename(p, "splash.png", NULL);
g_free(p);
base = gdk_pixbuf_new_from_file(filename, &err);
if (!base) {
g_warning("Cannot load base splash image: %s", err->message);
g_clear_error(&err);
sanity_check(filename);
g_free(filename);
return NULL;
}
g_free(filename);
while (*version) {
loader = NULL;
for (i = 0; i < G_N_ELEMENTS(digits); i++) {
if (*version == digits[i].c)
break;
}
if (i == G_N_ELEMENTS(digits)) {
g_warning("Cannot find image for %c", *version);
version++;
continue;
}
loader = gdk_pixbuf_loader_new_with_type("png", &err);
/* We have already successfully loaded base PNG */
g_assert(loader);
if (!gdk_pixbuf_loader_write(loader, digits[i].data, digits[i].len,
&err)) {
g_critical("Cannot load in-line image for %c as PNG", *version);
break;
}
if (!gdk_pixbuf_loader_close(loader, &err)) {
g_critical("Cannot load in-line image for %c as PNG", *version);
break;
}
digit = gdk_pixbuf_loader_get_pixbuf(loader);
g_assert(digit);
gdk_pixbuf_composite(digit, base,
xpos, ypos,
gdk_pixbuf_get_width(digit),
gdk_pixbuf_get_height(digit),
xpos, ypos,
1.0, 1.0,
GDK_INTERP_NEAREST,
255);
xpos += gdk_pixbuf_get_width(digit);
g_object_unref(loader);
version++;
}
return base;
}
cairo_surface_t *
rsvg_cairo_surface_new_from_href (RsvgHandle *handle,
const char *href,
GError **error)
{
guint8 *data;
gsize data_len;
char *mime_type = NULL;
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf = NULL;
int res;
cairo_surface_t *surface;
data = _rsvg_handle_acquire_data (handle, href, &mime_type, &data_len, error);
if (data == NULL)
return NULL;
if (mime_type) {
loader = gdk_pixbuf_loader_new_with_mime_type (mime_type, error);
g_free (mime_type);
} else {
loader = gdk_pixbuf_loader_new ();
}
if (loader == NULL) {
g_free (data);
return NULL;
}
res = gdk_pixbuf_loader_write (loader, data, data_len, error);
g_free (data);
if (!res) {
gdk_pixbuf_loader_close (loader, NULL);
g_object_unref (loader);
return NULL;
}
if (!gdk_pixbuf_loader_close (loader, error)) {
g_object_unref (loader);
return NULL;
}
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (!pixbuf) {
g_object_unref (loader);
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Failed to load image '%s': reason not known, probably a corrupt image file"),
href);
return NULL;
}
surface = rsvg_cairo_surface_from_pixbuf (pixbuf);
g_object_unref (loader);
return surface;
}
