static void register_stock_icon_bidi (GtkIconFactory * icon_factory, const char * stock_id, const char * icon_name_ltr, const char * icon_name_rtl) { GtkIconSource *source; GtkIconSet *set; set = gtk_icon_set_new (); source = gtk_icon_source_new (); gtk_icon_source_set_icon_name (source, icon_name_ltr); gtk_icon_source_set_direction (source, GTK_TEXT_DIR_LTR); gtk_icon_source_set_direction_wildcarded (source, FALSE); gtk_icon_set_add_source (set, source); gtk_icon_source_free (source); source = gtk_icon_source_new (); gtk_icon_source_set_icon_name (source, icon_name_rtl); gtk_icon_source_set_direction (source, GTK_TEXT_DIR_RTL); gtk_icon_source_set_direction_wildcarded (source, FALSE); gtk_icon_set_add_source (set, source); gtk_icon_source_free (source); gtk_icon_factory_add (icon_factory, stock_id, set); gtk_icon_set_unref (set); }
static void add_sized_icon(GtkIconSet *iconset, GtkIconSize sizeid, PidginIconTheme *theme, const char *size, SizedStockIcon sized_icon, gboolean translucent) { char *filename; GtkIconSource *source; GdkPixbuf *pixbuf; filename = find_icon_file(theme, size, sized_icon, FALSE); g_return_if_fail(filename != NULL); pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (translucent) do_alphashift(pixbuf, pixbuf); source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(source, pixbuf); gtk_icon_source_set_direction(source, GTK_TEXT_DIR_LTR); gtk_icon_source_set_direction_wildcarded(source, !sized_icon.rtl); gtk_icon_source_set_size(source, sizeid); gtk_icon_source_set_size_wildcarded(source, FALSE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_set_add_source(iconset, source); gtk_icon_source_free(source); if (sizeid == gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)) { source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(source, pixbuf); gtk_icon_source_set_direction_wildcarded(source, TRUE); gtk_icon_source_set_size(source, GTK_ICON_SIZE_MENU); gtk_icon_source_set_size_wildcarded(source, FALSE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_set_add_source(iconset, source); gtk_icon_source_free(source); } g_free(filename); g_object_unref(pixbuf); if (sized_icon.rtl) { filename = find_icon_file(theme, size, sized_icon, TRUE); g_return_if_fail(filename != NULL); pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (translucent) do_alphashift(pixbuf, pixbuf); source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(source, pixbuf); gtk_icon_source_set_filename(source, filename); gtk_icon_source_set_direction(source, GTK_TEXT_DIR_RTL); gtk_icon_source_set_size(source, sizeid); gtk_icon_source_set_size_wildcarded(source, FALSE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_set_add_source(iconset, source); g_free(filename); g_object_unref(pixbuf); gtk_icon_source_free(source); } }
static void add_stock_item(void) { GtkIconSet *icon_set; GtkIconFactory *factory = gtk_icon_factory_new(); GtkIconTheme *theme = gtk_icon_theme_get_default(); GtkStockItem item = { (gchar*)(GEANYSENDMAIL_STOCK_MAIL), (gchar*)(N_("Mail")), 0, 0, (gchar*)(GETTEXT_PACKAGE) }; if (gtk_icon_theme_has_icon(theme, "mail-message-new")) { GtkIconSource *icon_source = gtk_icon_source_new(); icon_set = gtk_icon_set_new(); gtk_icon_source_set_icon_name(icon_source, "mail-message-new"); gtk_icon_set_add_source(icon_set, icon_source); gtk_icon_source_free(icon_source); } else { GdkPixbuf *pb = gdk_pixbuf_new_from_xpm_data(mail_icon); icon_set = gtk_icon_set_new_from_pixbuf(pb); g_object_unref(pb); } gtk_icon_factory_add(factory, item.stock_id, icon_set); gtk_stock_add(&item, 1); gtk_icon_factory_add_default(factory); g_object_unref(factory); gtk_icon_set_unref(icon_set); }
static void add_stock_icon (const gchar *stock_id, GtkIconSize size, const guint8 *inline_data) { GtkIconSource *source; GtkIconSet *set; GdkPixbuf *pixbuf; source = gtk_icon_source_new (); gtk_icon_source_set_size (source, size); gtk_icon_source_set_size_wildcarded (source, FALSE); pixbuf = gdk_pixbuf_new_from_inline (-1, inline_data, FALSE, NULL); gtk_icon_source_set_pixbuf (source, pixbuf); g_object_unref (pixbuf); set = gtk_icon_set_new (); gtk_icon_set_add_source (set, source); gtk_icon_source_free (source); gtk_icon_factory_add (mapobject_icon_factory, stock_id, set); gtk_icon_set_unref (set); }
void RenderThemeGtk::initMediaButtons() { static bool iconsInitialized = false; if (iconsInitialized) return; GRefPtr<GtkIconFactory> iconFactory = adoptGRef(gtk_icon_factory_new()); GtkIconSource* iconSource = gtk_icon_source_new(); const char* icons[] = { "audio-volume-high", "audio-volume-muted" }; gtk_icon_factory_add_default(iconFactory.get()); for (size_t i = 0; i < G_N_ELEMENTS(icons); ++i) { gtk_icon_source_set_icon_name(iconSource, icons[i]); GtkIconSet* iconSet = gtk_icon_set_new(); gtk_icon_set_add_source(iconSet, iconSource); gtk_icon_factory_add(iconFactory.get(), icons[i], iconSet); gtk_icon_set_unref(iconSet); } gtk_icon_source_free(iconSource); iconsInitialized = true; }
static GdkPixbuf * ensure_stated_pixbuf_from_pixbuf (GtkIconHelper *self, GtkStyleContext *context, GdkPixbuf *pixbuf) { GdkPixbuf *rendered; GtkIconSource *source; G_GNUC_BEGIN_IGNORE_DEPRECATIONS; /* FIXME: use gtk_icon_info_load_icon? */ source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, pixbuf); /* The size here is arbitrary; since size isn't * wildcarded in the source, it isn't supposed to be * scaled by the engine function */ gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_icon_source_set_size_wildcarded (source, FALSE); rendered = gtk_render_icon_pixbuf (context, source, (GtkIconSize) -1); gtk_icon_source_free (source); G_GNUC_END_IGNORE_DEPRECATIONS; return rendered; }
/** * ev_stock_icons_init: * * Creates a new icon factory, adding the base stock icons to it. */ void ev_stock_icons_init (void) { GtkIconFactory *factory; GtkIconSource *source; gint i; ev_icons_path = g_build_filename (ATRILDATADIR, "icons", NULL); factory = gtk_icon_factory_new (); gtk_icon_factory_add_default (factory); source = gtk_icon_source_new (); for (i = 0; i < G_N_ELEMENTS (stock_icons); i++) { GtkIconSet *set; gtk_icon_source_set_icon_name (source, stock_icons [i].icon); set = gtk_icon_set_new (); gtk_icon_set_add_source (set, source); gtk_icon_factory_add (factory, stock_icons [i].stock_id, set); gtk_icon_set_unref (set); } gtk_icon_source_free (source); g_object_unref (G_OBJECT (factory)); ev_stock_icons_add_icons_path_for_screen (gdk_screen_get_default ()); }
void camorama_stock_init(void) { GtkIconFactory* factory = gtk_icon_factory_new(); GtkIconSet * set = gtk_icon_set_new (); GtkIconSource * source = gtk_icon_source_new(); gtk_stock_add_static(camorama_items, G_N_ELEMENTS(camorama_items)); gtk_icon_source_set_size_wildcarded(source, TRUE); gtk_icon_source_set_direction_wildcarded(source, TRUE); gtk_icon_source_set_state_wildcarded(source, TRUE); gtk_icon_source_set_icon_name(source, CAMORAMA_STOCK_WEBCAM); gtk_icon_set_add_source(set, source); gtk_icon_factory_add(factory, CAMORAMA_STOCK_WEBCAM, set); add_default_image(CAMORAMA_STOCK_WEBCAM, 16, camorama_webcam_16); add_default_image(CAMORAMA_STOCK_WEBCAM, 24, camorama_webcam_24); gtk_icon_factory_add_default(factory); gtk_icon_set_unref(set); gtk_icon_source_free(source); }
/** * thunar_stock_init: * * Initializes the stock icons used by the Thunar * file manager. **/ void thunar_stock_init (void) { GtkIconFactory *icon_factory; GtkIconSource *icon_source; GtkIconSet *icon_set; guint n; /* allocate a new icon factory for the thunar stock icons */ icon_factory = gtk_icon_factory_new (); /* allocate an icon source */ icon_source = gtk_icon_source_new (); /* register our stock icons */ for (n = 0; n < G_N_ELEMENTS (thunar_stock_icons); ++n) { /* setup the icon set */ icon_set = gtk_icon_set_new (); gtk_icon_source_set_icon_name (icon_source, thunar_stock_icons[n].icon); gtk_icon_set_add_source (icon_set, icon_source); gtk_icon_factory_add (icon_factory, thunar_stock_icons[n].name, icon_set); gtk_icon_set_unref (icon_set); } /* register our icon factory as default */ gtk_icon_factory_add_default (icon_factory); /* cleanup */ g_object_unref (G_OBJECT (icon_factory)); gtk_icon_source_free (icon_source); }
void fr_stock_init (void) { GtkIconFactory *factory; GtkIconSource *source; int i; if (stock_initialized) return; stock_initialized = TRUE; gtk_stock_add_static (stock_items, G_N_ELEMENTS (stock_items)); factory = gtk_icon_factory_new (); gtk_icon_factory_add_default (factory); source = gtk_icon_source_new (); for (i = 0; i < G_N_ELEMENTS (stock_icons); i++) { GtkIconSet *set; gtk_icon_source_set_icon_name (source, stock_icons [i].icon); set = gtk_icon_set_new (); gtk_icon_set_add_source (set, source); gtk_icon_factory_add (factory, stock_icons [i].stock_id, set); gtk_icon_set_unref (set); } gtk_icon_source_free (source); g_object_unref (factory); }
MidoriExtension* extension_init (void) { GtkIconFactory* factory; GtkIconSource* icon_source; GtkIconSet* icon_set; static GtkStockItem items[] = { { STOCK_PAGE_HOLDER, N_("_Pageholder"), 0, 0, NULL }, }; factory = gtk_icon_factory_new (); gtk_stock_add (items, G_N_ELEMENTS (items)); icon_set = gtk_icon_set_new (); icon_source = gtk_icon_source_new (); gtk_icon_source_set_icon_name (icon_source, GTK_STOCK_ORIENTATION_PORTRAIT); gtk_icon_set_add_source (icon_set, icon_source); gtk_icon_source_free (icon_source); gtk_icon_factory_add (factory, STOCK_PAGE_HOLDER, icon_set); gtk_icon_set_unref (icon_set); gtk_icon_factory_add_default (factory); g_object_unref (factory); MidoriExtension* extension = g_object_new (MIDORI_TYPE_EXTENSION, "name", _("Pageholder"), "description", "", "version", "0.1", "authors", "Christian Dywan <*****@*****.**>", NULL); g_signal_connect (extension, "activate", G_CALLBACK (page_holder_activate_cb), NULL); return extension; }
nsresult nsIconChannel::Init(nsIURI* aURI) { nsCOMPtr<nsIMozIconURI> iconURI = do_QueryInterface(aURI); NS_ASSERTION(iconURI, "URI is not an nsIMozIconURI"); nsCAutoString stockIcon; iconURI->GetStockIcon(stockIcon); if (stockIcon.IsEmpty()) { #ifdef MOZ_ENABLE_GNOMEUI return InitWithGnome(iconURI); #else return NS_ERROR_NOT_AVAILABLE; #endif } nsCAutoString iconSizeString; iconURI->GetIconSize(iconSizeString); nsCAutoString iconStateString; iconURI->GetIconState(iconStateString); GtkIconSize icon_size = moz_gtk_icon_size(iconSizeString.get()); ensure_stock_image_widget(); gboolean sensitive = strcmp(iconStateString.get(), "disabled"); gtk_widget_set_sensitive (gStockImageWidget, sensitive); GdkPixbuf *icon = gtk_widget_render_icon(gStockImageWidget, stockIcon.get(), icon_size, NULL); #if GTK_CHECK_VERSION(2,4,0) if (!icon) { ensure_icon_factory(); GtkIconSet *icon_set = gtk_icon_set_new(); GtkIconSource *icon_source = gtk_icon_source_new(); gtk_icon_source_set_icon_name(icon_source, stockIcon.get()); gtk_icon_set_add_source(icon_set, icon_source); gtk_icon_factory_add(gIconFactory, stockIcon.get(), icon_set); gtk_icon_set_unref(icon_set); gtk_icon_source_free(icon_source); icon = gtk_widget_render_icon(gStockImageWidget, stockIcon.get(), icon_size, NULL); } #endif if (!icon) return NS_ERROR_NOT_AVAILABLE; nsresult rv = moz_gdk_pixbuf_to_channel(icon, iconURI, getter_AddRefs(mRealChannel)); g_object_unref(icon); return rv; }
/** * gul_gui_image_set_from_mime_type: * @image: a #GtkImage * @mime_type: a MIME type * @icon_size: a stock icon size * * Set the @image to display the icon for MIME type @mime_type. Sample MIME * types are "text/plain", "application/ogg". Sample stock sizes are * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_DIALOG. */ void gul_gui_image_set_from_mime_type (GtkWidget *image, const char *mime_type, GtkIconSize icon_size) { GtkIconTheme *theme; char *icon; GtkIconSource *source; GtkIconSet *icon_set; g_return_if_fail (GTK_IS_IMAGE(image)); g_return_if_fail (mime_type != NULL); theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (image)); icon = gnome_icon_lookup (theme, NULL, NULL, NULL, NULL, mime_type, GNOME_ICON_LOOKUP_FLAGS_NONE, NULL); if (!g_path_is_absolute (icon)) { int width, height; GtkIconInfo *icon_info; if (!gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET(image)), icon_size, &width, &height)) { width = height = -1; } icon_info = gtk_icon_theme_lookup_icon (theme, icon, height,0); g_free (icon); g_return_if_fail (icon_info != NULL); icon = g_strdup (gtk_icon_info_get_filename (icon_info)); gtk_icon_info_free (icon_info); } /* Now that we have the icon filename, wrap it into an GtkIconSet so * that we really get the desired size; the icon size in the file may * still be arbitrary, in case of SVG themes, for example. */ source = gtk_icon_source_new (); gtk_icon_source_set_filename (source, icon); g_free (icon); icon_set = gtk_icon_set_new (); gtk_icon_set_add_source (icon_set, source); gtk_icon_source_free (source); gtk_image_set_from_icon_set (GTK_IMAGE(image), icon_set, icon_size); gtk_icon_set_unref (icon_set); }
static void delete_clicked (GtkWidget * button, GladeEditorProperty * eprop) { GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop); GladeProperty *property = glade_editor_property_get_property (eprop); GtkTreeIter iter; GladeIconSources *icon_sources = NULL; GList *list, *sources, *new_list_head; gchar *icon_name; gint index = 0; /* NOTE: This will trigger row-deleted below... */ if (!gtk_tree_selection_get_selected (gtk_tree_view_get_selection (eprop_sources->view), NULL, &iter)) return; gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter, COLUMN_ICON_NAME, &icon_name, COLUMN_LIST_INDEX, &index, -1); /* Could be the user pressed add and then delete without touching the * new item. */ if (index < 0) { g_idle_add ((GSourceFunc) reload_icon_sources_idle, eprop); return; } glade_property_get (property, &icon_sources); if (icon_sources) { icon_sources = glade_icon_sources_copy (icon_sources); if ((sources = g_hash_table_lookup (icon_sources->sources, icon_name)) != NULL) { new_list_head = icon_set_copy (sources); list = g_list_nth (new_list_head, index); new_list_head = g_list_remove_link (new_list_head, list); gtk_icon_source_free ((GtkIconSource *) list->data); g_list_free (list); /* We copied all that above cause this will free the old list */ g_hash_table_insert (icon_sources->sources, g_strdup (icon_name), new_list_head); } update_icon_sources (eprop, icon_sources); } g_free (icon_name); }
static gboolean xfce_panel_image_expose_event (GtkWidget *widget, GdkEventExpose *event) { XfcePanelImagePrivate *priv = XFCE_PANEL_IMAGE (widget)->priv; gint source_width, source_height; gint dest_x, dest_y; GtkIconSource *source; GdkPixbuf *rendered = NULL; GdkPixbuf *pixbuf = priv->cache; cairo_t *cr; if (G_LIKELY (pixbuf != NULL)) { /* get the size of the cache pixbuf */ source_width = gdk_pixbuf_get_width (pixbuf); source_height = gdk_pixbuf_get_height (pixbuf); /* position */ dest_x = widget->allocation.x + (priv->width - source_width) / 2; dest_y = widget->allocation.y + (priv->height - source_height) / 2; if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE) { source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, pixbuf); rendered = gtk_style_render_icon (widget->style, source, gtk_widget_get_direction (widget), GTK_WIDGET_STATE (widget), -1, widget, "xfce-panel-image"); gtk_icon_source_free (source); if (G_LIKELY (rendered != NULL)) pixbuf = rendered; } /* draw the pixbuf */ cr = gdk_cairo_create (gtk_widget_get_window (widget)); if (G_LIKELY (cr != NULL)) { gdk_cairo_set_source_pixbuf (cr, pixbuf, dest_x, dest_y); cairo_paint (cr); cairo_destroy (cr); } if (rendered != NULL) g_object_unref (G_OBJECT (rendered)); } return FALSE; }
static void register_stock_icons (void) { GdkPixbuf *pixbuf; GtkIconFactory *icon_factory; GtkIconSet *icon_set; GtkIconSource *icon_source; gint i; icon_factory = gtk_icon_factory_new (); for (i = 0; xpms[i].name; i++) { icon_set = gtk_icon_set_new (); icon_source = gtk_icon_source_new (); pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) xpms[i].xpm); gtk_icon_source_set_pixbuf (icon_source, pixbuf); gtk_icon_source_set_direction_wildcarded (icon_source, TRUE); gtk_icon_source_set_state_wildcarded (icon_source, TRUE); if (! strcmp (xpms[i].name, GPA_STOCK_PUBLIC_KEY) || ! strcmp (xpms[i].name, GPA_STOCK_SECRET_KEY)) { /* FIXME: For the keylist icons, we disable scaling for now for best visual results. */ gtk_icon_source_set_size_wildcarded (icon_source, FALSE); gtk_icon_source_set_size (icon_source, GTK_ICON_SIZE_LARGE_TOOLBAR); } gtk_icon_set_add_source (icon_set, icon_source); gtk_icon_source_free (icon_source); gtk_icon_factory_add (icon_factory, xpms[i].name, icon_set); gtk_icon_set_unref (icon_set); } /* Add a fake stock icon for the clipboard window. */ icon_set = gtk_icon_factory_lookup_default (GTK_STOCK_PASTE); icon_set = gtk_icon_set_copy (icon_set); gtk_icon_factory_add (icon_factory, GPA_STOCK_CLIPBOARD, icon_set); /* Add a fake stock icon for the file manager window. */ icon_set = gtk_icon_factory_lookup_default (GTK_STOCK_DIRECTORY); icon_set = gtk_icon_set_copy (icon_set); gtk_icon_factory_add (icon_factory, GPA_STOCK_FILEMAN, icon_set); gtk_icon_factory_add_default (icon_factory); g_object_unref (icon_factory); }
static GdkPixbuf * ensure_stated_icon_from_info (GtkIconHelper *self, GtkStyleContext *context, GtkIconInfo *info) { GdkPixbuf *destination = NULL; gboolean symbolic; symbolic = FALSE; if (info) destination = gtk_icon_info_load_symbolic_for_context (info, context, &symbolic, NULL); if (destination == NULL) { GtkIconSet *icon_set; icon_set = gtk_style_context_lookup_icon_set (context, GTK_STOCK_MISSING_IMAGE); destination = gtk_icon_set_render_icon_pixbuf (icon_set, context, self->priv->icon_size); } else if (!symbolic) { GtkIconSource *source; GdkPixbuf *rendered; source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, destination); /* The size here is arbitrary; since size isn't * wildcarded in the source, it isn't supposed to be * scaled by the engine function */ gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_icon_source_set_size_wildcarded (source, FALSE); rendered = gtk_render_icon_pixbuf (context, source, (GtkIconSize) -1); gtk_icon_source_free (source); g_object_unref (destination); destination = rendered; } return destination; }
void stock_icon_register_pixbuf(GdkPixbuf * pixbuf, gchar * stock_id) { GtkIconSet *icon_set; GtkIconSource *icon_source; icon_set = gtk_icon_set_new(); icon_source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(icon_source, pixbuf); gtk_icon_set_add_source(icon_set, icon_source); gtk_icon_source_free(icon_source); gtk_icon_factory_add(icon_factory, stock_id, icon_set); gtk_icon_set_unref(icon_set); }
static void register_screenshooter_icon (GtkIconFactory * factory) { GtkIconSource *source; GtkIconSet *icon_set; source = gtk_icon_source_new (); gtk_icon_source_set_icon_name (source, SCREENSHOOTER_ICON); icon_set = gtk_icon_set_new (); gtk_icon_set_add_source (icon_set, source); gtk_icon_factory_add (factory, SCREENSHOOTER_ICON, icon_set); gtk_icon_set_unref (icon_set); gtk_icon_source_free (source); }
static void on_preview_expose_event (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data) { ScreenshotDialog *dialog = data; GdkPixbuf *pixbuf = NULL; gboolean free_pixbuf = FALSE; cairo_t *cr; /* Stolen from GtkImage. I really should just make the drawing area an * image some day */ if (gtk_widget_get_state (drawing_area) != GTK_STATE_NORMAL) { GtkIconSource *source; source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, dialog->preview_image); gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_icon_source_set_size_wildcarded (source, FALSE); pixbuf = gtk_style_render_icon (drawing_area->style, source, gtk_widget_get_direction (drawing_area), gtk_widget_get_state (drawing_area), (GtkIconSize) -1, drawing_area, "gtk-image"); free_pixbuf = TRUE; gtk_icon_source_free (source); } else { pixbuf = g_object_ref (dialog->preview_image); } cr = gdk_cairo_create (drawing_area->window); gdk_cairo_region (cr, event->region); cairo_clip (cr); gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); cairo_paint (cr); cairo_destroy (cr); g_object_unref (pixbuf); }
void stock_icon_register(gchar * filename, gchar * stock_id) { GtkIconSet *icon_set; GtkIconSource *icon_source; icon_set = gtk_icon_set_new(); icon_source = gtk_icon_source_new(); gtk_icon_source_set_pixbuf(icon_source, icon_cache_get_pixbuf(filename)); gtk_icon_set_add_source(icon_set, icon_source); gtk_icon_source_free(icon_source); gtk_icon_factory_add(icon_factory, stock_id, icon_set); gtk_icon_set_unref(icon_set); }
static void add_icon (GtkIconFactory *factory, const char *scalable_filename, const char *sized_filename, const char *stock_id) { GtkIconSet *set = gtk_icon_set_new (); GtkIconSource *src = gtk_icon_source_new (); if (scalable_filename) { char *res = g_strconcat ("res:gnm:pixmaps/", scalable_filename, NULL); GdkPixbuf *pix = go_gdk_pixbuf_load_from_file (res); if (pix) { gtk_icon_source_set_size_wildcarded (src, TRUE); gtk_icon_source_set_pixbuf (src, pix); gtk_icon_set_add_source (set, src); g_object_unref (pix); } else { g_warning ("Missing resource %s\n", res); } g_free (res); } /* * For now, don't register a fixed-sized icon as doing so without * catching style changes kills things like bug 302902. */ if (sized_filename && !scalable_filename) { char *res = g_strconcat ("res:gnm:pixmaps/", sized_filename, NULL); GdkPixbuf *pix = go_gdk_pixbuf_load_from_file (res); gtk_icon_source_set_size (src, GTK_ICON_SIZE_MENU); gtk_icon_source_set_size_wildcarded (src, FALSE); gtk_icon_source_set_pixbuf (src, pix); gtk_icon_set_add_source (set, src); g_object_unref (pix); g_free (res); } gtk_icon_factory_add (factory, stock_id, set); gtk_icon_set_unref (set); gtk_icon_source_free (src); }
static void register_stock_icon (GtkIconFactory * icon_factory, const char * stock_id, const char * icon_name) { GtkIconSource *source; GtkIconSet *set; set = gtk_icon_set_new (); source = gtk_icon_source_new (); gtk_icon_source_set_icon_name (source, icon_name); gtk_icon_set_add_source (set, source); gtk_icon_source_free (source); gtk_icon_factory_add (icon_factory, stock_id, set); gtk_icon_set_unref (set); }
static gboolean xfce_panel_image_draw (GtkWidget *widget, cairo_t *cr) { XfcePanelImagePrivate *priv = XFCE_PANEL_IMAGE (widget)->priv; gint source_width, source_height; gint dest_x, dest_y; GtkIconSource *source; GdkPixbuf *rendered = NULL; GdkPixbuf *pixbuf = priv->cache; GtkStyleContext *context; if (G_LIKELY (pixbuf != NULL)) { /* get the size of the cache pixbuf */ source_width = gdk_pixbuf_get_width (pixbuf); source_height = gdk_pixbuf_get_height (pixbuf); /* position */ dest_x = (priv->width - source_width) / 2; dest_y = (priv->height - source_height) / 2; context = gtk_widget_get_style_context (widget); if (!gtk_widget_is_sensitive (widget)) { source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, pixbuf); rendered = gtk_render_icon_pixbuf (context, source, -1); gtk_icon_source_free (source); if (G_LIKELY (rendered != NULL)) pixbuf = rendered; } /* draw the icon */ gtk_render_icon (context, cr, pixbuf, dest_x, dest_y); if (rendered != NULL) g_object_unref (G_OBJECT (rendered)); } return FALSE; }
static void accessx_applet_add_stock_icons(AccessxStatusApplet* sapplet, GtkWidget* widget) { GtkIconFactory* factory = gtk_icon_factory_new(); gint i = 0; GtkIconSet* icon_set; gtk_icon_factory_add_default(factory); while (i < G_N_ELEMENTS(stock_icons)) { gchar* set_name = stock_icons[i].stock_id; icon_set = gtk_icon_set_new(); do { char* filename; GtkIconSource* source = gtk_icon_source_new(); filename = g_build_filename(ACCESSX_PIXMAPS_DIR, stock_icons[i].name, NULL); if (g_file_test(filename, G_FILE_TEST_EXISTS) && g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { gtk_icon_source_set_filename(source, filename); } else { GtkIconSet* default_set = gtk_icon_factory_lookup_default(GTK_STOCK_MISSING_IMAGE); gtk_icon_source_set_pixbuf(source, gtk_icon_set_render_icon(default_set, gtk_widget_get_style(widget), GTK_TEXT_DIR_NONE, GTK_STATE_NORMAL, icon_size_spec, widget, NULL)); } g_free(filename); gtk_icon_source_set_state(source, stock_icons[i].state); gtk_icon_source_set_state_wildcarded(source, stock_icons[i].wildcarded); gtk_icon_set_add_source(icon_set, source); gtk_icon_source_free(source); ++i; } while (set_name == stock_icons[i].stock_id); gtk_icon_factory_add(factory, set_name, icon_set); gtk_icon_set_unref(icon_set); } /* now create the stock icons for AltGr, which are internationalized */ icon_set = accessx_status_applet_altgraph_icon_set (sapplet, widget); gtk_icon_factory_add(factory, ALTGRAPH_KEY_ICON, icon_set); gtk_icon_set_unref(icon_set); sapplet->icon_factory = factory; }
static void register_stock_icon (GtkIconFactory *factory, const gchar *stock_id, const gchar *icon_name) { GtkIconSet *set = gtk_icon_set_new (); GtkIconSource *source = gtk_icon_source_new (); gtk_icon_source_set_direction_wildcarded (source, TRUE); gtk_icon_source_set_size_wildcarded (source, TRUE); gtk_icon_source_set_state_wildcarded (source, TRUE); gtk_icon_source_set_icon_name (source, icon_name); gtk_icon_set_add_source (set, source); gtk_icon_source_free (source); gtk_icon_factory_add (factory, stock_id, set); gtk_icon_set_unref (set); }
/* Initialize Sticky Notes Icons */ void stickynotes_applet_init_icons(void) { GtkIconFactory *icon_factory = gtk_icon_factory_new(); gint i; for (i = 0; i < G_N_ELEMENTS(stickynotes_icons); i++) { StickyNotesStockIcon icon = stickynotes_icons[i]; GtkIconSource *icon_source = gtk_icon_source_new(); GtkIconSet *icon_set = gtk_icon_set_new(); gtk_icon_source_set_filename(icon_source, icon.filename); gtk_icon_set_add_source(icon_set, icon_source); gtk_icon_factory_add(icon_factory, icon.stock_id, icon_set); gtk_icon_source_free(icon_source); gtk_icon_set_unref(icon_set); } gtk_icon_factory_add_default(icon_factory); g_object_unref(G_OBJECT(icon_factory)); }
static void icon_set_from_inline (GtkIconSet *set, const guchar *inline_data, GtkIconSize size, GtkTextDirection direction, gboolean fallback) { GtkIconSource *source; GdkPixbuf *pixbuf; source = gtk_icon_source_new (); if (direction != GTK_TEXT_DIR_NONE) { gtk_icon_source_set_direction (source, direction); gtk_icon_source_set_direction_wildcarded (source, FALSE); } gtk_icon_source_set_size (source, size); gtk_icon_source_set_size_wildcarded (source, FALSE); pixbuf = gdk_pixbuf_new_from_inline (-1, inline_data, FALSE, NULL); g_assert (pixbuf); gtk_icon_source_set_pixbuf (source, pixbuf); g_object_unref (pixbuf); gtk_icon_set_add_source (set, source); if (fallback) { gtk_icon_source_set_size_wildcarded (source, TRUE); gtk_icon_set_add_source (set, source); } gtk_icon_source_free (source); }
static void icon_set_from_data (GtkIconSet *set, const guint8 *icon_data, const guint data_size, GtkIconSize size, gboolean fallback) { GtkIconSource *source; GdkPixbuf *pixbuf; GError *err = NULL; source = gtk_icon_source_new (); gtk_icon_source_set_size (source, size); gtk_icon_source_set_size_wildcarded (source, FALSE); pixbuf = gdk_pixbuf_new_from_inline (data_size, icon_data, FALSE, &err); if (err) { g_warning ("%s",err->message); g_error_free (err); err = NULL; g_object_unref (source); return; } gtk_icon_source_set_pixbuf (source, pixbuf); g_object_unref (pixbuf); gtk_icon_set_add_source (set, source); if (fallback) { gtk_icon_source_set_size_wildcarded (source, TRUE); gtk_icon_set_add_source (set, source); } gtk_icon_source_free (source); }
static void add_stock_icon (const gchar *stock_id, GtkIconSize size, const guint8 *inline_data) { GtkIconSource *source; GtkIconSet *set; GdkPixbuf *pixbuf; source = gtk_icon_source_new (); gtk_icon_source_set_size (source, size); gtk_icon_source_set_size_wildcarded (source, FALSE); pixbuf = gdk_pixbuf_new_from_inline (-1, inline_data, FALSE, NULL); if(gap_debug) { printf("add_stock_icon stock_id:%s size:%d inline_data:%d pixbuf:%d\n" ,stock_id ,(int)size ,(int)inline_data ,(int)pixbuf ); } gtk_icon_source_set_pixbuf (source, pixbuf); g_object_unref (pixbuf); set = gtk_icon_set_new (); gtk_icon_set_add_source (set, source); gtk_icon_source_free (source); gtk_icon_factory_add (gap_icon_factory, stock_id, set); gtk_icon_set_unref (set); }