static GdkPixbuf * pixbuf_from_buddy_icon (PurpleBuddyIcon *buddy_icon) { GdkPixbuf *icon; const guchar *data; size_t len; GdkPixbufLoader *loader; data = purple_buddy_icon_get_data (buddy_icon, &len); loader = gdk_pixbuf_loader_new (); gdk_pixbuf_loader_set_size (loader, 48, 48); gdk_pixbuf_loader_write (loader, data, len, NULL); gdk_pixbuf_loader_close (loader, NULL); icon = gdk_pixbuf_loader_get_pixbuf (loader); if (icon) { g_object_ref (icon); } g_object_unref (loader); return icon; }
static void pixbuf_loader_size_prepared_cb (GdkPixbufLoader *loader, int width, int height, gpointer user_data) { ScaleData *scale_data = user_data; scale_data->original_width = width; scale_data->original_height = height; scale_data->loader_width = width; scale_data->loader_height = height; if (scale_data->requested_size == -1) return; if (scale_keeping_ratio (&scale_data->loader_width, &scale_data->loader_height, scale_data->requested_size, scale_data->requested_size, FALSE)) { gdk_pixbuf_loader_set_size (loader, scale_data->loader_width, scale_data->loader_height); } }
/** * on_image_size_prepared: * @pixbuf_loader: #GdkPixbufLoader loading the image * @width: the original width of the image * @height: the original height of the image * @data: pointer to the #Dimensions sructure containing available width and height for the image, * available width or height can be -1 if the dimension is not limited * * Private function. * * Sets the size of the image being loaded to fit the available width and height dimensions, * but never scales up the image beyond its actual size. * Intended to be used as a callback for #GdkPixbufLoader "size-prepared" signal. */ static void on_image_size_prepared (GdkPixbufLoader *pixbuf_loader, gint width, gint height, gpointer data) { Dimensions *available_dimensions = data; int available_width = available_dimensions->width; int available_height = available_dimensions->height; int scaled_width; int scaled_height; int final_width = width; int final_height = height; if (compute_pixbuf_scale (width, height, available_width, available_height, &scaled_width, &scaled_height)) { final_width = scaled_width; final_height = scaled_height; } final_width = (int)((double) final_width * active_scale); final_height = (int)((double) final_height * active_scale); gdk_pixbuf_loader_set_size (pixbuf_loader, final_width, final_height); }
static void size_prepared_exact_cb (GdkPixbufLoader *loader, gint width, gint height, HDImageSize *destination_size) { if (width == destination_size->width && height == destination_size->height) { gdk_pixbuf_loader_set_size (loader, width, height); } else { gdk_pixbuf_loader_set_size (loader, MIN (width, destination_size->width - 1), MIN (height, destination_size->height - 1)); } }
static void contact_photo_size (GdkPixbufLoader *loader, gint width, gint height, gpointer user_data) { /* Max height of GTK_ICON_SIZE_DIALOG */ gint iconwidth, iconheight; gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &iconwidth, &iconheight); gdk_pixbuf_loader_set_size (loader, width / ((gdouble) height / iconheight), iconheight); }
static void on_loader_size_prepared (GdkPixbufLoader *loader, gint width, gint height, gpointer user_data) { AsyncImageData *data = user_data; gdk_pixbuf_loader_set_size (loader, width * data->scale_factor, height * data->scale_factor); }
/** * on_image_size_prepared: * @pixbuf_loader: #GdkPixbufLoader loading the image * @width: the original width of the image * @height: the original height of the image * @data: pointer to the #Dimensions sructure containing available width and height for the image, * available width or height can be -1 if the dimension is not limited * * Private function. * * Sets the size of the image being loaded to fit the available width and height dimensions, * but never scales up the image beyond its actual size. * Intended to be used as a callback for #GdkPixbufLoader "size-prepared" signal. */ static void on_image_size_prepared (GdkPixbufLoader *pixbuf_loader, gint width, gint height, gpointer data) { Dimensions *available_dimensions = data; int available_width = available_dimensions->width; int available_height = available_dimensions->height; int scaled_width; int scaled_height; if (compute_pixbuf_scale (width, height, available_width, available_height, &scaled_width, &scaled_height)) gdk_pixbuf_loader_set_size (pixbuf_loader, scaled_width, scaled_height); }
static void thumbnail_loader_size_prepared (GdkPixbufLoader *loader, int width, int height, ThumbnailLoadArgs *args) { int size = MAX (width, height); args->original_width = width; args->original_height = height; if (args->force_nominal) { args->base_size = size; } else if (args->base_size == 0) { if (args->is_thumbnail) { args->base_size = 128 * NAUTILUS_ICON_SIZE_STANDARD / thumbnail_icon_size; } else { if (size > args->nominal_size * thumbnail_icon_size / NAUTILUS_ICON_SIZE_STANDARD) { args->base_size = size * NAUTILUS_ICON_SIZE_STANDARD / thumbnail_icon_size; } else if (size > NAUTILUS_ICON_SIZE_STANDARD) { args->base_size = args->nominal_size; } else { /* Don't scale up small icons */ args->base_size = NAUTILUS_ICON_SIZE_STANDARD; } } } if (args->base_size != args->nominal_size) { double scale; scale = (double) args->nominal_size / args->base_size; if ((int) (width * scale) > NAUTILUS_ICON_MAXIMUM_SIZE || (int) (height * scale) > NAUTILUS_ICON_MAXIMUM_SIZE) { scale = MIN ((double) NAUTILUS_ICON_MAXIMUM_SIZE / width, (double) NAUTILUS_ICON_MAXIMUM_SIZE / height); } width = MAX (1, floor (width * scale + 0.5)); height = MAX (1, floor (height * scale + 0.5)); gdk_pixbuf_loader_set_size (loader, width, height); } }
static void size_prepared_cb (GdkPixbufLoader *loader, gint width, gint height, gpointer user_data) { gfloat scale; if (max_width_in_bytes < 1 || width <= max_width_in_bytes) { return; } g_debug ("Resizing media art to %d width", max_width_in_bytes); scale = width / (gfloat) max_width_in_bytes; gdk_pixbuf_loader_set_size (loader, (gint) (width / scale), (gint) (height / scale)); }
static void size_prepared_cb (GdkPixbufLoader *loader, int width, int height, gpointer data) { SizePrepareContext *info = data; g_return_if_fail (width > 0 && height > 0); info->input_width = width; info->input_height = height; if (width < info->width && height < info->height) return; if (info->preserve_aspect_ratio && (info->width > 0 || info->height > 0)) { if (info->width < 0) { width = width * (double)info->height/(double)height; height = info->height; } else if (info->height < 0) { height = height * (double)info->width/(double)width; width = info->width; } else if ((double)height * (double)info->width > (double)width * (double)info->height) { width = 0.5 + (double)width * (double)info->height / (double)height; height = info->height; } else { height = 0.5 + (double)height * (double)info->width / (double)width; width = info->width; } } else { if (info->width > 0) width = info->width; if (info->height > 0) height = info->height; } gdk_pixbuf_loader_set_size (loader, width, height); }
static GdkPixbuf* load_background (gchar *image_name, gint width, gint height) { GdkPixbufLoader *loader; gchar *data; gsize length; GdkPixbuf *pixbuf = NULL; GError *error = NULL; if (g_file_get_contents (image_name, &data, &length, NULL)) { loader = gdk_pixbuf_loader_new (); gdk_pixbuf_loader_set_size (loader, width, height); gdk_pixbuf_loader_write (loader, data, length, &error); pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); } return pixbuf; }
static void pixbuf_from_avatar_size_prepared_cb (GdkPixbufLoader *loader, int width, int height, struct SizeData *data) { g_return_if_fail (width > 0 && height > 0); if (data->preserve_aspect_ratio && (data->width > 0 || data->height > 0)) { if (data->width < 0) { width = width * (double) data->height / (gdouble) height; height = data->height; } else if (data->height < 0) { height = height * (double) data->width / (double) width; width = data->width; } else if ((double) height * (double) data->width > (double) width * (double) data->height) { width = 0.5 + (double) width * (double) data->height / (double) height; height = data->height; } else { height = 0.5 + (double) height * (double) data->width / (double) width; width = data->width; } } else { if (data->width > 0) width = data->width; if (data->height > 0) height = data->height; } gdk_pixbuf_loader_set_size (loader, width, height); }
static void pixbuf_loader_size_prepared (GdkPixbufLoader *loader, int width, int height, gpointer desired_size_ptr) { int size, desired_size; float scale; size = MAX (width, height); desired_size = GPOINTER_TO_INT (desired_size_ptr); if (size != desired_size) { scale = (float) desired_size / size; gdk_pixbuf_loader_set_size (loader, floor (scale * width + 0.5), floor (scale * height + 0.5)); } }
static void size_prepared_cb (GdkPixbufLoader *loader, int width, int height, gpointer data) { struct { int width; int height; } *info = data; if ((double)height * (double)info->width > (double)width * (double)info->height) { width = 0.5 + (double)width * (double)info->height / (double)height; height = info->height; } else { height = 0.5 + (double)height * (double)info->width / (double)width; width = info->width; } gdk_pixbuf_loader_set_size (loader, width, height); }
static void cover_thumbnailer_size_prepared (GdkPixbufLoader *loader, gint source_width, gint source_height, TumblerThumbnailFlavor *flavor) { gint dest_width; gint dest_height; gdouble hratio; gdouble wratio; g_return_if_fail (GDK_IS_PIXBUF_LOADER (loader)); g_return_if_fail (TUMBLER_IS_THUMBNAIL_FLAVOR (flavor)); /* get the destination size */ tumbler_thumbnail_flavor_get_size (flavor, &dest_width, &dest_height); if (source_width <= dest_width && source_height <= dest_height) { /* do not scale the image */ dest_width = source_width; dest_height = source_height; } else { /* determine which axis needs to be scaled down more */ wratio = (gdouble) source_width / (gdouble) dest_width; hratio = (gdouble) source_height / (gdouble) dest_height; /* adjust the other axis */ if (hratio > wratio) dest_width = rint (source_width / hratio); else dest_height = rint (source_height / wratio); } gdk_pixbuf_loader_set_size (loader, MAX (dest_width, 1), MAX (dest_height, 1)); }
static void size_prepared_cb (GdkPixbufLoader *loader, gint width, gint height, HDImageSize *size) { HDImageSize image_size = {width, height}; HDImageSize minimum_size; double scale; minimum_size.width = minimum_size.height = MAX (size->width, size->height); scale = get_scale_for_aspect_ratio (&image_size, &minimum_size); /* Do not load images bigger than neccesary */ if (scale < 1) { image_size.width *= scale; image_size.height *= scale; } gdk_pixbuf_loader_set_size (loader, image_size.width, image_size.height); }
GdkPixbuf * eventd_nd_pixbuf_from_data(GVariant *var, gint width, gint height) { GdkPixbuf *pixbuf = NULL; GError *error = NULL; const gchar *mime_type; GVariant *invar; g_variant_get(var, "(m&sm&sv)", &mime_type, NULL, &invar); if ( g_strcmp0(mime_type, "image/x.eventd.pixbuf") == 0 ) { gboolean a; gint b, w, h, s, n; GVariant *data; g_variant_get(invar, "(iiibii@ay)", &w, &h, &s, &a, &b, &n, &data); /* This is the only format gdk-pixbuf can read */ if ( ( b == 8 ) && ( n == ( a ? 4 : 3 ) ) && ( h * s == (gint) g_variant_get_size(data) ) ) return gdk_pixbuf_new_from_data(g_variant_get_data(data), GDK_COLORSPACE_RGB, a, b, w, h, s, _eventd_nd_pixbuf_free_data, data); g_variant_unref(data); goto end; } if ( ! g_variant_is_of_type(invar, G_VARIANT_TYPE_BYTESTRING) ) goto end; GdkPixbufLoader *loader; const guchar *data; gsize length; data = g_variant_get_data(invar); length = g_variant_get_size(invar); if ( mime_type != NULL ) { loader = gdk_pixbuf_loader_new_with_mime_type(mime_type, &error); if ( loader == NULL ) { g_warning("Couldn't create loader for MIME type '%s': %s", mime_type, error->message); goto end; } GdkPixbufFormat *format; if ( ( ( width > 0 ) || ( height > 0 ) ) && ( ( format = gdk_pixbuf_loader_get_format(loader) ) != NULL ) && gdk_pixbuf_format_is_scalable(format) ) gdk_pixbuf_loader_set_size(loader, width, height); } else loader = gdk_pixbuf_loader_new(); if ( ! gdk_pixbuf_loader_write(loader, data, length, &error) ) { g_warning("Couldn't write image data: %s", error->message); goto error; } if ( ! gdk_pixbuf_loader_close(loader, &error) ) { g_warning("Couldn't load image data: %s", error->message); goto error; } pixbuf = g_object_ref(gdk_pixbuf_loader_get_pixbuf(loader)); error: g_object_unref(loader); end: g_variant_unref(invar); g_variant_unref(var); g_clear_error(&error); return pixbuf; }
void size_func (GdkPixbufLoader *loader, gint width, gint height, gpointer data) { gdk_pixbuf_loader_set_size (loader, width*2, height*2); }
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; }
/*! Loads an image from from a byte buffer. Note: If the specified width and/or height does not match the size of the image contained in the byte buffer, some image information will be lost. WARNING: TODO @param iDisplayWidth the width to which the image needs to be scaled. Values are in device units. Setting this to -1 will cause the image not to be scaled. @param iDisplayheight the height to which the image needs to be scaled. Values are in device units. Setting this to -1 will cause the image not to be scaled. @return true if successful, false otherwise */ bool GR_UnixImage::convertFromBuffer(const UT_ByteBuf* pBB, const std::string & /*mimetype */, UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight) { // assert no image loaded yet UT_ASSERT(!m_image); bool forceScale = (iDisplayWidth != -1 && iDisplayHeight != -1); GError * err = 0; GdkPixbufLoader * ldr = gdk_pixbuf_loader_new (); if (!ldr) { UT_DEBUGMSG (("GdkPixbuf: couldn't create loader! WTF?\n")); UT_ASSERT (ldr); return false; } if (forceScale) { setDisplaySize(iDisplayWidth, iDisplayHeight); gdk_pixbuf_loader_set_size(ldr, iDisplayWidth, iDisplayHeight); } if ( !gdk_pixbuf_loader_write (ldr, static_cast<const guchar *>(pBB->getPointer (0)),static_cast<gsize>(pBB->getLength ()), &err) ) { if(err != NULL) { 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)); return false; } if ( !gdk_pixbuf_loader_close (ldr, &err) ) { if(err != NULL) { UT_DEBUGMSG(("DOM: couldn't close loader:%s \n", err->message)); g_error_free(err); } g_object_unref(G_OBJECT(ldr)); return false; } // // This is just pointer to the buffer in the loader. This can be deleted // when we close the loader. // m_image = gdk_pixbuf_loader_get_pixbuf (ldr); if (!m_image) { UT_DEBUGMSG (("GdkPixbuf: couldn't get image from loader!\n")); gdk_pixbuf_loader_close (ldr, NULL); g_object_unref(G_OBJECT(ldr)); return false; } G_IS_OBJECT(G_OBJECT(m_image)); // // Have to put a reference on it to prevent it being deleted during the close. // g_object_ref(G_OBJECT(m_image)); if ( FALSE == gdk_pixbuf_loader_close (ldr, &err) ) { UT_DEBUGMSG(("DOM: error closing loader. Corrupt image: %s\n", err->message)); g_error_free(err); g_object_unref(G_OBJECT(m_image)); return false; } g_object_unref(G_OBJECT(ldr)); // // Adjust the reference count so it's always 1. Unfortunately // the reference count after the close is undefined. // while(G_OBJECT(m_image)->ref_count > 1) { g_object_unref(G_OBJECT(m_image)); } UT_ASSERT(G_OBJECT(m_image)->ref_count == 1); // if gdk_pixbuf_loader_set_size was not able to scale the image, then do it manually if (forceScale && (iDisplayWidth != gdk_pixbuf_get_width (m_image) || iDisplayHeight != gdk_pixbuf_get_height(m_image))) scale (iDisplayWidth, iDisplayHeight); UT_ASSERT(G_OBJECT(m_image)->ref_count == 1); return true; }
GdkPixbuf * my_new_from_file_at_size (const char *filename, int width, int height, GError **error) { GdkPixbufLoader *loader; GdkPixbuf *pixbuf; struct { int width; int height; } info; struct stat st; guchar buffer [4096]; int length; FILE *f; g_return_val_if_fail (filename != NULL, NULL); g_return_val_if_fail (width > 0 && height > 0, NULL); if (g_stat (filename, &st) != 0) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not get information for file '%s': %s"), filename, g_strerror (errno)); return NULL; } if (!S_ISREG (st.st_mode)) return NULL; f = g_fopen (filename, "rb"); if (!f) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Failed to open file '%s': %s"), filename, g_strerror (errno)); return NULL; } loader = gdk_pixbuf_loader_new (); #ifdef DONT_PRESERVE_ASPECT gdk_pixbuf_loader_set_size (loader, width, height); #else info.width = width; info.height = height; g_signal_connect (loader, "size-prepared", G_CALLBACK (&size_prepared_cb), &info); #endif while (!feof (f)) { length = fread (buffer, 1, sizeof (buffer), f); if (length > 0) if (!gdk_pixbuf_loader_write (loader, buffer, length, error)) { gdk_pixbuf_loader_close (loader, NULL); fclose (f); g_object_unref (G_OBJECT (loader)); return NULL; } } fclose (f); if (!gdk_pixbuf_loader_close (loader, error)) { g_object_unref (G_OBJECT (loader)); return NULL; } pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (!pixbuf) { g_object_unref (G_OBJECT (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"), filename); return NULL; } g_object_ref (pixbuf); g_object_unref (G_OBJECT (loader)); return pixbuf; }
static VALUE loader_set_size(VALUE self, VALUE width, VALUE height) { gdk_pixbuf_loader_set_size(_SELF(self), NUM2INT(width), NUM2INT(height)); return self; }