GuMenuGui* menugui_init(GtkBuilder* builder)
{
g_return_val_if_fail(GTK_IS_BUILDER(builder), NULL);
GuMenuGui* m = g_new0(GuMenuGui, 1);
m->menu_projcreate = GTK_MENU_ITEM(
gtk_builder_get_object(builder, "menu_projcreate"));
m->menu_projopen = GTK_MENU_ITEM(
gtk_builder_get_object(builder, "menu_projopen"));
m->menu_projclose = GTK_MENU_ITEM(
gtk_builder_get_object(builder, "menu_projclose"));
m->menu_cut = GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_cut"));
m->menu_copy = GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_copy"));
#ifdef WIN32
// Please do NOT enable for nix, it has no place on a free OS ;)
GtkWidget* donate =
gtk_image_menu_item_new_with_label("Support this Project");
gtk_image_menu_item_set_image
(GTK_IMAGE_MENU_ITEM(donate),
GTK_WIDGET(gtk_image_new_from_stock(
GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_MENU)));
GtkWidget* helpmenu =
GTK_WIDGET(gtk_builder_get_object(builder, "menu11"));
gtk_menu_prepend(GTK_MENU(helpmenu), donate);
gtk_signal_connect_object(GTK_OBJECT(donate), "activate",
GTK_SIGNAL_FUNC(on_menu_donate_activate),
NULL);
#endif
/* TODO: There has to be a better way than this.. (bug 246)
GtkSettings *settings = gtk_settings_get_default();
gchar *iconsizes;
g_object_get(settings, "gtk-icon-sizes", &iconsizes, NULL);
if (iconsizes != NULL) {
printf("%s\n", iconsizes);
}*/
#ifdef WIN32
// The 2 non-stock menu items have their pixel size values set
// to the default 16x16 in GLADE. The normal icon-size value is
// normally set by the GTK theme in gtkrc. For themes using
// non-default icon sizes or Windows, this 16x16 value will be
// wrong. This code sets it to match the gtkrc file that we
// supply with the Windows builds:
GtkWidget* export = gtk_image_menu_item_get_image(
GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "menu_export")));
GtkWidget* update = gtk_image_menu_item_get_image(
GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "menu_update")));
gtk_image_set_pixel_size(GTK_IMAGE(export), 13);
gtk_image_set_pixel_size(GTK_IMAGE(update), 13);
#endif
return m;
}
static void
set_have_icons (AppearanceData *data, gboolean value)
{
static const char *menu_item_names[] = {
"menu_item_1",
"menu_item_2",
"menu_item_3",
"menu_item_4",
"menu_item_5",
"cut",
"copy",
"paste",
NULL
};
const char **name;
for (name = menu_item_names; *name != NULL; name++) {
GtkImageMenuItem *item = GTK_IMAGE_MENU_ITEM (glade_xml_get_widget (data->xml, *name));
GtkWidget *image;
if (value) {
image = g_object_get_data (G_OBJECT (item), "image");
if (image) {
gtk_image_menu_item_set_image (item, image);
g_object_unref (image);
}
} else {
image = gtk_image_menu_item_get_image (item);
g_object_set_data (G_OBJECT (item), "image", image);
g_object_ref (image);
gtk_image_menu_item_set_image (item, NULL);
}
}
}
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;
}
static void
set_item_stock (GtkWidget *mi,
const char *stock_id)
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (mi));
if (stock_id == NULL)
{
if (image != NULL)
gtk_widget_destroy (image);
return;
}
if (image == NULL)
{
image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image);
}
else
{
gtk_image_set_from_stock (GTK_IMAGE (image), stock_id,
GTK_ICON_SIZE_MENU);
}
}
static void
image_clicked_cb (GtkWidget *widget, gpointer data)
{
gtk_image_set_from_stock (GTK_IMAGE (gtk_image_menu_item_get_image (
GTK_IMAGE_MENU_ITEM (widget))),
GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
}
static void
gtk_image_menu_item_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (object);
switch (prop_id)
{
case PROP_IMAGE:
g_value_set_object (value, gtk_image_menu_item_get_image (image_menu_item));
break;
case PROP_USE_STOCK:
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
g_value_set_boolean (value, gtk_image_menu_item_get_use_stock (image_menu_item));
G_GNUC_END_IGNORE_DEPRECATIONS;
break;
case PROP_ALWAYS_SHOW_IMAGE:
g_value_set_boolean (value, gtk_image_menu_item_get_always_show_image (image_menu_item));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
menuitem_style_set_cb (GtkWidget *menuitem,
GtkStyle *old_style,
ShellStatusMenu *status)
{
GtkWidget *image;
const char *icon_name;
ShellStatusMenuPrivate *priv = status->priv;
if (menuitem == priv->login_screen_item)
icon_name = "system-users";
else if (menuitem == priv->lock_screen_item)
icon_name = "system-lock-screen";
else if (menuitem == priv->quit_session_item)
icon_name = "system-log-out";
else if (menuitem == priv->account_item)
icon_name = "user-info";
else if (menuitem == priv->control_panel_item)
icon_name = "preferences-desktop";
else
icon_name = GTK_STOCK_MISSING_IMAGE;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (menuitem));
gtk_image_set_pixel_size (GTK_IMAGE (image), priv->pixel_size);
gtk_image_set_from_icon_name (GTK_IMAGE (image), icon_name, priv->icon_size);
}
static void
set_action_image_temporary_visibility (NemoContextMenuMenuItem *item,
gboolean visible)
{
GtkWidget *image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (item));
if (!visible) {
gtk_widget_set_visible (image, FALSE);
} else {
if (gtk_image_menu_item_get_always_show_image (GTK_IMAGE_MENU_ITEM (item))) {
gtk_widget_set_visible (image, TRUE);
}
}
}
static void
panel_desktop_menu_item_on_presence_changed (PanelSessionManager *manager,
PanelSessionManagerPresenceType presence_type,
PanelDesktopMenuItem *desktop_item)
{
const char *icon;
GtkWidget *image;
GList *l;
switch (presence_type) {
case PANEL_SESSION_MANAGER_PRESENCE_AVAILABLE:
icon = PANEL_ICON_USER_AVAILABLE;
break;
case PANEL_SESSION_MANAGER_PRESENCE_INVISIBLE:
icon = PANEL_ICON_USER_INVISIBLE;
break;
case PANEL_SESSION_MANAGER_PRESENCE_BUSY:
icon = PANEL_ICON_USER_BUSY;
break;
case PANEL_SESSION_MANAGER_PRESENCE_IDLE:
default:
icon = PANEL_ICON_USER_IDLE;
break;
}
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (desktop_item));
/* we only have an image if we are specifically using an icon for this
* menu */
if (image) {
gtk_image_set_from_icon_name (GTK_IMAGE (image),
icon, panel_menu_icon_get_size ());
}
for (l = desktop_item->priv->presence_items; l != NULL; l = l->next) {
PanelSessionManagerPresenceType for_presence;
GObject *object = l->data;
for_presence = GPOINTER_TO_INT (g_object_get_data (object,
"panel-menu-presence"));
g_signal_handlers_block_by_func (object,
panel_menu_item_activate_presence,
desktop_item->priv->account_manager);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (object),
for_presence == presence_type);
g_signal_handlers_unblock_by_func (object,
panel_menu_item_activate_presence,
desktop_item->priv->account_manager);
}
}
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);
}
}
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 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;
}
static void
item_activated (GtkMenuItem * item, gpointer picker)
{
NldSearchContextPickerPrivate *priv = NLD_SEARCH_CONTEXT_PICKER_GET_PRIVATE (picker);
GtkImage *image;
const char *icon_name;
GtkIconSize icon_size;
image = GTK_IMAGE (gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (item)));
gtk_image_get_icon_name (image, &icon_name, &icon_size);
gtk_image_set_from_icon_name (priv->cur_icon, icon_name, icon_size);
priv->cur_context =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item),
"NldSearchContextPicker:context_id"));
g_signal_emit (picker, signals[CONTEXT_CHANGED], 0);
}
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);
}
int
clip_GTK_IMAGEMENUITEMGETIMAGE(ClipMachine * cm)
{
C_widget *cimgitem = _fetch_cw_arg(cm);
C_widget *cimage ;
GtkWidget *image ;
CHECKARG2(1,MAP_t, NUMERIC_t); CHECKCWID(cimgitem, GTK_IS_IMAGE_MENU_ITEM);
image = gtk_image_menu_item_get_image(GTK_IMAGE_MENU_ITEM(cimgitem->widget));
if (image)
{
cimage = _list_get_cwidget(cm, image);
if (!cimage) cimage = _register_widget(cm, image, NULL);
if (cimage) _clip_mclone(cm, RETPTR(cm), &cimage->obj);
}
return 0;
err:
return 1;
}
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);
}
static void
mateconf_bookmarks_set_item_has_icon (GtkWidget *item,
gboolean have_icons)
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (item));
if (image && !g_object_get_data (G_OBJECT (item), "mateconf-editor-icon"))
g_object_set_data_full (G_OBJECT (item), "mateconf-editor-icon",
g_object_ref (image), g_object_unref);
if (!image)
image = g_object_get_data (G_OBJECT (item), "mateconf-editor-icon");
if (!image)
return;
if (have_icons)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
else
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), NULL);
}
static void gtkItemUpdateImage(Ihandle* ih, const char* value, const char* image, const char* impress)
{
GdkPixbuf* pixbuf;
if (!impress || !iupStrBoolean(value))
pixbuf = iupImageGetImage(image, ih, 0);
else
pixbuf = iupImageGetImage(impress, ih, 0);
if (pixbuf)
{
GtkWidget* image_label = gtk_image_menu_item_get_image((GtkImageMenuItem*)ih->handle);
if (!image_label)
{
image_label = gtk_image_new();
gtk_image_menu_item_set_image((GtkImageMenuItem*)ih->handle, image_label);
}
if (pixbuf != gtk_image_get_pixbuf((GtkImage*)image_label))
gtk_image_set_from_pixbuf((GtkImage*)image_label, pixbuf);
}
else
gtk_image_menu_item_set_image((GtkImageMenuItem*)ih->handle, NULL);
}
static void serializer_visit_menuitem (Serializer* self, GtkMenuItem* menuitem) {
char* _tmp0_;
gboolean _tmp2_ = FALSE;
g_return_if_fail (self != NULL);
g_return_if_fail (menuitem != NULL);
if (GTK_IS_TEAROFF_MENU_ITEM (menuitem)) {
return;
}
serializer_indent (self);
g_string_append (self->priv->sb, "<item");
g_string_append (self->priv->sb, _tmp0_ = g_markup_printf_escaped (" id=\"W%lu\"", (gulong) menuitem));
_g_free0 (_tmp0_);
if (self->priv->hybrid) {
g_string_append (self->priv->sb, " client-side=\"1\"");
}
g_string_erase (self->priv->label_sb, (gssize) 0, (gssize) (-1));
self->priv->last_item_empty = TRUE;
self->priv->guessed_type = NULL;
serializer_visit_container (self, (GtkContainer*) menuitem);
if (self->priv->label_sb->len > 0) {
char* _tmp1_;
g_string_append (self->priv->sb, _tmp1_ = g_markup_printf_escaped (" label=\"%s\"", self->priv->label_sb->str));
_g_free0 (_tmp1_);
self->priv->last_item_empty = FALSE;
}
if (GTK_IS_SEPARATOR_MENU_ITEM (menuitem)) {
_tmp2_ = TRUE;
} else {
_tmp2_ = gtk_bin_get_child ((GtkBin*) menuitem) == NULL;
}
if (_tmp2_) {
self->priv->guessed_type = "s";
self->priv->last_item_empty = FALSE;
}
if (GTK_IS_IMAGE_MENU_ITEM (menuitem)) {
GtkMenuItem* _tmp3_;
GtkWidget* _tmp4_;
GtkImage* image;
image = _g_object_ref0 ((_tmp4_ = gtk_image_menu_item_get_image ((_tmp3_ = menuitem, GTK_IS_IMAGE_MENU_ITEM (_tmp3_) ? ((GtkImageMenuItem*) _tmp3_) : NULL)), GTK_IS_IMAGE (_tmp4_) ? ((GtkImage*) _tmp4_) : NULL));
if (image != NULL) {
self->priv->guessed_type = "i";
serializer_append_icon_attribute (self, image);
self->priv->last_item_empty = FALSE;
}
_g_object_unref0 (image);
}
if (GTK_IS_CHECK_MENU_ITEM (menuitem)) {
GtkMenuItem* _tmp5_;
GtkCheckMenuItem* checkmenuitem;
checkmenuitem = _g_object_ref0 ((_tmp5_ = menuitem, GTK_IS_CHECK_MENU_ITEM (_tmp5_) ? ((GtkCheckMenuItem*) _tmp5_) : NULL));
if (gtk_check_menu_item_get_draw_as_radio (checkmenuitem)) {
self->priv->guessed_type = "r";
} else {
self->priv->guessed_type = "c";
}
if (!gtk_check_menu_item_get_inconsistent (checkmenuitem)) {
if (gtk_check_menu_item_get_active (checkmenuitem)) {
g_string_append (self->priv->sb, " state=\"1\"");
} else {
g_string_append (self->priv->sb, " state=\"0\"");
}
}
self->priv->last_item_empty = FALSE;
_g_object_unref0 (checkmenuitem);
}
if (gtk_widget_get_visible ((GtkWidget*) menuitem) == FALSE) {
g_string_append (self->priv->sb, " visible=\"0\"");
self->priv->last_item_empty = FALSE;
}
if (gtk_widget_get_sensitive ((GtkWidget*) menuitem) == FALSE) {
g_string_append (self->priv->sb, " sensitive=\"0\"");
}
if (self->priv->last_item_empty) {
g_string_append (self->priv->sb, " visible=\"0\"");
}
if (self->priv->guessed_type != NULL) {
g_string_append_printf (self->priv->sb, " type=\"%s\"", self->priv->guessed_type);
}
if (gtk_menu_item_get_submenu (menuitem) == NULL) {
g_string_append (self->priv->sb, "/>");
serializer_linebreak (self);
} else {
g_string_append_c (self->priv->sb, '>');
serializer_linebreak (self);
self->priv->level++;
if (gtk_menu_item_get_submenu (menuitem) != NULL) {
serializer_visit_menu (self, gtk_menu_item_get_submenu (menuitem));
}
self->priv->level--;
serializer_indent (self);
g_string_append (self->priv->sb, "</item>");
serializer_linebreak (self);
}
}
static void
gimp_action_set_proxy (GimpAction *action,
GtkWidget *proxy)
{
if (! GTK_IS_IMAGE_MENU_ITEM (proxy))
return;
if (action->color)
{
GtkWidget *area;
area = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_COLOR_AREA (area))
{
gimp_color_area_set_color (GIMP_COLOR_AREA (area), action->color);
}
else
{
gint width, height;
area = gimp_color_area_new (action->color,
GIMP_COLOR_AREA_SMALL_CHECKS, 0);
gimp_color_area_set_draw_border (GIMP_COLOR_AREA (area), TRUE);
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
GTK_ICON_SIZE_MENU,
&width, &height);
gtk_widget_set_size_request (area, width, height);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), area);
gtk_widget_show (area);
}
}
else if (action->viewable)
{
GtkWidget *view;
view = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (view) &&
g_type_is_a (G_TYPE_FROM_INSTANCE (action->viewable),
GIMP_VIEW (view)->renderer->viewable_type))
{
gimp_view_set_viewable (GIMP_VIEW (view), action->viewable);
}
else
{
GtkIconSize size;
gint width, height;
gint border_width;
if (GIMP_IS_IMAGEFILE (action->viewable))
{
size = GTK_ICON_SIZE_LARGE_TOOLBAR;
border_width = 0;
}
else
{
size = GTK_ICON_SIZE_MENU;
border_width = 1;
}
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
size, &width, &height);
view = gimp_view_new_full (action->context, action->viewable,
width, height, border_width,
FALSE, FALSE, FALSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), view);
gtk_widget_show (view);
}
}
else
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (image) || GIMP_IS_COLOR_AREA (image))
{
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), NULL);
g_object_notify (G_OBJECT (action), "stock-id");
}
}
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (proxy));
if (GTK_IS_LABEL (child))
{
GtkLabel *label = GTK_LABEL (child);
gtk_label_set_ellipsize (label, action->ellipsize);
gtk_label_set_max_width_chars (label, action->max_width_chars);
}
}
}
