static GdkPixbuf * ev_document_misc_render_thumbnail_frame (GtkWidget *widget, int width, int height, gboolean inverted_colors, GdkPixbuf *source_pixbuf) { GtkStyleContext *context = gtk_widget_get_style_context (widget); GtkStateFlags state = gtk_widget_get_state_flags (widget); int width_r, height_r; int width_f, height_f; cairo_surface_t *surface; cairo_t *cr; GtkBorder border = {0, }; GdkPixbuf *retval; if (source_pixbuf) { g_return_val_if_fail (GDK_IS_PIXBUF (source_pixbuf), NULL); width_r = gdk_pixbuf_get_width (source_pixbuf); height_r = gdk_pixbuf_get_height (source_pixbuf); } else { width_r = width; height_r = height; } gtk_style_context_save (context); gtk_style_context_add_class (context, "page-thumbnail"); if (inverted_colors) gtk_style_context_add_class (context, "inverted"); gtk_style_context_get_border (context, state, &border); width_f = width_r + border.left + border.right; height_f = height_r + border.top + border.bottom; surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width_f, height_f); cr = cairo_create (surface); if (source_pixbuf) { gdk_cairo_set_source_pixbuf (cr, source_pixbuf, border.left, border.top); cairo_paint (cr); } else { gtk_render_background (context, cr, 0, 0, width_f, height_f); } gtk_render_frame (context, cr, 0, 0, width_f, height_f); cairo_destroy (cr); gtk_style_context_restore (context); retval = gdk_pixbuf_get_from_surface (surface, 0, 0, width_f, height_f); cairo_surface_destroy (surface); return retval; }
/** * gimp_thumbnail_save_thumb_local: * @thumbnail: a #GimpThumbnail object * @pixbuf: a #GdkPixbuf representing the preview thumbnail * @software: a string describing the software saving the thumbnail * @error: return location for possible errors * * Saves a preview thumbnail for the image associated with @thumbnail * to the local thumbnail repository. Local thumbnails have been added * with version 0.7 of the spec. * * Please see also gimp_thumbnail_save_thumb(). The notes made there * apply here as well. * * Return value: %TRUE if a thumbnail was successfully written, * %FALSE otherwise * * Since: 2.2 **/ gboolean gimp_thumbnail_save_thumb_local (GimpThumbnail *thumbnail, GdkPixbuf *pixbuf, const gchar *software, GError **error) { GimpThumbSize size; gchar *name; gchar *filename; gchar *dirname; gboolean success; g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE); g_return_val_if_fail (thumbnail->image_uri != NULL, FALSE); g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE); g_return_val_if_fail (software != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); GIMP_THUMB_DEBUG_CALL (thumbnail); size = MAX (gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf)); if (size < 1) return TRUE; filename = _gimp_thumb_filename_from_uri (thumbnail->image_uri); if (! filename) return TRUE; dirname = g_path_get_dirname (filename); g_free (filename); name = gimp_thumb_name_from_uri_local (thumbnail->image_uri, size); if (! name) { g_free (dirname); return TRUE; } if (! gimp_thumb_ensure_thumb_dir_local (dirname, size, error)) { g_free (name); g_free (dirname); return FALSE; } g_free (dirname); success = gimp_thumbnail_save (thumbnail, size, name, pixbuf, software, error); g_free (name); return success; }
/** * gdl_dock_object_set_pixbuf: * @object: a #GdlDockObject * @icon: (allow-none): a icon or %NULL * * Set a icon for a dock object using a #GdkPixbuf. * * Since: 3.6 */ void gdl_dock_object_set_pixbuf (GdlDockObject *object, GdkPixbuf *icon) { g_return_if_fail (GDL_IS_DOCK_OBJECT (object)); g_return_if_fail (icon == NULL || GDK_IS_PIXBUF (icon)); object->priv->pixbuf_icon =icon; g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_PIXBUF_ICON]); }
void zbar_gtk_release_pixbuf (zbar_image_t *img) { GdkPixbuf *pixbuf = zbar_image_get_userdata(img); g_assert(GDK_IS_PIXBUF(pixbuf)); /* remove reference */ zbar_image_set_userdata(img, NULL); /* release reference to associated pixbuf and it's data */ g_object_unref(pixbuf); }
/** * gwy_gl_material_sample_to_pixbuf: * @gl_material: A GL material to sample. * @pixbuf: A pixbuf to sample gl_material to (in horizontal direction). * * Samples GL material to a provided pixbuf. **/ void gwy_gl_material_sample_to_pixbuf(GwyGLMaterial *gl_material, GdkPixbuf *pixbuf) { GwyGLMaterial *glm = gl_material; gint width, height, rowstride, i, j, bpp; gboolean has_alpha; guchar *row, *pdata; guchar alpha; gdouble p, q; g_return_if_fail(GWY_IS_GL_MATERIAL(gl_material)); g_return_if_fail(GDK_IS_PIXBUF(pixbuf)); width = gdk_pixbuf_get_width(pixbuf); height = gdk_pixbuf_get_height(pixbuf); rowstride = gdk_pixbuf_get_rowstride(pixbuf); has_alpha = gdk_pixbuf_get_has_alpha(pixbuf); pdata = gdk_pixbuf_get_pixels(pixbuf); bpp = 3 + (has_alpha ? 1 : 0); q = (width == 1) ? 0.0 : 1.0/(width - 1.0); p = (height == 1) ? 0.0 : 1.0/(height - 1.0); alpha = (guchar)CLAMP(MAX_CVAL*glm->ambient.a, 0.0, 255.0); for (j = 0; j < width; j++) { gdouble VRp = j*q*(2.0 - j*q); gdouble s = pow(VRp, 128.0*glm->shininess); GwyRGBA s0; s0.r = glm->emission.r + 0.3*glm->ambient.r + glm->specular.r*s; s0.g = glm->emission.g + 0.3*glm->ambient.g + glm->specular.g*s; s0.b = glm->emission.b + 0.3*glm->ambient.b + glm->specular.b*s; for (i = 0; i < height; i++) { gdouble LNp = 1.0 - i*p; gdouble v; row = pdata + i*rowstride + j*bpp; v = s0.r + glm->diffuse.r*LNp; *(row++) = (guchar)CLAMP(MAX_CVAL*v, 0.0, 255.0); v = s0.g + glm->diffuse.g*LNp; *(row++) = (guchar)CLAMP(MAX_CVAL*v, 0.0, 255.0); v = s0.b + glm->diffuse.b*LNp; *(row++) = (guchar)CLAMP(MAX_CVAL*v, 0.0, 255.0); if (has_alpha) *(row++) = alpha; } } }
/** * gdk_pixbuf_fill: * @pixbuf: a #GdkPixbuf * @pixel: RGBA pixel to clear to * (0xffffffff is opaque white, 0x00000000 transparent black) * * Clears a pixbuf to the given RGBA value, converting the RGBA value into * the pixbuf's pixel format. The alpha will be ignored if the pixbuf * doesn't have an alpha channel. * **/ void gdk_pixbuf_fill (GdkPixbuf *pixbuf, guint32 pixel) { guchar *pixels; guint r, g, b, a; guchar *p; guint w, h; g_return_if_fail (GDK_IS_PIXBUF (pixbuf)); g_return_if_fail (pixbuf->pixels || pixbuf->bytes); if (pixbuf->width == 0 || pixbuf->height == 0) return; /* Force an implicit copy */ pixels = gdk_pixbuf_get_pixels (pixbuf); r = (pixel & 0xff000000) >> 24; g = (pixel & 0x00ff0000) >> 16; b = (pixel & 0x0000ff00) >> 8; a = (pixel & 0x000000ff); h = pixbuf->height; while (h--) { w = pixbuf->width; p = pixels; switch (pixbuf->n_channels) { case 3: while (w--) { p[0] = r; p[1] = g; p[2] = b; p += 3; } break; case 4: while (w--) { p[0] = r; p[1] = g; p[2] = b; p[3] = a; p += 4; } break; default: break; } pixels += pixbuf->rowstride; } }
/** * gdk_pixbuf_remove_option: * @pixbuf: a #GdkPixbuf * @key: a nul-terminated string representing the key to remove. * * Remove the key/value pair option attached to a #GdkPixbuf. * * Return value: %TRUE if an option was removed, %FALSE if not. * * Since: 2.36 **/ gboolean gdk_pixbuf_remove_option (GdkPixbuf *pixbuf, const gchar *key) { GQuark quark; gchar **options; guint n; GPtrArray *array; gboolean found; g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE); g_return_val_if_fail (key != NULL, FALSE); quark = g_quark_from_static_string ("gdk_pixbuf_options"); options = g_object_get_qdata (G_OBJECT (pixbuf), quark); if (!options) return FALSE; g_object_steal_qdata (G_OBJECT (pixbuf), quark); /* There's at least a nul-terminator */ array = g_ptr_array_new_full (1, g_free); found = FALSE; for (n = 0; options[2*n]; n++) { if (strcmp (options[2*n], key) != 0) { g_ptr_array_add (array, g_strdup (options[2*n])); /* key */ g_ptr_array_add (array, g_strdup (options[2*n+1])); /* value */ } else { found = TRUE; } } if (array->len == 0) { g_ptr_array_unref (array); g_strfreev (options); return found; } if (!found) { g_ptr_array_free (array, TRUE); g_object_set_qdata_full (G_OBJECT (pixbuf), quark, options, (GDestroyNotify) g_strfreev); return FALSE; } g_ptr_array_add (array, NULL); g_object_set_qdata_full (G_OBJECT (pixbuf), quark, g_ptr_array_free (array, FALSE), (GDestroyNotify) g_strfreev); g_strfreev (options); return TRUE; }
/** * Adds an image to the current clip. * TODO: should be moved out of here, to application. */ void Pipeline::grab_frame() { GdkPixbuf* pixbuf; g_object_get(G_OBJECT(gdkpixbufsink_), "last-pixbuf", &pixbuf, NULL); if (! GDK_IS_PIXBUF(pixbuf)) { std::cout << "No picture yet to grab!" << std::endl; } else { save_image_to_current_clip(pixbuf); } g_object_unref(pixbuf); }
/** * gdk_pixbuf_read_pixel_bytes: * @pixbuf: A pixbuf * * Returns: (transfer full): A new reference to a read-only copy of * the pixel data. Note that for mutable pixbufs, this function will * incur a one-time copy of the pixel data for conversion into the * returned #GBytes. * * Since: 2.32 */ GBytes * gdk_pixbuf_read_pixel_bytes (const GdkPixbuf *pixbuf) { g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); if (pixbuf->bytes) { return g_bytes_ref (pixbuf->bytes); } else { return g_bytes_new (pixbuf->pixels, gdk_pixbuf_get_byte_length (pixbuf)); } }
void moko_contacts_get_photo (MokoContacts *contacts, MokoContact *m_contact) { MokoContactsPrivate *priv; EContact *e_contact; EContactPhoto *photo; GError *err = NULL; GdkPixbufLoader *loader; g_return_if_fail (MOKO_IS_CONTACTS (contacts)); g_return_if_fail (m_contact); priv = contacts->priv; if (!e_book_get_contact (priv->book, m_contact->uid, &e_contact, &err)) { g_warning ("%s\n", err->message); m_contact->photo = gdk_pixbuf_new_from_file (PKGDATADIR"/person.png", NULL); if (m_contact->photo) g_object_ref (m_contact->photo); return; } photo = e_contact_get (e_contact, E_CONTACT_PHOTO); if (!photo) { m_contact->photo = gdk_pixbuf_new_from_file (PKGDATADIR"/person.png", NULL); if (m_contact->photo) g_object_ref (m_contact->photo); return; } loader = gdk_pixbuf_loader_new (); gdk_pixbuf_loader_write (loader, photo->data.inlined.data, photo->data.inlined.length, NULL); gdk_pixbuf_loader_close (loader, NULL); m_contact->photo = gdk_pixbuf_loader_get_pixbuf (loader); if (GDK_IS_PIXBUF (m_contact->photo)) g_object_ref (m_contact->photo); else { m_contact->photo = gdk_pixbuf_new_from_file (PKGDATADIR"/person.png", NULL); if (m_contact->photo) g_object_ref (m_contact->photo); } g_object_unref (loader); e_contact_photo_free (photo); }
/** * gtk_selection_data_set_pixbuf: * @selection_data: a #GtkSelectionData * @pixbuf: a #GdkPixbuf * * Sets the contents of the selection from a #GdkPixbuf * The pixbuf is converted to the form determined by * @selection_data->target. * * Returns: %TRUE if the selection was successfully set, * otherwise %FALSE. **/ gboolean gtk_selection_data_set_pixbuf (GtkSelectionData *selection_data, GdkPixbuf *pixbuf) { GSList *formats, *f; gchar **mimes, **m; GdkAtom atom; gboolean result; gchar *str, *type; gsize len; g_return_val_if_fail (selection_data != NULL, FALSE); g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE); formats = gdk_pixbuf_get_formats (); for (f = formats; f; f = f->next) { GdkPixbufFormat *fmt = f->data; mimes = gdk_pixbuf_format_get_mime_types (fmt); for (m = mimes; *m; m++) { atom = g_intern_string (*m); if (selection_data->target == atom) { str = NULL; type = gdk_pixbuf_format_get_name (fmt); result = gdk_pixbuf_save_to_buffer (pixbuf, &str, &len, type, NULL, ((strcmp (type, "png") == 0) ? "compression" : NULL), "2", NULL); if (result) gtk_selection_data_set (selection_data, atom, 8, (guchar *)str, len); g_free (type); g_free (str); g_strfreev (mimes); g_slist_free (formats); return result; } } g_strfreev (mimes); } g_slist_free (formats); return FALSE; }
/** * gdk_pixbuf_read_pixels: * @pixbuf: A pixbuf * * Returns a read-only pointer to the raw pixel data; must not be * modified. This function allows skipping the implicit copy that * must be made if gdk_pixbuf_get_pixels() is called on a read-only * pixbuf. * * Since: 2.32 */ const guint8* gdk_pixbuf_read_pixels (const GdkPixbuf *pixbuf) { g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); if (pixbuf->bytes) { gsize len; /* Ignore len; callers know the size via other variables */ return g_bytes_get_data (pixbuf->bytes, &len); } else { return pixbuf->pixels; } }
void HudIconTextureSource::ColorForIcon(GdkPixbuf* pixbuf) { if (GDK_IS_PIXBUF(pixbuf)) { unsigned int width = gdk_pixbuf_get_width(pixbuf); unsigned int height = gdk_pixbuf_get_height(pixbuf); unsigned int row_bytes = gdk_pixbuf_get_rowstride(pixbuf); long int rtotal = 0, gtotal = 0, btotal = 0; float total = 0.0f; guchar* img = gdk_pixbuf_get_pixels(pixbuf); for (unsigned int i = 0; i < width; i++) { for (unsigned int j = 0; j < height; j++) { guchar* pixels = img + (j * row_bytes + i * 4); guchar r = *(pixels + 0); guchar g = *(pixels + 1); guchar b = *(pixels + 2); guchar a = *(pixels + 3); float saturation = (MAX(r, MAX(g, b)) - MIN(r, MIN(g, b))) / 255.0f; float relevance = .1 + .9 * (a / 255.0f) * saturation; rtotal += (guchar)(r * relevance); gtotal += (guchar)(g * relevance); btotal += (guchar)(b * relevance); total += relevance * 255; } } nux::color::RedGreenBlue rgb(rtotal / total, gtotal / total, btotal / total); nux::color::HueSaturationValue hsv(rgb); if (hsv.saturation > 0.15f) hsv.saturation = 0.65f; hsv.value = 0.90f; bg_color = nux::Color(nux::color::RedGreenBlue(hsv)); } else { LOG_ERROR(logger) << "Pixbuf (" << pixbuf << ") passed is non valid"; bg_color = nux::Color(255,255,255,255); } }
static void astro_contact_row_set_icon (AstroContactRow *row, GdkPixbuf *icon) { AstroContactRowPrivate *priv; g_return_if_fail (ASTRO_IS_CONTACT_ROW (row)); g_return_if_fail (GDK_IS_PIXBUF (icon)); priv = row->priv; priv->icon = icon; g_object_set (G_OBJECT (priv->texture), "pixbuf", icon, NULL); clutter_actor_set_size (priv->texture, ICON_SIZE, ICON_SIZE); }
/** * gdk_pixbuf_get_pixels_with_length: (rename-to gdk_pixbuf_get_pixels) * @pixbuf: A pixbuf. * @length: (out): The length of the binary data. * * Queries a pointer to the pixel data of a pixbuf. * * Return value: (array length=length): A pointer to the pixbuf's * pixel data. Please see the section on [image data][image-data] * for information about how the pixel data is stored in memory. * * This function will cause an implicit copy of the pixbuf data if the * pixbuf was created from read-only data. * * Since: 2.26 */ guchar * gdk_pixbuf_get_pixels_with_length (const GdkPixbuf *pixbuf, guint *length) { g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); downgrade_to_pixels (pixbuf); g_assert (pixbuf->storage == STORAGE_PIXELS); if (length) *length = gdk_pixbuf_get_byte_length (pixbuf); return pixbuf->s.pixels.pixels; }
static void gx_knob_size_request (GtkWidget *widget, GtkRequisition *requisition) { g_assert(GX_IS_KNOB(widget)); GdkPixbuf *pb = gtk_widget_render_icon(widget, get_stock_id(widget), GtkIconSize(-1), NULL); if (GDK_IS_PIXBUF (pb)) { gint fcount; GdkRectangle rect; get_image_dimensions (widget, pb, &rect, &fcount); requisition->width = rect.width; requisition->height = rect.height; _gx_regler_calc_size_request(GX_REGLER(widget), requisition); g_object_unref(pb); } }
/** * gdk_pixbuf_composite: * @src: a #GdkPixbuf * @dest: the #GdkPixbuf into which to render the results * @dest_x: the left coordinate for region to render * @dest_y: the top coordinate for region to render * @dest_width: the width of the region to render * @dest_height: the height of the region to render * @offset_x: the offset in the X direction (currently rounded to an integer) * @offset_y: the offset in the Y direction (currently rounded to an integer) * @scale_x: the scale factor in the X direction * @scale_y: the scale factor in the Y direction * @interp_type: the interpolation type for the transformation. * @overall_alpha: overall alpha for source image (0..255) * * Creates a transformation of the source image @src by scaling by * @scale_x and @scale_y then translating by @offset_x and @offset_y. * This gives an image in the coordinates of the destination pixbuf. * The rectangle (@dest_x, @dest_y, @dest_width, @dest_height) * is then composited onto the corresponding rectangle of the * original destination image. * * When the destination rectangle contains parts not in the source * image, the data at the edges of the source image is replicated * to infinity. * * ![](composite.png) */ void gdk_pixbuf_composite (const GdkPixbuf *src, GdkPixbuf *dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, GdkInterpType interp_type, int overall_alpha) { const guint8 *src_pixels; guint8 *dest_pixels; g_return_if_fail (GDK_IS_PIXBUF (src)); g_return_if_fail (GDK_IS_PIXBUF (dest)); g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width); g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height); g_return_if_fail (overall_alpha >= 0 && overall_alpha <= 255); offset_x = floor (offset_x + 0.5); offset_y = floor (offset_y + 0.5); /* Force an implicit copy */ dest_pixels = gdk_pixbuf_get_pixels (dest); src_pixels = gdk_pixbuf_read_pixels (src); _pixops_composite (dest_pixels, dest->width, dest->height, dest->rowstride, dest->n_channels, dest->has_alpha, src_pixels, src->width, src->height, src->rowstride, src->n_channels, src->has_alpha, dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, (PixopsInterpType)interp_type, overall_alpha); }
void moko_talking_outgoing_call (MokoTalking *talking, const gchar *number, MokoContactEntry *entry) { MokoTalkingPrivate *priv; gchar *markup = NULL; moko_talking_reset_ui (talking); g_return_if_fail (MOKO_IS_TALKING (talking)); priv = talking->priv; gtk_widget_hide (priv->incoming_bar); gtk_widget_show_all (priv->main_bar); if ( HEADSET_STATUS_IN == moko_headset_status_get() ) moko_sound_profile_set(SOUND_PROFILE_GSM_HEADSET); else moko_sound_profile_set(SOUND_PROFILE_GSM_HANDSET); if (entry) markup = g_strdup_printf ("<b>%s</b>\n%s", entry->contact->name, number); else markup = g_strdup (number); gtk_window_set_title (GTK_WINDOW (priv->window), "Dialing"); gtk_label_set_text (GTK_LABEL (priv->title), "Outgoing Call"); gtk_label_set_text (GTK_LABEL (priv->duration), ""); gtk_label_set_markup (GTK_LABEL (priv->status), markup); if (entry && GDK_IS_PIXBUF (entry->contact->photo)) gtk_image_set_from_pixbuf (GTK_IMAGE (priv->person), entry->contact->photo); else gtk_image_set_from_file (GTK_IMAGE (priv->person), PKGDATADIR"/unknown.png"); if (priv->timeout) g_source_remove (priv->timeout); priv->timeout = g_timeout_add (1000, (GSourceFunc)outgoing_timeout, (gpointer)talking); g_free (markup); priv->call_direction = CALL_DIRECTION_OUTGOING; gtk_window_present (GTK_WINDOW (priv->window)); gtk_window_deiconify (GTK_WINDOW (priv->window)); }
/** * photos_print_preview_new_with_pixbuf: * @pixbuf: a #GdkPixbuf * * Creates a new #PhotosPrintPreview widget, and sets the #GdkPixbuf to preview * on it. * * Returns: A new #PhotosPrintPreview widget. **/ GtkWidget * photos_print_preview_new_with_pixbuf (GdkPixbuf *pixbuf) { PhotosPrintPreview *preview; g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); preview = PHOTOS_PRINT_PREVIEW (photos_print_preview_new ()); preview->priv->pixbuf = g_object_ref (pixbuf); update_relative_sizes (preview); return GTK_WIDGET (preview); }
/** * gimp_pixbuf_get_format: * @pixbuf: a #GdkPixbuf * * Returns the Babl format that corresponds to the @pixbuf's pixel format. * * Return value: the @pixbuf's pixel format * * Since: GIMP 2.10 **/ const Babl * gimp_pixbuf_get_format (GdkPixbuf *pixbuf) { g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); switch (gdk_pixbuf_get_n_channels (pixbuf)) { case 3: return babl_format ("R'G'B' u8"); case 4: return babl_format ("R'G'B'A u8"); } g_return_val_if_reached (NULL); }
GtkCssImage * _gtk_css_image_surface_new_for_pixbuf (GdkPixbuf *pixbuf) { GtkCssImage *image; cairo_surface_t *surface; g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL); image = _gtk_css_image_surface_new (surface); cairo_surface_destroy (surface); return image; }
/** * xfce_panel_image_set_from_pixbuf: * @image : an #XfcePanelImage. * @pixbuf : a #GdkPixbuf, or %NULL. * * See xfce_panel_image_new_from_pixbuf() for details. * * Since: 4.8 **/ void xfce_panel_image_set_from_pixbuf (XfcePanelImage *image, GdkPixbuf *pixbuf) { g_return_if_fail (XFCE_IS_PANEL_IMAGE (image)); g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf)); xfce_panel_image_clear (image); /* set the new pixbuf, scale it to the maximum size if needed */ image->priv->pixbuf = xfce_panel_image_scale_pixbuf (pixbuf, MAX_PIXBUF_SIZE, MAX_PIXBUF_SIZE); gtk_widget_queue_resize (GTK_WIDGET (image)); }
/** * eom_print_preview_new_with_pixbuf: * @pixbuf: a #GdkPixbuf * * Creates a new #EomPrintPreview widget, and sets the #GdkPixbuf to preview * on it. * * Returns: A new #EomPrintPreview widget. **/ GtkWidget * eom_print_preview_new_with_pixbuf (GdkPixbuf *pixbuf) { EomPrintPreview *preview; g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); preview = EOM_PRINT_PREVIEW (eom_print_preview_new ()); preview->priv->image = g_object_ref (pixbuf); update_relative_sizes (preview); return GTK_WIDGET (preview); }
/** * gtk_tooltip_set_icon: * @tooltip: a #GtkTooltip * @pixbuf: (allow-none): a #GdkPixbuf, or %NULL * * Sets the icon of the tooltip (which is in front of the text) to be * @pixbuf. If @pixbuf is %NULL, the image will be hidden. * * Since: 2.12 */ void gtk_tooltip_set_icon (GtkTooltip *tooltip, GdkPixbuf *pixbuf) { g_return_if_fail (GTK_IS_TOOLTIP (tooltip)); if (pixbuf) g_return_if_fail (GDK_IS_PIXBUF (pixbuf)); gtk_image_set_from_pixbuf (GTK_IMAGE (tooltip->image), pixbuf); if (pixbuf) gtk_widget_show (tooltip->image); else gtk_widget_hide (tooltip->image); }
static gboolean gx_knob_expose(GtkWidget *widget, GdkEventExpose *event) { g_assert(GX_IS_KNOB(widget)); GdkRectangle image_rect, value_rect; GdkPixbuf *pb = gtk_widget_render_icon(widget, get_stock_id(widget), GtkIconSize(-1), NULL); if (GDK_IS_PIXBUF (pb)) { gint fcount; get_image_dimensions (widget, pb, &image_rect, &fcount); gdouble knobstate = _gx_regler_get_step_pos(GX_REGLER(widget), 1); _gx_regler_get_positions(GX_REGLER(widget), &image_rect, &value_rect); _gx_knob_expose(widget, &image_rect, knobstate, pb, fcount, gtk_widget_has_focus(widget)); _gx_regler_display_value(GX_REGLER(widget), &value_rect); g_object_unref(pb); } return FALSE; }
int clip_GTK_DRAGSOURCESETICONPIXBUF(ClipMachine * cm) { C_widget *cwid = _fetch_cw_arg(cm); C_object *cpixbuf = _fetch_cobject(cm, _clip_spar(cm, 2)); CHECKCWID(cwid, GTK_IS_WIDGET); CHECKCOBJ(cpixbuf, GDK_IS_PIXBUF(cpixbuf->object)); gtk_drag_source_set_icon_pixbuf(GTK_WIDGET(cwid->widget), GDK_PIXBUF(cpixbuf->object)); return 0; err: return 1; }
static void on_window_icon_changed (WnckWindow *window, TaskItem *item) { TaskItemPrivate *priv; g_return_if_fail (TASK_IS_ITEM (item)); priv = item->priv; if (GDK_IS_PIXBUF (priv->pixbuf)) { g_object_unref (priv->pixbuf); priv->pixbuf = NULL; } gtk_widget_queue_draw (GTK_WIDGET (item)); }
void empathy_smiley_manager_add_from_pixbuf (EmpathySmileyManager *manager, GdkPixbuf *smiley, const gchar *first_str, ...) { va_list var_args; g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager)); g_return_if_fail (GDK_IS_PIXBUF (smiley)); g_return_if_fail (!G_STR_EMPTY (first_str)); va_start (var_args, first_str); smiley_manager_add_valist (manager, smiley, first_str, var_args); va_end (var_args); }
/** * gimp_layer_new_from_pixbuf: * @pixbuf: The pixbuf to make the new layer from. * @dest_image: The image the new layer will be added to. * @format: The #Babl format of the new layer. * @name: The new layer's name. * @opacity: The new layer's opacity. * @mode: The new layer's mode. * * Copies %pixbuf to a layer taking into consideration the * possibility of transforming the contents to meet the requirements * of the target image type * * Return value: The new layer. **/ GimpLayer * gimp_layer_new_from_pixbuf (GdkPixbuf *pixbuf, GimpImage *dest_image, const Babl *format, const gchar *name, gdouble opacity, GimpLayerModeEffects mode) { GimpLayer *layer; GeglBuffer *buffer; guint8 *icc_data; gsize icc_len; GimpColorProfile *profile = NULL; g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL); g_return_val_if_fail (format != NULL, NULL); layer = gimp_layer_new (dest_image, gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), format, name, opacity, mode); buffer = gimp_pixbuf_create_buffer (pixbuf); icc_data = gimp_pixbuf_get_icc_profile (pixbuf, &icc_len); if (icc_data) { profile = gimp_color_profile_new_from_icc_profile (icc_data, icc_len, NULL); g_free (icc_data); } if (! profile && gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB) { profile = gimp_color_profile_new_srgb (); } gimp_layer_new_convert_buffer (layer, buffer, profile, NULL); if (profile) g_object_unref (profile); g_object_unref (buffer); return layer; }
/** * gdk_pixbuf_flip: * @src: a #GdkPixbuf * @horizontal: %TRUE to flip horizontally, %FALSE to flip vertically * * Flips a pixbuf horizontally or vertically and returns the * result in a new pixbuf. * * Returns: (nullable) (transfer full): the new #GdkPixbuf, or %NULL * if not enough memory could be allocated for it. * * Since: 2.6 */ GdkPixbuf * gdk_pixbuf_flip (const GdkPixbuf *src, gboolean horizontal) { const guint8 *src_pixels; guint8 *dest_pixels; GdkPixbuf *dest; const guchar *p; guchar *q; gint x, y; g_return_val_if_fail (GDK_IS_PIXBUF (src), NULL); dest = gdk_pixbuf_new (src->colorspace, src->has_alpha, src->bits_per_sample, src->width, src->height); if (!dest) return NULL; dest_pixels = gdk_pixbuf_get_pixels (dest); src_pixels = gdk_pixbuf_read_pixels (src); if (!horizontal) /* flip vertical */ { for (y = 0; y < dest->height; y++) { p = src_pixels + OFFSET (src, 0, y); q = dest_pixels + OFFSET (dest, 0, dest->height - y - 1); memcpy (q, p, dest->rowstride); } } else /* flip horizontal */ { for (y = 0; y < dest->height; y++) { for (x = 0; x < dest->width; x++) { p = src_pixels + OFFSET (src, x, y); q = dest_pixels + OFFSET (dest, dest->width - x - 1, y); memcpy (q, p, dest->n_channels); } } } return dest; }