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_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);
}
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;
}
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);
}
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);
}
static GtkIconSource*
make_icon_source (const gchar *icon, const gchar *base, const gchar *ext,
GtkIconSize size)
{
GtkIconSource *source;
gchar *filename;
filename = g_strdup_printf ("%s/%s/%s.%s", PIXMAPSDIR, base, icon, ext);
source = gtk_icon_source_new ();
gtk_icon_source_set_filename (source, filename);
gtk_icon_source_set_direction_wildcarded (source, TRUE);
gtk_icon_source_set_state_wildcarded (source, TRUE);
if (size == -1) {
gtk_icon_source_set_size_wildcarded (source, TRUE);
} else {
gtk_icon_source_set_size_wildcarded (source, FALSE);
gtk_icon_source_set_size (source, size);
}
g_free(filename);
return source;
}
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;
}
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;
}
/**
* 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 ());
}
/**
* 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);
}
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 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 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;
}
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 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);
}
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
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);
}
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);
}
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
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 GtkIconSource*
make_theme_source (const gchar *icon, GtkIconSize size)
{
GtkIconSource *source;
source = gtk_icon_source_new ();
gtk_icon_source_set_icon_name (source, icon);
gtk_icon_source_set_direction_wildcarded (source, TRUE);
gtk_icon_source_set_state_wildcarded (source, TRUE);
if (size == -1) {
gtk_icon_source_set_size_wildcarded (source, TRUE);
} else {
gtk_icon_source_set_size_wildcarded (source, FALSE);
gtk_icon_source_set_size (source, size);
}
return source;
}
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);
}
void add_stock_icon (const gchar *filename, const gchar *stock_id)
{
GtkIconSource *icon_source = NULL ;
GtkIconSet *icon_set = NULL ;
static GtkIconFactory *icon_factory = NULL ;
char *psz = NULL ;
if (NULL == icon_factory)
gtk_icon_factory_add_default (icon_factory = gtk_icon_factory_new ()) ;
if (NULL != (icon_source = gtk_icon_source_new ()))
{
gtk_icon_source_set_filename (icon_source, psz = find_pixmap_file (filename)) ;
if (NULL == (icon_set = gtk_icon_factory_lookup (icon_factory, stock_id)))
{
icon_set = gtk_icon_set_new () ;
gtk_icon_factory_add (icon_factory, stock_id, icon_set) ;
}
gtk_icon_set_add_source (icon_set, icon_source) ;
}
}
/* 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);
}