static GtkImage*
get_image_from_button (GtkWidget *button)
{
GtkWidget *child;
GList *list;
GtkImage *image = NULL;
child = gtk_bin_get_child (GTK_BIN (button));
if (GTK_IS_IMAGE (child))
image = GTK_IMAGE (child);
else
{
if (GTK_IS_ALIGNMENT (child))
child = gtk_bin_get_child (GTK_BIN (child));
if (GTK_IS_CONTAINER (child))
{
list = gtk_container_get_children (GTK_CONTAINER (child));
if (!list)
return NULL;
if (GTK_IS_IMAGE (list->data))
image = GTK_IMAGE (list->data);
g_list_free (list);
}
}
return image;
}
static void serializer_visit (Serializer* self, GtkWidget* widget) {
g_return_if_fail (self != NULL);
g_return_if_fail (widget != NULL);
if (GTK_IS_MENU_BAR (widget)) {
GtkWidget* _tmp0_;
serializer_visit_menubar (self, (_tmp0_ = widget, GTK_IS_MENU_BAR (_tmp0_) ? ((GtkMenuBar*) _tmp0_) : NULL));
} else {
if (GTK_IS_MENU (widget)) {
GtkWidget* _tmp1_;
serializer_visit_menu (self, (_tmp1_ = widget, GTK_IS_MENU (_tmp1_) ? ((GtkMenu*) _tmp1_) : NULL));
} else {
if (GTK_IS_MENU_ITEM (widget)) {
GtkWidget* _tmp2_;
serializer_visit_menuitem (self, (_tmp2_ = widget, GTK_IS_MENU_ITEM (_tmp2_) ? ((GtkMenuItem*) _tmp2_) : NULL));
} else {
if (GTK_IS_LABEL (widget)) {
GtkWidget* _tmp3_;
serializer_visit_label (self, (_tmp3_ = widget, GTK_IS_LABEL (_tmp3_) ? ((GtkLabel*) _tmp3_) : NULL));
} else {
if (GTK_IS_IMAGE (widget)) {
GtkWidget* _tmp4_;
serializer_visit_image (self, (_tmp4_ = widget, GTK_IS_IMAGE (_tmp4_) ? ((GtkImage*) _tmp4_) : NULL));
} else {
if (GTK_IS_CONTAINER (widget)) {
GtkWidget* _tmp5_;
serializer_visit_container (self, (_tmp5_ = widget, GTK_IS_CONTAINER (_tmp5_) ? ((GtkContainer*) _tmp5_) : NULL));
}
}
}
}
}
}
}
static void
set_image (MateComponentUIToolbarButtonItem *button_item,
gpointer image)
{
gboolean is_pixbuf;
gboolean is_gtk_image;
MateComponentUIToolbarButtonItemPrivate *priv;
priv = button_item->priv;
is_pixbuf = image && GDK_IS_PIXBUF (image);
is_gtk_image = priv->icon && GTK_IS_IMAGE (priv->icon);
if (is_pixbuf && is_gtk_image)
matecomponent_ui_image_set_pixbuf ((GtkImage *) priv->icon, image);
else {
if (priv->icon)
gtk_widget_destroy (priv->icon);
if (is_pixbuf)
priv->icon = gtk_image_new_from_pixbuf (image);
else {
g_return_if_fail (!image || GTK_IS_WIDGET (image));
priv->icon = image;
}
}
}
void
gimp_throbber_set_image (GimpThrobber *button,
GtkWidget *image)
{
g_return_if_fail (GIMP_IS_THROBBER (button));
g_return_if_fail (image == NULL || GTK_IS_IMAGE (image));
if (image != button->priv->image)
{
if (button->priv->image)
{
if (gtk_widget_get_parent (button->priv->image))
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (button->priv->image)),
button->priv->image);
g_object_unref (button->priv->image);
}
if (image)
g_object_ref_sink (image);
button->priv->image = image;
gimp_throbber_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "image");
}
}
void abi_table_set_icon(AbiTable* abi_table,GtkWidget * gtkImageIcon)
{
if(!GTK_IS_IMAGE(G_OBJECT(gtkImageIcon)))
return;
g_object_unref (G_OBJECT (abi_table->icon));
abi_table->icon = gtkImageIcon;
}
static gboolean
activatable_update_gicon (GtkImageMenuItem *image_menu_item, GtkAction *action)
{
GtkWidget *image;
GIcon *icon = gtk_action_get_gicon (action);
const gchar *stock_id;
gboolean ret = FALSE;
stock_id = gtk_action_get_stock_id (action);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
image = gtk_image_menu_item_get_image (image_menu_item);
if (icon && GTK_IS_IMAGE (image) &&
!(stock_id && gtk_icon_factory_lookup_default (stock_id)))
{
gtk_image_set_from_gicon (GTK_IMAGE (image), icon, GTK_ICON_SIZE_MENU);
ret = TRUE;
}
G_GNUC_END_IGNORE_DEPRECATIONS;
return ret;
}
void wxAnyButton::GTKDoShowBitmap(const wxBitmap& bitmap)
{
wxASSERT_MSG( bitmap.IsOk(), "invalid bitmap" );
GtkWidget *image;
if ( DontShowLabel() )
{
image = gtk_bin_get_child(GTK_BIN(m_widget));
}
else // have both label and bitmap
{
#ifdef __WXGTK26__
if ( !gtk_check_version(2,6,0) )
{
image = gtk_button_get_image(GTK_BUTTON(m_widget));
}
else
#endif // __WXGTK26__
{
// buttons with both label and bitmap are only supported with GTK+
// 2.6 so far
//
// it shouldn't be difficult to implement them ourselves for the
// previous GTK+ versions by stuffing a container with a label and
// an image inside GtkButton but there doesn't seem to be much
// point in doing this for ancient GTK+ versions
return;
}
}
wxCHECK_RET( image && GTK_IS_IMAGE(image), "must have image widget" );
gtk_image_set_from_pixbuf(GTK_IMAGE(image), bitmap.GetPixbuf());
}
static const gchar *
gtk_button_accessible_get_name (AtkObject *obj)
{
const gchar *name = NULL;
GtkWidget *widget;
GtkWidget *child;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
return NULL;
name = ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
child = get_label_from_button (widget);
if (GTK_IS_LABEL (child))
name = gtk_label_get_text (GTK_LABEL (child));
else
{
GtkWidget *image;
image = get_image_from_button (widget);
if (GTK_IS_IMAGE (image))
{
AtkObject *atk_obj;
atk_obj = gtk_widget_get_accessible (image);
name = atk_object_get_name (atk_obj);
}
}
return name;
}
static void
gwy_sensitivity_group_debug(GwySensitivityGroup *sensgroup)
{
SensList *senslist;
GtkWidget *widget, *w;
GList *l, *ll;
const gchar *s;
gint nw = 0;
g_printerr("SENS GROUP %p\n", sensgroup);
for (ll = sensgroup->lists; ll; ll = g_list_next(ll)) {
g_printerr(" LIST: ");
senslist = (SensList*)ll->data;
g_printerr("mask=%04x, dirty=%d, parent=%p\n",
senslist->mask, senslist->dirty, senslist->parent);
for (l = senslist->widgets; l; l = g_list_next(l)) {
nw++;
g_printerr(" WIDGET: ");
widget = GTK_WIDGET(l->data);
g_printerr("%s ", g_type_name(G_TYPE_FROM_INSTANCE(widget)));
if (GTK_IS_BUTTON(widget)) {
s = gtk_button_get_label(GTK_BUTTON(widget));
if (s)
g_printerr("<%s> ", s);
else {
w = gtk_bin_get_child(GTK_BIN(widget));
if (w) {
g_printerr("%s ", g_type_name(G_TYPE_FROM_INSTANCE(w)));
if (GTK_IS_LABEL(w)) {
s = gtk_label_get_text(GTK_LABEL(w));
if (s)
g_printerr("<%s> ", s);
}
else if (GTK_IS_IMAGE(w)) {
s = NULL;
gtk_image_get_stock(GTK_IMAGE(w), (gchar**)&s,
NULL);
if (s)
g_printerr("<%s> ", s);
}
}
}
}
else if (GTK_IS_MENU_ITEM(widget)) {
w = gtk_bin_get_child(GTK_BIN(widget));
if (w) {
g_printerr("%s ", g_type_name(G_TYPE_FROM_INSTANCE(w)));
if (GTK_IS_LABEL(w)) {
s = gtk_label_get_text(GTK_LABEL(w));
if (s)
g_printerr("<%s> ", s);
}
}
}
g_printerr("\n");
}
}
g_printerr(" nwidgets=%d, ref_count=%d\n",
nw, G_OBJECT(sensgroup)->ref_count);
}
/* consumes reference on icon */
static void _lxpanel_button_set_icon(GtkWidget* btn, FmIcon* icon, gint size)
{
/* Locate the image within the button. */
GtkWidget * child = gtk_bin_get_child(GTK_BIN(btn));
GtkWidget * img = NULL;
if (GTK_IS_IMAGE(child))
img = child;
else if (GTK_IS_BOX(child))
{
GList * children = gtk_container_get_children(GTK_CONTAINER(child));
img = GTK_WIDGET(GTK_IMAGE(children->data));
g_list_free(children);
}
if (img != NULL)
{
ImgData * data = (ImgData *) g_object_get_qdata(G_OBJECT(img), img_data_id);
if (icon != data->icon || size != data->size) /* something was changed */
{
g_object_unref(data->icon);
data->icon = icon;
data->size = size;
_gtk_image_set_from_file_scaled(img, data);
}
else
g_object_unref(icon);
}
else
g_object_unref(icon);
}
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (item);
GtkWidget *menu_item;
GtkWidget *menu_image = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
if (GTK_IS_LABEL (button->priv->label_widget))
{
label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
}
else if (button->priv->label_text)
{
label = button->priv->label_text;
use_mnemonic = button->priv->use_underline;
}
else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_image_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_image_menu_item_new_with_label (label);
if (GTK_IS_IMAGE (button->priv->icon_widget))
{
menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),
gtk_widget_get_settings (GTK_WIDGET (button)));
}
else if (button->priv->stock_id)
{
menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
}
if (menu_image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
return TRUE;
}
/**
* 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
gnac_properties_reset_field(GtkWidget *widget)
{
if (GTK_IS_ENTRY(widget)) {
gtk_entry_set_text(GTK_ENTRY(widget), "");
} else if (GTK_IS_IMAGE(widget)) {
gtk_image_clear(GTK_IMAGE(widget));
}
}
/**
@brief set new (or no) icon for existing button @a button
e2 uses non-standard dialog buttons, containing alignment containing h/vbox,
the latter with image (if any) packed first. @a stock may be a gtk stock name
or a custom icon filename. The new image is shown immediately, so this func is
not intended for buttons which are ultimately included in a "show all".
@param button the button widget to be updated
@param stock string describing icon or NULL to clear the icon
@return
*/
void e2_button_set_image (GtkWidget *button, gchar *stock)
{
gint choice = e2_option_sel_get ("dialog-button-icons");
if (choice == 0)
{
#ifdef USE_GTK2_18
gboolean show;
GtkSettings* defs = gtk_settings_get_default ();
g_object_get (G_OBJECT (defs), "gtk-button-images", &show, NULL);
if (show)
#endif
choice = 1;
}
if (choice == 1)
{
GtkWidget *image = (stock != NULL) ?
e2_widget_get_icon (stock, GTK_ICON_SIZE_BUTTON) : NULL;
if (stock == NULL || image != NULL)
{
GtkWidget *bbox =
#ifdef USE_GTK2_14
gtk_bin_get_child (GTK_BIN (button));
bbox = gtk_bin_get_child (GTK_BIN (bbox));
GList *children = gtk_container_get_children (GTK_CONTAINER (bbox));
GtkWidget *child1 = (GtkWidget *) children->data;
if (GTK_IS_IMAGE (child1))
gtk_container_remove (GTK_CONTAINER (bbox), child1);
g_list_free (children);
#else
GTK_BIN (GTK_BIN (button)->child)->child;
GtkBoxChild *child1 = (GtkBoxChild *) GTK_BOX (bbox)->children->data;
if (GTK_IS_IMAGE (child1->widget))
gtk_container_remove (GTK_CONTAINER (bbox), child1->widget);
#endif
if (image != NULL)
{
gtk_box_pack_start (GTK_BOX (bbox), image, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (bbox), image, 0);
gtk_widget_show (image);
}
}
}
}
static void style_changed_cb(GtkWidget *widget, gpointer user_data)
{
IndicatorFitbit *self = INDICATOR_FITBIT(user_data);
g_return_if_fail(GTK_IS_IMAGE(widget));
g_return_if_fail(IS_INDICATOR_FITBIT(user_data));
load_all_pixbufs(self);
update_icon(self);
}
static GtkWidget *
get_image_from_button (GtkWidget *button)
{
GtkWidget *image;
image = gtk_bin_get_child (GTK_BIN (button));
if (GTK_IS_IMAGE (image))
return image;
return NULL;
}
void file_chooser_preview_img (FileChooser *chooser, gpointer user_data)
{
g_assert(GTK_IS_IMAGE(user_data));
gchar *filename = file_chooser_get_filename(chooser);
if(g_file_test(filename, G_FILE_TEST_IS_REGULAR))
{
file_chooser_set_preview_widget_active(chooser, TRUE);
gtk_image_set_from_file( GTK_IMAGE(user_data), filename);
} else
file_chooser_set_preview_widget_active(chooser, FALSE);
g_free(filename);
}
/**
* sexy_icon_entry_set_icon
* @entry: A #SexyIconEntry.
* @position: Icon position.
* @icon: A #GtkImage to set as the icon.
*
* Sets the icon shown in the entry
*/
void
sexy_icon_entry_set_icon(SexyIconEntry *entry, SexyIconEntryPosition icon_pos,
GtkImage *icon)
{
SexyIconInfo *icon_info;
g_return_if_fail(entry != NULL);
g_return_if_fail(SEXY_IS_ICON_ENTRY(entry));
g_return_if_fail(IS_VALID_ICON_ENTRY_POSITION(icon_pos));
g_return_if_fail(icon == NULL || GTK_IS_IMAGE(icon));
icon_info = &entry->priv->icons[icon_pos];
if (icon == icon_info->icon)
return;
if (icon_pos == SEXY_ICON_ENTRY_SECONDARY &&
entry->priv->icon_released_id != 0)
{
g_signal_handler_disconnect(entry, entry->priv->icon_released_id);
entry->priv->icon_released_id = 0;
}
if (icon == NULL)
{
if (icon_info->icon != NULL)
{
gtk_widget_destroy(GTK_WIDGET(icon_info->icon));
icon_info->icon = NULL;
/*
* Explicitly check, as the pointer may become invalidated
* during destruction.
*/
if (icon_info->window != NULL && GDK_IS_WINDOW(icon_info->window))
gdk_window_hide(icon_info->window);
}
}
else
{
if (icon_info->window != NULL && icon_info->icon == NULL)
gdk_window_show(icon_info->window);
g_signal_connect(G_OBJECT(icon), "notify",
G_CALLBACK(update_icon), entry);
icon_info->icon = icon;
g_object_ref(icon);
}
update_icon(NULL, NULL, entry);
}
static void
glade_gtk_image_set_image_mode (GObject *object, const GValue *value)
{
GladeWidget *gwidget;
GladeImageEditMode type;
gwidget = glade_widget_get_from_gobject (object);
g_return_if_fail (GTK_IS_IMAGE (object));
g_return_if_fail (GLADE_IS_WIDGET (gwidget));
glade_widget_property_set_sensitive (gwidget, "stock", FALSE,
NOT_SELECTED_MSG);
glade_widget_property_set_sensitive (gwidget, "icon-name", FALSE,
NOT_SELECTED_MSG);
glade_widget_property_set_sensitive (gwidget, "pixbuf", FALSE,
NOT_SELECTED_MSG);
glade_widget_property_set_sensitive (gwidget, "resource", FALSE,
NOT_SELECTED_MSG);
glade_widget_property_set_sensitive (gwidget, "icon-size", FALSE,
_("This property only applies to stock images or named icons"));
glade_widget_property_set_sensitive (gwidget, "pixel-size", FALSE,
_("This property only applies to named icons"));
glade_widget_property_set_sensitive (gwidget, "use-fallback", FALSE,
_("This property only applies to named icons"));
switch ((type = g_value_get_int (value)))
{
case GLADE_IMAGE_MODE_STOCK:
glade_widget_property_set_sensitive (gwidget, "stock", TRUE, NULL);
glade_widget_property_set_sensitive (gwidget, "icon-size", TRUE, NULL);
break;
case GLADE_IMAGE_MODE_ICON:
glade_widget_property_set_sensitive (gwidget, "icon-name", TRUE, NULL);
glade_widget_property_set_sensitive (gwidget, "icon-size", TRUE, NULL);
glade_widget_property_set_sensitive (gwidget, "pixel-size", TRUE, NULL);
glade_widget_property_set_sensitive (gwidget, "use-fallback", TRUE, NULL);
break;
case GLADE_IMAGE_MODE_RESOURCE:
glade_widget_property_set_sensitive (gwidget, "resource", TRUE, NULL);
break;
case GLADE_IMAGE_MODE_FILENAME:
glade_widget_property_set_sensitive (gwidget, "pixbuf", TRUE, NULL);
default:
break;
}
}
void
gimp_editor_set_box_style (GimpEditor *editor,
GtkBox *box)
{
GtkIconSize button_icon_size;
gint button_spacing;
GtkReliefStyle button_relief;
GList *children;
GList *list;
g_return_if_fail (GIMP_IS_EDITOR (editor));
g_return_if_fail (GTK_IS_BOX (box));
gtk_widget_style_get (GTK_WIDGET (editor),
"button-icon-size", &button_icon_size,
"button-spacing", &button_spacing,
"button-relief", &button_relief,
NULL);
gtk_box_set_spacing (box, button_spacing);
children = gtk_container_get_children (GTK_CONTAINER (box));
for (list = children; list; list = g_list_next (list))
{
if (GTK_IS_BUTTON (list->data))
{
GtkWidget *child;
gtk_button_set_relief (GTK_BUTTON (list->data), button_relief);
child = gtk_bin_get_child (GTK_BIN (list->data));
if (GTK_IS_IMAGE (child))
{
GtkIconSize old_size;
gchar *stock_id;
gtk_image_get_stock (GTK_IMAGE (child), &stock_id, &old_size);
if (button_icon_size != old_size)
gtk_image_set_from_stock (GTK_IMAGE (child),
stock_id, button_icon_size);
}
}
}
g_list_free (children);
}
static GtkWidget *
gtk_image_menu_item_ensure_image (GtkImageMenuItem *item)
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (item);
if (!GTK_IS_IMAGE (image))
{
image = gtk_image_new ();
gtk_widget_show (image);
gtk_image_menu_item_set_image (item, image);
}
return image;
}
static void
activatable_update_icon_name (GtkImageMenuItem *image_menu_item, GtkAction *action)
{
GtkWidget *image;
const gchar *icon_name = gtk_action_get_icon_name (action);
image = gtk_image_menu_item_get_image (image_menu_item);
if (GTK_IS_IMAGE (image) &&
(gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_EMPTY ||
gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME))
{
gtk_image_set_from_icon_name (GTK_IMAGE (image), icon_name, GTK_ICON_SIZE_MENU);
}
}
GtkWidget* AbstractToolItem::getNewToolIcon()
{
XOJ_CHECK_TYPE(AbstractToolItem);
GtkWidget* icon = this->getNewToolIconImpl();
if (!GTK_IS_IMAGE(icon))
{
GdkPixbuf* pixbuf = Util::newPixbufFromWidget(icon);
gtk_widget_unref(icon);
icon = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
}
return icon;
}
application_icon_change_cb (DbusmenuMenuitem * mi, gchar * prop, GValue * value, gpointer user_data)
#endif
{
if (!g_strcmp0(prop, APPLICATION_MENUITEM_PROP_ICON)) {
/* Set the main icon */
if (GTK_IS_IMAGE(user_data)) {
#if (INDICATOR_OLD_NAMES == 0)
gtk_image_set_from_icon_name(GTK_IMAGE(user_data), g_variant_get_string(value, NULL), GTK_ICON_SIZE_MENU);
#else
gtk_image_set_from_icon_name(GTK_IMAGE(user_data), g_value_get_string(value), GTK_ICON_SIZE_MENU);
#endif
}
}
return;
}
static gboolean
activatable_update_stock_id (GtkImageMenuItem *image_menu_item, GtkAction *action)
{
GtkWidget *image;
const gchar *stock_id = gtk_action_get_stock_id (action);
image = gtk_image_menu_item_get_image (image_menu_item);
if (GTK_IS_IMAGE (image) &&
stock_id && gtk_icon_factory_lookup_default (stock_id))
{
gtk_image_set_from_stock (GTK_IMAGE (image), stock_id, GTK_ICON_SIZE_MENU);
return TRUE;
}
return FALSE;
}
void
balsa_mime_widget_image_resize_all(GtkWidget * widget, gpointer user_data)
{
if (GTK_IS_CONTAINER(widget))
gtk_container_foreach(GTK_CONTAINER(widget),
balsa_mime_widget_image_resize_all, NULL);
else if (GTK_IS_IMAGE(widget) &&
g_object_get_data(G_OBJECT(widget), "orig-width") &&
g_object_get_data(G_OBJECT(widget), "mime-body") &&
!GPOINTER_TO_INT(g_object_get_data
(G_OBJECT(widget), "check_size_sched"))) {
GtkWidget **widget_p = g_new(GtkWidget *, 1);
g_object_set_data(G_OBJECT(widget), "check_size_sched",
GINT_TO_POINTER(TRUE));
*widget_p = widget;
g_object_add_weak_pointer(G_OBJECT(widget), (gpointer) widget_p);
g_idle_add((GSourceFunc) img_check_size, widget_p);
}
void wxAnyButton::GTKDoShowBitmap(const wxBitmap& bitmap)
{
wxASSERT_MSG( bitmap.IsOk(), "invalid bitmap" );
GtkWidget *image;
if ( DontShowLabel() )
{
image = gtk_bin_get_child(GTK_BIN(m_widget));
}
else // have both label and bitmap
{
image = gtk_button_get_image(GTK_BUTTON(m_widget));
}
wxCHECK_RET( image && GTK_IS_IMAGE(image), "must have image widget" );
gtk_image_set_from_pixbuf(GTK_IMAGE(image), bitmap.GetPixbuf());
}
static G_CONST_RETURN gchar*
gail_button_get_name (AtkObject *obj)
{
G_CONST_RETURN gchar* name = NULL;
g_return_val_if_fail (GAIL_IS_BUTTON (obj), NULL);
name = ATK_OBJECT_CLASS (gail_button_parent_class)->get_name (obj);
if (name == NULL)
{
/*
* Get the text on the label
*/
GtkWidget *widget;
GtkWidget *child;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
/*
* State is defunct
*/
return NULL;
g_return_val_if_fail (GTK_IS_BUTTON (widget), NULL);
child = get_label_from_button (widget, 0, FALSE);
if (GTK_IS_LABEL (child))
name = gtk_label_get_text (GTK_LABEL (child));
else
{
GtkImage *image;
image = get_image_from_button (widget);
if (GTK_IS_IMAGE (image))
{
AtkObject *atk_obj;
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (image));
name = atk_object_get_name (atk_obj);
}
}
}
return name;
}
static void
menu_item_sync_action_properties (NemoContextMenuMenuItem *menu_item,
GtkAction *action)
{
GtkImageMenuItem *image_menu_item;
GtkActivatable *activatable;
GtkWidget *image;
gboolean use_appearance;
image_menu_item = GTK_IMAGE_MENU_ITEM (menu_item);
activatable = GTK_ACTIVATABLE (image_menu_item);
if (!action)
return;
use_appearance = gtk_activatable_get_use_action_appearance (activatable);
if (!use_appearance)
return;
image = gtk_image_menu_item_get_image (image_menu_item);
if (image && !GTK_IS_IMAGE (image)) {
gtk_image_menu_item_set_image (image_menu_item, NULL);
image = NULL;
}
if (!image) {
image = gtk_image_new ();
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (activatable),
image);
}
if (!activatable_update_stock_id (image_menu_item, action) &&
!activatable_update_gicon (image_menu_item, action))
activatable_update_icon_name (image_menu_item, action);
gtk_image_menu_item_set_always_show_image (image_menu_item,
gtk_action_get_always_show_image (action));
activatable_update_label (GTK_MENU_ITEM (menu_item), action);
}
static void
gtk_image_menu_item_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
GtkImageMenuItem *image_menu_item;
GtkWidget *image;
gboolean use_appearance;
image_menu_item = GTK_IMAGE_MENU_ITEM (activatable);
parent_activatable_iface->sync_action_properties (activatable, action);
if (!action)
return;
use_appearance = gtk_activatable_get_use_action_appearance (activatable);
if (!use_appearance)
return;
image = gtk_image_menu_item_get_image (image_menu_item);
if (image && !GTK_IS_IMAGE (image))
{
gtk_image_menu_item_set_image (image_menu_item, NULL);
image = NULL;
}
if (!image)
{
image = gtk_image_new ();
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (activatable),
image);
}
if (!activatable_update_stock_id (image_menu_item, action) &&
!activatable_update_gicon (image_menu_item, action))
activatable_update_icon_name (image_menu_item, action);
}
