void
pidgin_stock_load_status_icon_theme(PidginStatusIconTheme *theme)
{
GtkIconFactory *icon_factory;
gint i;
GtkIconSet *normal;
GtkIconSet *translucent = NULL;
GtkWidget *win;
if (theme != NULL) {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/status/icon-theme",
purple_theme_get_name(PURPLE_THEME(theme)));
purple_prefs_set_path(PIDGIN_PREFS_ROOT "/status/icon-theme-dir",
purple_theme_get_dir(PURPLE_THEME(theme)));
}
else {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/status/icon-theme", "");
purple_prefs_set_path(PIDGIN_PREFS_ROOT "/status/icon-theme-dir", "");
}
icon_factory = gtk_icon_factory_new();
gtk_icon_factory_add_default(icon_factory);
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(win);
for (i = 0; i < G_N_ELEMENTS(sized_status_icons); i++)
{
normal = gtk_icon_set_new();
if (sized_status_icons[i].translucent_name)
translucent = gtk_icon_set_new();
#define ADD_SIZED_ICON(name, size) \
if (sized_status_icons[i].name) { \
add_sized_icon(normal, name, PIDGIN_ICON_THEME(theme), size, sized_status_icons[i], FALSE); \
if (sized_status_icons[i].translucent_name) \
add_sized_icon(translucent, name, PIDGIN_ICON_THEME(theme), size, sized_status_icons[i], TRUE); \
}
ADD_SIZED_ICON(microscopic, "11");
ADD_SIZED_ICON(extra_small, "16");
ADD_SIZED_ICON(small, "22");
ADD_SIZED_ICON(medium, "32");
ADD_SIZED_ICON(large, "48");
ADD_SIZED_ICON(huge, "64");
#undef ADD_SIZED_ICON
gtk_icon_factory_add(icon_factory, sized_status_icons[i].name, normal);
gtk_icon_set_unref(normal);
if (sized_status_icons[i].translucent_name) {
gtk_icon_factory_add(icon_factory, sized_status_icons[i].translucent_name, translucent);
gtk_icon_set_unref(translucent);
}
}
gtk_widget_destroy(win);
g_object_unref(G_OBJECT(icon_factory));
reload_settings();
}
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);
}
/**
* 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);
}
static VALUE
rg_add(VALUE self, VALUE id, VALUE icon_set)
{
gtk_icon_factory_add(_SELF(self), RVAL2CSTR(id),
(GtkIconSet*)RVAL2BOXED(icon_set, GTK_TYPE_ICON_SET));
return self;
}
static void
register_stock_icons (void)
{
static gboolean registered = FALSE;
if (!registered)
{
GdkPixbuf *pixbuf;
GtkIconFactory *factory;
GtkIconSet *icon_set;
static GtkStockItem items[] = {
{ "demo-gtk-logo", "_GTK!", 0, 0, NULL }
};
registered = TRUE;
gtk_stock_add (items, G_N_ELEMENTS (items));
factory = gtk_icon_factory_new ();
gtk_icon_factory_add_default (factory);
pixbuf = gdk_pixbuf_new_from_resource ("/application/gtk-logo-24.png", NULL);
icon_set = gtk_icon_set_new_from_pixbuf (pixbuf);
gtk_icon_factory_add (factory, "demo-gtk-logo", icon_set);
gtk_icon_set_unref (icon_set);
g_object_unref (pixbuf);
/* Drop our reference to the factory, GTK will hold a reference. */
g_object_unref (factory);
}
}
/**
* @param item a validly filled out GxkStockItem
*
* Register a new stock item. The new stock item
* @a item->stock_id is registered with an item label
* of @a item->label and the stock icon @a item->stock_fallback.
* If @a item->label is NULL, @a item->stock_fallback must
* not be NULL, and @a item->stock_id becomes merely an
* alias of @a item->stock_fallback.
*/
void
gxk_stock_register_item (const GxkStockItem *item)
{
GtkStockItem tkitem = { NULL, };
g_return_if_fail (item != NULL);
g_return_if_fail (item->stock_id != NULL);
g_return_if_fail (item->label != NULL || item->stock_fallback != NULL);
tkitem.stock_id = (gchar*) item->stock_id;
if (item->label)
tkitem.label = (gchar*) item->label;
else
tkitem.label = (gchar*) gxk_stock_item (item->stock_fallback);
tkitem.modifier = 0;
tkitem.keyval = 0;
tkitem.translation_domain = NULL;
gtk_stock_add (&tkitem, 1);
if (item->stock_fallback)
{
GtkIconSet *iset = gtk_icon_factory_lookup_default (item->stock_fallback);
if (iset)
gtk_icon_factory_add (stock_icon_factory, item->stock_id, iset);
}
}
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);
}
void extras_register_stock()
{
static gboolean stock_is_init = FALSE;
GtkIconFactory *icon_factory = NULL;
int i;
if (stock_is_init)
return;
stock_is_init = TRUE;
icon_factory = gtk_icon_factory_new();
gtk_icon_factory_add_default(icon_factory);
for (i = 0; i < G_N_ELEMENTS(stock_icons); i++) {
GdkPixbuf *pixbuf;
GtkIconSet *iconset;
gchar *filename;
filename = find_file(stock_icons[i].dir, stock_icons[i].filename);
if (filename == NULL)
continue;
pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
g_free(filename);
iconset = gtk_icon_set_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
gtk_icon_factory_add(icon_factory, stock_icons[i].name, iconset);
gtk_icon_set_unref(iconset);
}
}
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);
}
static void
add_sized_with_same_fallback (GtkIconFactory *factory,
const guchar *inline_data,
const guchar *inline_data_rtl,
GtkIconSize size,
const gchar *stock_id)
{
GtkIconSet *set;
gboolean fallback = FALSE;
set = gtk_icon_factory_lookup (factory, stock_id);
if (! set)
{
set = gtk_icon_set_new ();
gtk_icon_factory_add (factory, stock_id, set);
gtk_icon_set_unref (set);
fallback = TRUE;
}
icon_set_from_inline (set, inline_data, size, GTK_TEXT_DIR_NONE, fallback);
if (inline_data_rtl)
icon_set_from_inline (set,
inline_data_rtl, size, GTK_TEXT_DIR_RTL, fallback);
}
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;
}
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
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
meta_stock_icons_init (void)
{
GtkIconFactory *factory;
int i;
MetaStockIcon items[] =
{
{ METACITY_STOCK_DELETE, stock_delete_data },
{ METACITY_STOCK_MINIMIZE, stock_minimize_data },
{ METACITY_STOCK_MAXIMIZE, stock_maximize_data }
};
factory = gtk_icon_factory_new ();
gtk_icon_factory_add_default (factory);
for (i = 0; i < (gint) G_N_ELEMENTS (items); i++)
{
GtkIconSet *icon_set;
GdkPixbuf *pixbuf;
pixbuf = gdk_pixbuf_new_from_inline (-1, items[i].icon_data,
FALSE,
NULL);
icon_set = gtk_icon_set_new_from_pixbuf (pixbuf);
gtk_icon_factory_add (factory, items[i].stock_id, icon_set);
gtk_icon_set_unref (icon_set);
g_object_unref (G_OBJECT (pixbuf));
}
g_object_unref (G_OBJECT (factory));
}
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);
}
/**
* 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
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;
}
void setup_icons()
{
GtkIconFactory *icons = gtk_icon_factory_new();
gtk_icon_factory_add(icons, "slade-mode-verts",
gtk_icon_set_new_from_pixbuf(gdk_pixbuf_new_from_file("res/tb_verts16.png", NULL)));
gtk_icon_factory_add(icons, "slade-mode-lines",
gtk_icon_set_new_from_pixbuf(gdk_pixbuf_new_from_file("res/tb_lines16.png", NULL)));
gtk_icon_factory_add(icons, "slade-mode-sectors",
gtk_icon_set_new_from_pixbuf(gdk_pixbuf_new_from_file("res/tb_sectors16.png", NULL)));
gtk_icon_factory_add(icons, "slade-mode-things",
gtk_icon_set_new_from_pixbuf(gdk_pixbuf_new_from_file("res/tb_things16.png", NULL)));
gtk_icon_factory_add(icons, "slade-mode-3d",
gtk_icon_set_new_from_pixbuf(gdk_pixbuf_new_from_file("res/tb_3d16.png", NULL)));
gtk_icon_factory_add_default(icons);
}
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;
}
void
lshw_gtk_stock_init(void)
{
static int stock_initted = 0;
GtkIconFactory *icon_factory;
int i;
GtkWidget *win;
if (stock_initted)
return;
stock_initted = 1;
/* Setup the icon factory. */
icon_factory = gtk_icon_factory_new();
gtk_icon_factory_add_default(icon_factory);
/* Er, yeah, a hack, but it works. :) */
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(win);
for (i = 0; i < G_N_ELEMENTS(stock_icons); i++)
{
GdkPixbuf *pixbuf;
GtkIconSet *iconset;
gchar *filename;
filename = find_file(stock_icons[i].filename);
if (filename == NULL)
continue;
pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
g_free(filename);
if(pixbuf) /* we managed to load something */
{
iconset = gtk_icon_set_new_from_pixbuf(pixbuf);
g_object_unref(G_OBJECT(pixbuf));
gtk_icon_factory_add(icon_factory, stock_icons[i].name, iconset);
gtk_icon_set_unref(iconset);
}
}
gtk_widget_destroy(win);
/* register logo icon size */
gtk_icon_size_register(LSHW_ICON_SIZE_LOGO, LSHW_DEFAULT_ICON_SIZE, LSHW_DEFAULT_ICON_SIZE);
g_object_unref(G_OBJECT(icon_factory));
(void) &id; /* avoid "id defined but not used" warning */
}
/**
* @param icon a validly filled out GxkStockIcon
*
* Register a new stock icon from an inlined pixbuf.
* The inlined pixbuf pixels are not copied, so the
* caller must make sure for the data to remain valid.
*/
void
gxk_stock_register_icon (const GxkStockIcon *icon)
{
GdkPixbuf *pixbuf;
GtkIconSet *iset;
g_return_if_fail (icon != NULL);
pixbuf = gdk_pixbuf_new_from_inline (-1, icon->inlined_pixbuf, FALSE, NULL);
iset = gtk_icon_set_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_icon_factory_add (stock_icon_factory, icon->stock_id, iset);
gtk_icon_set_unref (iset);
}
static void
_add_stock_icon_name (GtkIconFactory *factory, const char *name, const gchar *icon)
{
GdkPixbuf *pixbuf;
GtkIconSet *set;
char *path;
path = g_strdup_printf ("/org/gnome/Dia/icons/%s.png", icon);
pixbuf = pixbuf_from_resource (path);
set = gtk_icon_set_new_from_pixbuf (pixbuf);
gtk_icon_factory_add (factory, name, set);
g_object_unref (pixbuf);
g_free (path);
pixbuf = NULL;
}
void gxw_init()
{
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init();
#endif
GtkIconFactory *factory = gtk_icon_factory_new();
for (image_entry *p = image_data; p->icon_name; p++) {
gtk_icon_factory_add(
factory, p->icon_name,
gtk_icon_set_new_from_pixbuf(
gdk_pixbuf_new_from_inline(
-1, p->icon_data, FALSE, NULL)));
}
gtk_icon_factory_add_default(factory);
}
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 GdkPixbuf*
add(GtkIconFactory *factory,
const guchar *inline_data,
const gchar *stock_id) {
GtkIconSet *set;
GdkPixbuf *pixbuf;
pixbuf = gdk_pixbuf_new_from_inline(-1, inline_data, FALSE, NULL);
set = gtk_icon_set_new_from_pixbuf(pixbuf);
g_object_unref(G_OBJECT(pixbuf));
gtk_icon_factory_add(factory, stock_id, set);
gtk_icon_set_unref(set);
return pixbuf;
}
static void
register_stock_icon(void)
{
static gboolean registered = FALSE;
if (!registered)
{
GdkPixbuf *pixbuf;
GtkIconFactory *factory;
static GtkStockItem items[] = {
{ (gchar*)"abi-table-widget",
(gchar*)"_Table",
static_cast<GdkModifierType>(0), 0, NULL }
};
registered = TRUE;
/* Register our stock items */
gtk_stock_add (items, G_N_ELEMENTS (items));
/* Add our custom icon factory to the list of defaults */
factory = gtk_icon_factory_new ();
gtk_icon_factory_add_default (factory);
// Must be C cast
pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)widget_tb_insert_table_xpm);
/* Register icon to accompany stock item */
if (pixbuf != NULL)
{
GtkIconSet *icon_set;
icon_set = gtk_icon_set_new_from_pixbuf (pixbuf);
gtk_icon_factory_add (factory, "abi-table-widget", icon_set);
gtk_icon_set_unref (icon_set);
g_object_unref (G_OBJECT (pixbuf));
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
/* Drop our reference to the factory, GTK will hold a reference. */
g_object_unref (G_OBJECT (factory));
}
}
/*
* Initialise tool actions.
* The caller owns the return value.
*/
static GtkActionGroup *
create_or_ref_tool_actions (void)
{
GtkIconFactory *icon_factory;
GtkActionGroup *actions;
GtkAction *action;
int i;
if (tool_actions)
return g_object_ref (tool_actions);
actions = gtk_action_group_new ("tool-actions");
gtk_action_group_set_translation_domain (actions, NULL);
gtk_action_group_set_translate_func (actions, _dia_translate, NULL, NULL);
gtk_action_group_add_actions (actions, tool_entries,
G_N_ELEMENTS (tool_entries), NULL);
icon_factory = gtk_icon_factory_new ();
for (i = 0; i < num_tools; i++) {
action = gtk_action_group_get_action (actions, tool_data[i].action_name);
if (action != NULL) {
g_signal_connect (G_OBJECT (action), "activate",
G_CALLBACK (tool_menu_select),
&tool_data[i].callback_data);
gtk_action_set_tooltip (action, _(tool_data[i].tool_desc));
{
GdkPixbuf *pb = tool_get_pixbuf (&tool_data[i]);
GtkIconSet *is = gtk_icon_set_new_from_pixbuf (pb);
/* not sure if the action name is unique enough */
gtk_icon_factory_add (icon_factory, tool_data[i].action_name, is);
gtk_action_set_stock_id (action, tool_data[i].action_name);
g_object_unref (pb);
}
}
else {
g_warning ("couldn't find tool menu item %s", tool_data[i].action_name);
}
}
gtk_icon_factory_add_default (icon_factory);
return actions;
}
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);
}
