/**
* @param stock_id stock name
* @return this @a stock_id's pixbuf (or NULL for invalid stock ids)
*
* Return the pixbuf associated with @a stock_id, the pixbuf is
* owned by the stock system and persists throughout runtime.
* To display stock icons in widgets use gxk_stock_image() and not
* this pixbuf.
*/
GdkPixbuf*
gxk_stock_fallback_pixbuf (const gchar *stock_id)
{
static GData *stock_pixbuf_repo = NULL;
GdkPixbuf *pixbuf;
g_return_val_if_fail (stock_id != NULL, NULL);
pixbuf = g_datalist_get_data (&stock_pixbuf_repo, stock_id);
if (!pixbuf)
{
GtkIconSet *iset = gtk_icon_factory_lookup_default (stock_id);
if (iset)
{
static GtkStyle *style = NULL; /* FIXME: GTKFIX: gtk_icon_set_render_icon() shouldn't demand a style */
if (!style)
style = gtk_style_new ();
pixbuf = gtk_icon_set_render_icon (iset, style, GTK_TEXT_DIR_NONE,
GTK_STATE_NORMAL, -1, NULL, NULL);
g_datalist_set_data (&stock_pixbuf_repo, stock_id, pixbuf);
}
}
return pixbuf;
}
GdkPixbuf *CreateStockIcon(const char *stockid, GtkIconSize size)
{
// FIXME: This code is not 100% correct, because stock pixmap are
// context-dependent and may be affected by theme engine, the
// correct value can only be obtained for given GtkWidget object.
//
// Fool-proof implementation of stock bitmaps would extend wxBitmap
// with "stock-id" representation (in addition to pixmap and pixbuf
// ones) and would convert it to pixbuf when rendered.
GtkWidget* widget = wxGTKPrivate::GetButtonWidget();
#ifdef __WXGTK3__
GtkStyleContext* sc = gtk_widget_get_style_context(widget);
GtkIconSet* iconset = gtk_style_context_lookup_icon_set(sc, stockid);
GdkPixbuf* pixbuf = NULL;
if (iconset)
pixbuf = gtk_icon_set_render_icon_pixbuf(iconset, sc, size);
return pixbuf;
#else
GtkStyle* style = gtk_widget_get_style(widget);
GtkIconSet* iconset = gtk_style_lookup_icon_set(style, stockid);
if (!iconset)
return NULL;
return gtk_icon_set_render_icon(iconset, style,
gtk_widget_get_default_direction(),
GTK_STATE_NORMAL, size, NULL, NULL);
#endif
}
static void
fm_menu__item_image_from_stock(GtkWidget* menu, GtkWidget* item, char* stock_id)
{
GtkIconSet* set = gtk_style_lookup_icon_set(gtk_widget_get_style(menu), stock_id);
GdkPixbuf* pixbuf = gtk_icon_set_render_icon(set, gtk_widget_get_style(menu), GTK_TEXT_DIR_LTR, GTK_STATE_NORMAL, GTK_ICON_SIZE_MENU, menu, NULL);
GtkWidget* icon = gtk_image_new_from_pixbuf(pixbuf);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), icon);
g_object_unref(pixbuf);
}
GRefPtr<GdkPixbuf> RenderThemeGtk::getStockIcon(GType widgetType, const char* iconName, gint direction, gint state, gint iconSize)
{
ASSERT(widgetType == GTK_TYPE_CONTAINER || widgetType == GTK_TYPE_ENTRY);
GtkWidget* widget = widgetType == GTK_TYPE_CONTAINER ? GTK_WIDGET(gtkContainer()) : gtkEntry();
GtkStyle* style = gtk_widget_get_style(widget);
GtkIconSet* iconSet = gtk_style_lookup_icon_set(style, iconName);
return adoptGRef(gtk_icon_set_render_icon(iconSet, style,
static_cast<GtkTextDirection>(direction),
static_cast<GtkStateType>(state),
static_cast<GtkIconSize>(iconSize), 0, 0));
}
static void
create_button_images (AppearanceData *data)
{
GtkWidget *widget = (GtkWidget*)data->wp_view;
GtkStyle *style = gtk_widget_get_style (widget);
GtkIconSet *icon_set;
GdkPixbuf *pixbuf, *pb, *pb2;
gint i, w, h;
icon_set = gtk_style_lookup_icon_set (style, "gtk-media-play");
pb = gtk_icon_set_render_icon (icon_set,
style,
GTK_TEXT_DIR_RTL,
GTK_STATE_NORMAL,
GTK_ICON_SIZE_MENU,
widget,
NULL);
pb2 = gtk_icon_set_render_icon (icon_set,
style,
GTK_TEXT_DIR_LTR,
GTK_STATE_NORMAL,
GTK_ICON_SIZE_MENU,
widget,
NULL);
w = gdk_pixbuf_get_width (pb);
h = gdk_pixbuf_get_height (pb);
for (i = 0; i < 3; i++) {
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 2 * w, h);
gdk_pixbuf_fill (pixbuf, 0);
if (i > 0)
gdk_pixbuf_composite (pb, pixbuf, 0, 0, w, h, 0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
if (i < 2)
gdk_pixbuf_composite (pb2, pixbuf, w, 0, w, h, w, 0, 1, 1, GDK_INTERP_NEAREST, 255);
buttons[i] = pixbuf;
}
g_object_unref (pb);
g_object_unref (pb2);
}
static VALUE
rg_render_icon(int argc, VALUE *argv, VALUE self)
{
VALUE style, direction, state, size, widget, detail;
rb_scan_args(argc, argv, "42", &style, &direction, &state, &size, &widget, &detail);
return GOBJ2RVAL(gtk_icon_set_render_icon(_SELF(self),
RVAL2GOBJ(style),
RVAL2GENUM(direction, GTK_TYPE_TEXT_DIRECTION),
RVAL2GENUM(state, GTK_TYPE_STATE_TYPE),
RVAL2GENUM(size, GTK_TYPE_ICON_SIZE),
NIL_P(widget) ? NULL : RVAL2GOBJ(widget),
NIL_P(detail) ? NULL : RVAL2CSTR(detail)));
}
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;
}
/* Create a MaskedPixmap from a GTK stock ID. Always returns
* a valid image.
*/
static MaskedPixmap *mp_from_stock(const char *stock_id, int size)
{
//printf("mp_from_stock()...\n");
GtkIconSet *icon_set;
GdkPixbuf *pixbuf;
MaskedPixmap *retval;
icon_set = gtk_icon_factory_lookup_default(stock_id);
if (!icon_set) return get_bad_image();
pixbuf = gtk_icon_set_render_icon(icon_set,
gtk_widget_get_default_style(), /* Gtk bug */
GTK_TEXT_DIR_LTR,
GTK_STATE_NORMAL,
size,
NULL,
NULL);
retval = masked_pixmap_new(pixbuf);
g_object_unref(pixbuf);
return retval;
}
nsresult
nsIconChannel::Init(nsIURI* aURI)
{
nsCOMPtr<nsIMozIconURI> iconURI = do_QueryInterface(aURI);
NS_ASSERTION(iconURI, "URI is not an nsIMozIconURI");
nsAutoCString stockIcon;
iconURI->GetStockIcon(stockIcon);
if (stockIcon.IsEmpty()) {
#ifdef MOZ_ENABLE_GNOMEUI
return InitWithGnome(iconURI);
#else
#ifdef MOZ_ENABLE_GIO
return InitWithGIO(iconURI);
#else
return NS_ERROR_NOT_AVAILABLE;
#endif
#endif
}
// Search for stockIcon
nsAutoCString iconSizeString;
iconURI->GetIconSize(iconSizeString);
nsAutoCString iconStateString;
iconURI->GetIconState(iconStateString);
GtkIconSize icon_size = moz_gtk_icon_size(iconSizeString.get());
GtkStateType state = iconStateString.EqualsLiteral("disabled") ?
GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL;
// First lookup the icon by stock id and text direction.
GtkTextDirection direction = GTK_TEXT_DIR_NONE;
if (StringEndsWith(stockIcon, NS_LITERAL_CSTRING("-ltr"))) {
direction = GTK_TEXT_DIR_LTR;
} else if (StringEndsWith(stockIcon, NS_LITERAL_CSTRING("-rtl"))) {
direction = GTK_TEXT_DIR_RTL;
}
bool forceDirection = direction != GTK_TEXT_DIR_NONE;
nsAutoCString stockID;
bool useIconName = false;
if (!forceDirection) {
direction = gtk_widget_get_default_direction();
stockID = stockIcon;
} else {
// GTK versions < 2.22 use icon names from concatenating stock id with
// -(rtl|ltr), which is how the moz-icon stock name is interpreted here.
stockID = Substring(stockIcon, 0, stockIcon.Length() - 4);
// However, if we lookup bidi icons by the stock name, then GTK versions
// >= 2.22 will use a bidi lookup convention that most icon themes do not
// yet follow. Therefore, we first check to see if the theme supports the
// old icon name as this will have bidi support (if found).
GtkIconTheme *icon_theme = gtk_icon_theme_get_default();
// Micking what gtk_icon_set_render_icon does with sizes, though it's not
// critical as icons will be scaled to suit size. It just means we follow
// the same pathes and so share caches.
gint width, height;
if (gtk_icon_size_lookup(icon_size, &width, &height)) {
gint size = NS_MIN(width, height);
// We use gtk_icon_theme_lookup_icon() without
// GTK_ICON_LOOKUP_USE_BUILTIN instead of gtk_icon_theme_has_icon() so
// we don't pick up fallback icons added by distributions for backward
// compatibility.
GtkIconInfo *icon =
gtk_icon_theme_lookup_icon(icon_theme, stockIcon.get(),
size, (GtkIconLookupFlags)0);
if (icon) {
useIconName = true;
gtk_icon_info_free(icon);
}
}
}
ensure_stock_image_widget();
GtkStyle *style = gtk_widget_get_style(gStockImageWidget);
GtkIconSet *icon_set = NULL;
if (!useIconName) {
icon_set = gtk_style_lookup_icon_set(style, stockID.get());
}
if (!icon_set) {
// Either we have choosen icon-name lookup for a bidi icon, or stockIcon is
// not a stock id so we assume it is an icon name.
useIconName = true;
// Creating a GtkIconSet is a convenient way to allow the style to
// render the icon, possibly with variations suitable for insensitive
// states.
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_source_free(icon_source);
}
GdkPixbuf *icon =
gtk_icon_set_render_icon (icon_set, style, direction, state,
icon_size, gStockImageWidget, NULL);
if (useIconName) {
gtk_icon_set_unref(icon_set);
}
// According to documentation, gtk_icon_set_render_icon() never returns
// NULL, but it does return NULL when we have the problem reported here:
// https://bugzilla.gnome.org/show_bug.cgi?id=629878#c13
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;
}