void
db__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->action_group = gtk_action_group_new ("Desktop Background Actions");
gtk_action_group_set_translation_domain (data->action_group, NULL);
gtk_action_group_add_actions (data->action_group,
action_entries,
G_N_ELEMENTS (action_entries),
browser);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->action_group, 0);
if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_clear_error (&error);
}
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/FileListPopup/Screen_Actions/DesktopBackground")), TRUE);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/FilePopup/Screen_Actions/DesktopBackground")), TRUE);
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
static void
xmr_indicator_plugin_init(XmrIndicatorPlugin *plugin)
{
GtkWidget *item;
plugin->settings = g_settings_new("com.timxx.xmradio.plugins.indicator");
plugin->hide_on_exit = g_settings_get_boolean(plugin->settings, "hide-on-exit");
plugin->indicator = NULL;
plugin->popup_menu = gtk_menu_new();
item = gtk_image_menu_item_new_with_label(_("Show"));
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PLAY, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
plugin->menu_item_play = item;
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
plugin->menu_item_pause = item;
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_NEXT, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
item = gtk_image_menu_item_new_with_label(_("Love"));
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
item = gtk_image_menu_item_new_with_label(_("Hate"));
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_widget_show_all(plugin->popup_menu);
}
static void
status_icon_popup_menu_cb (GtkStatusIcon * icon, guint button, guint time)
{
GtkMenu *popup_menu = GTK_MENU (gtk_menu_new ());
GtkMenu *groups_menu = GTK_MENU (gtk_menu_new ());
int i = 0;
gchar **current_name = gkbd_status_get_group_names ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (_("_Groups"));
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
GTK_WIDGET (groups_menu));
item =
gtk_menu_item_new_with_mnemonic (_("Keyboard _Preferences"));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_launch_capplet,
NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
item = gtk_menu_item_new_with_mnemonic (_("Show Current _Layout"));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_show_layout, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
for (i = 0; *current_name; i++, current_name++) {
gchar *image_file = gkbd_status_get_image_filename (i);
if (image_file == NULL) {
item =
gtk_menu_item_new_with_label (*current_name);
} else {
GdkPixbuf *pixbuf =
gdk_pixbuf_new_from_file_at_size (image_file,
24, 24,
NULL);
GtkWidget *img =
gtk_image_new_from_pixbuf (pixbuf);
item =
gtk_image_menu_item_new_with_label
(*current_name);
gtk_widget_show (img);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM
(item), img);
gtk_image_menu_item_set_always_show_image
(GTK_IMAGE_MENU_ITEM (item), TRUE);
g_free (image_file);
}
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (groups_menu), item);
g_signal_connect (item, "activate",
G_CALLBACK (popup_menu_set_group),
GINT_TO_POINTER (i));
}
gtk_menu_popup (popup_menu, NULL, NULL,
gtk_status_icon_position_menu,
(gpointer) icon, button, time);
}
static void
gtk_image_menu_item_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
GtkImageMenuItem *image_menu_item;
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;
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));
}
/* This function shows a menu for the user to select which item to launch. */
void show_menu(pqi inst)
{
menu_iter iter; int i = 0,
orient = mate_panel_applet_get_orient(inst->applet);
GtkMenu* menu = GTK_MENU(gtk_menu_new());
gboolean reverse;
if (inst->clicked && inst->items)
{
reverse = (orient == MATE_PANEL_APPLET_ORIENT_UP);
for (reverse? menu_iterate_rbegin(inst,&iter,inst->show_primary):menu_iterate_begin(inst,&iter,inst->show_primary); iter.valid; menu_iter_next(&iter))
{
GtkWidget *mi = gtk_image_menu_item_new(),
*lbl = gtk_label_new(iter.text),
*icon = gtk_image_new_from_gicon(iter.icon, GTK_ICON_SIZE_DND);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), icon);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(mi), TRUE);
gtk_label_set_justify(GTK_LABEL(lbl),GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(lbl),0,0.5);
gtk_container_add(GTK_CONTAINER(mi),lbl);
gtk_widget_show_all(mi);
gtk_menu_insert(menu,mi,i++);
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_launch), iter.si);
}
gtk_menu_attach_to_widget(menu,inst->box,NULL);
gtk_menu_popup(menu,NULL,NULL,set_to_corner, inst, 1, 0);
}
inst->clicked = FALSE;
}
static void
gtk_image_menu_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (object);
switch (prop_id)
{
case PROP_IMAGE:
gtk_image_menu_item_set_image (image_menu_item, (GtkWidget *) g_value_get_object (value));
break;
case PROP_USE_STOCK:
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_image_menu_item_set_use_stock (image_menu_item, g_value_get_boolean (value));
G_GNUC_END_IGNORE_DEPRECATIONS;
break;
case PROP_ALWAYS_SHOW_IMAGE:
gtk_image_menu_item_set_always_show_image (image_menu_item, g_value_get_boolean (value));
break;
case PROP_ACCEL_GROUP:
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_image_menu_item_set_accel_group (image_menu_item, g_value_get_object (value));
G_GNUC_END_IGNORE_DEPRECATIONS;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GtkMenu *
create_status_menu (void)
{
GtkMenu *popup_menu = GTK_MENU (gtk_menu_new ());
int i = 0;
GtkMenu *groups_menu = GTK_MENU (gtk_menu_new ());
gchar **current_name = gkbd_status_get_group_names ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (_("_Layouts"));
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
GTK_WIDGET (groups_menu));
item = gtk_menu_item_new_with_mnemonic (_("Show _Keyboard Layout..."));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_show_layout, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
/* translators note:
* This is the name of the sagarmatha-settings "region" panel */
item = gtk_menu_item_new_with_mnemonic (_("Region and Language Settings"));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_launch_capplet, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
for (i = 0; current_name && *current_name; i++, current_name++) {
gchar *image_file = gkbd_status_get_image_filename (i);
if (image_file == NULL) {
item =
gtk_menu_item_new_with_label (*current_name);
} else {
GdkPixbuf *pixbuf =
gdk_pixbuf_new_from_file_at_size (image_file,
24, 24,
NULL);
GtkWidget *img =
gtk_image_new_from_pixbuf (pixbuf);
item =
gtk_image_menu_item_new_with_label
(*current_name);
gtk_widget_show (img);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM
(item), img);
gtk_image_menu_item_set_always_show_image
(GTK_IMAGE_MENU_ITEM (item), TRUE);
g_free (image_file);
}
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (groups_menu), item);
g_signal_connect (item, "activate",
G_CALLBACK (popup_menu_set_group_cb),
GINT_TO_POINTER (i));
}
return popup_menu;
}
GtkWidget *get_language_menu(GtkWidget *window, cb_t cb)
{
//GtkAccelGroup *group;
gint i;
//group = gtk_accel_group_new ();
lang_menu = gtk_image_menu_item_new();
for (i = 0; i < NUM_LANGS; i++) {
flags[i] = get_picture(flags_files[i]);
g_object_ref(flags[i]);
}
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(lang_menu), flags[language]);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(lang_menu), TRUE);
g_signal_connect(G_OBJECT(lang_menu), "button_press_event",
G_CALLBACK(lang_dialog), cb);
set_gui_language(language);
g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL);
return lang_menu;
}
static GtkWidget *
matewnck_selector_item_new (MatewnckSelector *selector,
const gchar *label, MatewnckWindow *window)
{
GtkWidget *item;
GtkWidget *ellipsizing_label;
window_hash_item *hash_item;
static const GtkTargetEntry targets[] = {
{ "application/x-matewnck-window-id", 0, 0 }
};
item = gtk_image_menu_item_new ();
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
ellipsizing_label = gtk_label_new (label);
gtk_misc_set_alignment (GTK_MISC (ellipsizing_label), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (ellipsizing_label),
PANGO_ELLIPSIZE_END);
if (window != NULL)
{
/* if window demands attention, bold the label */
if (matewnck_window_or_transient_needs_attention (window))
_make_gtk_label_bold (GTK_LABEL (ellipsizing_label));
hash_item = g_new0 (window_hash_item, 1);
hash_item->item = item;
hash_item->label = ellipsizing_label;
g_hash_table_insert (selector->priv->window_hash, window, hash_item);
}
gtk_container_add (GTK_CONTAINER (item), ellipsizing_label);
gtk_widget_show (ellipsizing_label);
gtk_widget_set_size_request (ellipsizing_label,
matewnck_selector_get_width (GTK_WIDGET (selector),
label), -1);
if (window != NULL)
{
gtk_drag_source_set (item,
GDK_BUTTON1_MASK,
targets, 1,
GDK_ACTION_MOVE);
g_signal_connect_object (item, "drag_data_get",
G_CALLBACK (matewnck_selector_drag_data_get),
G_OBJECT (window),
0);
g_signal_connect_object (item, "drag_begin",
G_CALLBACK (matewnck_selector_drag_begin),
G_OBJECT (window),
0);
}
return item;
}
static void
build_menu (NemoBlankDesktopWindow *window)
{
if (window->details->popup_menu) {
return;
}
NemoActionManager *desktop_action_manager = nemo_desktop_manager_get_action_manager ();
if (window->details->actions_changed_id == 0) {
window->details->actions_changed_id = g_signal_connect_swapped (desktop_action_manager,
"changed",
G_CALLBACK (actions_changed_cb),
window);
}
GList *action_list = nemo_action_manager_list_actions (desktop_action_manager);
if (g_list_length (action_list) == 0)
return;
window->details->popup_menu = gtk_menu_new ();
gboolean show;
g_object_get (gtk_settings_get_default (), "gtk-menu-images", &show, NULL);
gtk_menu_attach_to_widget (GTK_MENU (window->details->popup_menu),
GTK_WIDGET (window),
NULL);
GtkWidget *item;
GList *l;
NemoAction *action;
for (l = action_list; l != NULL; l = l->next) {
action = l->data;
if (action->show_in_blank_desktop && action->dbus_satisfied) {
gchar *label = nemo_action_get_label (action, NULL, NULL);
item = gtk_image_menu_item_new_with_mnemonic (label);
g_free (label);
const gchar *stock_id = gtk_action_get_stock_id (GTK_ACTION (action));
const gchar *icon_name = gtk_action_get_icon_name (GTK_ACTION (action));
if (stock_id || icon_name) {
GtkWidget *image = stock_id ? gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU) :
gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), show);
}
gtk_widget_set_visible (item, TRUE);
g_signal_connect (item, "activate", G_CALLBACK (action_activated_callback), action);
gtk_menu_shell_append (GTK_MENU_SHELL (window->details->popup_menu), item);
}
}
}
GtkWidget *
empathy_smiley_menu_new (EmpathySmileyManager *manager,
EmpathySmileyMenuFunc func,
gpointer user_data)
{
EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
GSList *l;
GtkWidget *menu;
gint x = 0;
gint y = 0;
g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
g_return_val_if_fail (func != NULL, NULL);
menu = gtk_menu_new ();
for (l = priv->smileys; l; l = l->next) {
EmpathySmiley *smiley;
GtkWidget *item;
GtkWidget *image;
ActivateData *data;
smiley = l->data;
image = gtk_image_new_from_pixbuf (smiley->pixbuf);
item = gtk_image_menu_item_new_with_label ("");
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
gtk_menu_attach (GTK_MENU (menu), item,
x, x + 1, y, y + 1);
gtk_widget_set_tooltip_text (item, smiley->str);
data = g_slice_new (ActivateData);
data->manager = g_object_ref (manager);
data->smiley = smiley;
data->func = func;
data->user_data = user_data;
g_signal_connect_data (item, "activate",
G_CALLBACK (smiley_menu_activate_cb),
data,
smiley_menu_data_free,
0);
if (x > 3) {
y++;
x = 0;
} else {
x++;
}
}
gtk_widget_show_all (menu);
return menu;
}
GtkWidget *
panel_desktop_menu_item_new (gboolean use_image,
gboolean append_lock_logout)
{
PanelDesktopMenuItem *menuitem;
char *name;
#ifdef HAVE_TELEPATHY_GLIB
PanelSessionManager *manager;
#endif
menuitem = g_object_new (PANEL_TYPE_DESKTOP_MENU_ITEM, NULL);
name = panel_util_get_user_name ();
if (use_image) {
#ifdef HAVE_TELEPATHY_GLIB
setup_menu_item_with_icon (GTK_WIDGET (menuitem),
panel_menu_icon_get_size (),
PANEL_ICON_USER_AVAILABLE,
NULL, NULL,
name);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
#else
setup_menu_item_with_icon (GTK_WIDGET (menuitem),
panel_menu_icon_get_size (),
PANEL_ICON_COMPUTER,
NULL, NULL,
name);
#endif
} else
setup_menuitem (GTK_WIDGET (menuitem),
GTK_ICON_SIZE_INVALID, NULL,
name);
g_free (name);
menuitem->priv->menu = panel_desktop_menu_item_create_menu (menuitem,
append_lock_logout);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
menuitem->priv->menu);
#ifdef HAVE_TELEPATHY_GLIB
manager = panel_session_manager_get ();
menuitem->priv->presence_changed_id =
g_signal_connect (manager,
"presence-changed",
G_CALLBACK (panel_desktop_menu_item_on_presence_changed),
menuitem);
panel_desktop_menu_item_on_presence_changed (manager,
panel_session_manager_get_presence (manager),
menuitem);
#endif
return GTK_WIDGET (menuitem);
}
GtkWidget *
panel_image_menu_item_new (void)
{
GtkWidget *menuitem;
menuitem = gtk_image_menu_item_new ();
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
return menuitem;
}
ToolSelectCombocontrol::ToolSelectCombocontrol(ToolMenuHandler * th, ActionHandler * handler, GladeGui * gui, String id) :
ToolButton(handler, gui, id, ACTION_TOOL_SELECT_RECT, GROUP_TOOL, true, "rect-select.png", _("Select Rectangle")) {
XOJ_INIT_TYPE(ToolSelectCombocontrol);
this->labelWidget = NULL;
GtkWidget * popup = gtk_menu_new();
GtkWidget * menuItem;
this->iconSelectRect = gui->loadIconPixbuf("rect-select.png");
this->iconSelectRgion = gui->loadIconPixbuf("lasso.png");
this->iconSelectObject = gui->loadIconPixbuf("object-select.png");
g_object_ref(this->iconSelectRect);
g_object_ref(this->iconSelectRgion);
g_object_ref(this->iconSelectObject);
menuItem = gtk_image_menu_item_new_with_label(_("Select Rectangle"));
gtk_container_add(GTK_CONTAINER(popup), menuItem);
th->registerMenupoint(menuItem, ACTION_TOOL_SELECT_RECT, GROUP_TOOL);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(menuItem), true);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), gui->loadIcon("rect-select.png"));
gtk_widget_show_all(menuItem);
menuItem = gtk_image_menu_item_new_with_label(_("Select Region"));
gtk_container_add(GTK_CONTAINER(popup), menuItem);
th->registerMenupoint(menuItem, ACTION_TOOL_SELECT_REGION, GROUP_TOOL);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(menuItem), true);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), gui->loadIcon("lasso.png"));
gtk_widget_show_all(menuItem);
menuItem = gtk_image_menu_item_new_with_label(_("Select Object"));
gtk_container_add(GTK_CONTAINER(popup), menuItem);
th->registerMenupoint(menuItem, ACTION_TOOL_SELECT_OBJECT, GROUP_TOOL);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(menuItem), true);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), gui->loadIcon("object-select.png"));
gtk_widget_show_all(menuItem);
setPopupMenu(popup);
}
static GtkWidget *
new_nsp_menu_item (NMDeviceWimax *device,
NMConnection *connection,
gboolean active,
NMWimaxNsp *nsp,
NMApplet *applet)
{
GtkWidget *item;
WimaxMenuItemInfo *info;
#ifdef ENABLE_INDICATOR
char *text = NULL;
GtkWidget *signal_icon = NULL;
#endif
g_return_val_if_fail (nsp != NULL, NULL);
#ifndef ENABLE_INDICATOR
item = nm_mb_menu_item_new (nm_wimax_nsp_get_name (nsp),
nm_wimax_nsp_get_signal_quality (nsp),
NULL,
active,
MB_TECH_WIMAX,
nsp_type_to_mb_state (nm_wimax_nsp_get_network_type (nsp)),
TRUE,
applet);
#else
text = g_strdup (nm_wimax_nsp_get_name (nsp));
item = gtk_image_menu_item_new_with_label (text);
g_free (text);
text = mobile_helper_get_quality_icon (nm_wimax_nsp_get_signal_quality (nsp), applet);
signal_icon = gtk_image_new_from_icon_name (text, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_free (text);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), signal_icon);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
#endif /* ENABLE_INDICATOR */
gtk_widget_set_sensitive (GTK_WIDGET (item), TRUE);
info = g_slice_new0 (WimaxMenuItemInfo);
info->applet = applet;
info->device = g_object_ref (G_OBJECT (device));
info->connection = connection ? g_object_ref (connection) : NULL;
info->nsp = g_object_ref (nsp);
g_signal_connect_data (item, "activate",
G_CALLBACK (wimax_menu_item_activate),
info,
(GClosureNotify) wimax_menu_item_info_destroy, 0);
return item;
}
GtkWidget *
panel_image_menu_item_new (void)
{
GtkWidget *menuitem;
GtkStyleContext *context;
menuitem = gtk_image_menu_item_new ();
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
context = gtk_widget_get_style_context (menuitem);
gtk_style_context_add_class (context, "gnome-panel-menu-item");
return menuitem;
}
GtkWidget *
create_search_menu (GtkWidget *entry)
{
GtkWidget *menu;
GtkWidget *item;
GtkWidget *image;
menu = gtk_menu_new ();
item = gtk_image_menu_item_new_with_mnemonic ("Search by _name");
image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
g_signal_connect (item, "activate",
G_CALLBACK (search_by_name), entry);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_image_menu_item_new_with_mnemonic ("Search by _description");
image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
g_signal_connect (item, "activate",
G_CALLBACK (search_by_description), entry);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_image_menu_item_new_with_mnemonic ("Search by _file name");
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
g_signal_connect (item, "activate",
G_CALLBACK (search_by_file), entry);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (menu);
return menu;
}
/**
* refresh_go_menu:
*
* Refresh list of bookmarks at end of Go menu to match centralized history list.
* @window: The NemoWindow whose Go menu will be refreshed.
**/
static void
nemo_window_initialize_go_menu (NemoWindow *window)
{
GtkUIManager *ui_manager;
GtkWidget *menuitem;
int i;
ui_manager = nemo_window_get_ui_manager (NEMO_WINDOW (window));
for (i = 0; i < G_N_ELEMENTS (icon_entries); i++) {
menuitem = gtk_ui_manager_get_widget (
ui_manager,
icon_entries[i]);
gtk_image_menu_item_set_always_show_image (
GTK_IMAGE_MENU_ITEM (menuitem), TRUE);
}
}
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 GtkWidget*
remmina_applet_menu_add_group(GtkWidget *menu, const gchar *group, gint position, RemminaAppletMenuItem *menuitem,
GtkWidget **groupmenuitem)
{
GtkWidget *widget;
GtkWidget *image;
GtkWidget *submenu;
widget = gtk_image_menu_item_new_with_label(group);
gtk_widget_show(widget);
image =
gtk_image_new_from_icon_name(
(menuitem->item_type == REMMINA_APPLET_MENU_ITEM_DISCOVERED ?
"folder-remote" : "folder"), GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget), image);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(widget), TRUE);
g_object_set_data_full(G_OBJECT(widget), "group", g_strdup(group), g_free);
g_object_set_data(G_OBJECT(widget), "count", GINT_TO_POINTER(0));
if (groupmenuitem)
{
*groupmenuitem = widget;
}
if (position < 0)
{
gtk_menu_shell_append(GTK_MENU_SHELL(menu), widget);
}
else
{
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), widget, position);
}
submenu = gtk_menu_new();
gtk_widget_show(submenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(widget), submenu);
return submenu;
}
static void wl_httper_menu_init(WlHttperMenu * menu)
{
GtkWidget *properties =
gtk_image_menu_item_new_from_stock(GTK_STOCK_PROPERTIES, NULL);
gtk_menu_item_set_label(GTK_MENU_ITEM(properties), "Properties");
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
(properties), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), properties);
GtkWidget *openDir =
gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
gtk_menu_item_set_label(GTK_MENU_ITEM(openDir), "Open Folder");
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(openDir),
TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), openDir);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
GtkWidget *startAction =
gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PLAY, NULL);
gtk_menu_item_set_label(GTK_MENU_ITEM(startAction), "Start");
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
(startAction), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), startAction);
GtkWidget *pauseAction =
gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
(pauseAction), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), pauseAction);
GtkWidget *abortAction =
gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_STOP, NULL);
gtk_menu_item_set_label(GTK_MENU_ITEM(abortAction), "Abort");
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
(abortAction), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), abortAction);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
GtkWidget *redlAction = gtk_menu_item_new_with_label("Re-Download");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), redlAction);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
GtkWidget *copyURL = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY,
NULL);
gtk_menu_item_set_label(GTK_MENU_ITEM(copyURL),
"Copy Download URL to Clipboard");
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
(copyURL), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), copyURL);
gtk_widget_show_all(GTK_WIDGET(menu));
menu->httper = NULL;
menu->properties = properties;
menu->openDir = openDir;
menu->copyURL = copyURL;
menu->startAction = startAction;
menu->pauseAction = pauseAction;
menu->abortAction = abortAction;
menu->redlAction = redlAction;
menu->propertiesDialog = NULL;
}
void
caja_menus_append_bookmark_to_menu (CajaWindow *window,
CajaBookmark *bookmark,
const char *parent_path,
const char *parent_id,
guint index_in_parent,
GtkActionGroup *action_group,
guint merge_id,
GCallback refresh_callback,
CajaBookmarkFailedCallback failed_callback)
{
BookmarkHolder *bookmark_holder;
char action_name[128];
char *name;
char *path;
GdkPixbuf *pixbuf;
GtkAction *action;
GtkWidget *menuitem;
g_assert (CAJA_IS_WINDOW (window));
g_assert (CAJA_IS_BOOKMARK (bookmark));
bookmark_holder = bookmark_holder_new (bookmark, window, refresh_callback, failed_callback);
name = caja_bookmark_get_name (bookmark);
/* Create menu item with pixbuf */
pixbuf = caja_bookmark_get_pixbuf (bookmark, GTK_ICON_SIZE_MENU);
g_snprintf (action_name, sizeof (action_name), "%s%d", parent_id, index_in_parent);
action = gtk_action_new (action_name,
name,
_("Go to the location specified by this bookmark"),
NULL);
g_object_set_data_full (G_OBJECT (action), "menu-icon",
g_object_ref (pixbuf),
g_object_unref);
g_signal_connect_data (action, "activate",
G_CALLBACK (activate_bookmark_in_menu_item),
bookmark_holder,
bookmark_holder_free_cover, 0);
gtk_action_group_add_action (action_group,
GTK_ACTION (action));
g_object_unref (action);
gtk_ui_manager_add_ui (window->details->ui_manager,
merge_id,
parent_path,
action_name,
action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
path = g_strdup_printf ("%s/%s", parent_path, action_name);
menuitem = gtk_ui_manager_get_widget (window->details->ui_manager,
path);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
g_object_unref (pixbuf);
g_free (path);
g_free (name);
}
static void
popup_prop_menu(GtkButton *prop_button, GdkEventButton *event,
GtkWidget *widget)
{
GtkWidget *menu_item, *hbox, *label, *img;
GList *menu_item_list, *icon_list, *label_list, *tooltip_list, *action_list,
*state_list, *list;
int i, selected = -1;
uim_toolbar_check_helper_connection(widget);
menu_item_list = gtk_container_get_children(GTK_CONTAINER(prop_menu));
icon_list = g_object_get_data(G_OBJECT(prop_button), "prop_icon");
label_list = g_object_get_data(G_OBJECT(prop_button), "prop_label");
tooltip_list = g_object_get_data(G_OBJECT(prop_button), "prop_tooltip");
action_list = g_object_get_data(G_OBJECT(prop_button), "prop_action");
state_list = g_object_get_data(G_OBJECT(prop_button), "prop_state");
list = menu_item_list;
while (list) {
gtk_widget_destroy(list->data);
list = list->next;
}
g_list_free(menu_item_list);
gtk_widget_destroy(prop_menu);
prop_menu = gtk_menu_new();
/* check selected item */
i = 0;
while (state_list) {
if (!strcmp("*", state_list->data)) {
selected = i;
break;
}
state_list = state_list->next;
i++;
}
i = 0;
while (label_list) {
if (selected != -1) {
menu_item = gtk_check_menu_item_new();
label = gtk_label_new(label_list->data);
#if GTK_CHECK_VERSION(3, 2, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
#endif
if (register_icon(icon_list->data))
img = gtk_image_new_from_stock(icon_list->data, GTK_ICON_SIZE_MENU);
else
img = gtk_image_new_from_stock("null", GTK_ICON_SIZE_MENU);
if (img) {
gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 3);
gtk_widget_show(img);
}
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
gtk_container_add(GTK_CONTAINER(menu_item), hbox);
gtk_widget_show(label);
gtk_widget_show(hbox);
if (i == selected)
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE);
} else {
menu_item = gtk_image_menu_item_new_with_label(label_list->data);
if (register_icon(icon_list->data)) {
img = gtk_image_new_from_stock(icon_list->data, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), img);
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(menu_item), TRUE);
#endif
}
}
/* tooltips */
gtk_widget_set_tooltip_text(menu_item,
tooltip_list ? tooltip_list->data : NULL);
/* add to the menu */
gtk_menu_shell_append(GTK_MENU_SHELL(prop_menu), menu_item);
gtk_widget_show(menu_item);
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(prop_menu_activate), prop_menu);
g_object_set_data(G_OBJECT(menu_item), "prop_action",
action_list? action_list->data : NULL);
label_list = label_list->next;
if (icon_list)
icon_list = icon_list->next;
if (action_list)
action_list = action_list->next;
if (tooltip_list)
tooltip_list = tooltip_list->next;
i++;
}
g_signal_connect(G_OBJECT(GTK_MENU_SHELL(prop_menu)), "deactivate",
G_CALLBACK(prop_menu_shell_deactivate), NULL);
gtk_menu_popup(GTK_MENU(prop_menu), NULL, NULL,
(GtkMenuPositionFunc)calc_menu_position,
(gpointer)prop_button, event->button,
gtk_get_current_event_time());
prop_menu_showing = TRUE;
}
static void
_gth_browser_update_open_menu (GthBrowser *browser,
const char *path)
{
GtkWidget *openwith_item;
GtkWidget *menu;
GList *items;
GList *file_list;
GList *scan;
GList *appinfo_list;
GHashTable *used_mime_types;
GthIconCache *icon_cache;
GHashTable *used_apps;
openwith_item = gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), path);
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (openwith_item));
_gtk_container_remove_children (GTK_CONTAINER (menu), NULL, NULL);
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items);
appinfo_list = NULL;
used_mime_types = g_hash_table_new (g_str_hash, g_str_equal);
for (scan = file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
const char *mime_type;
mime_type = gth_file_data_get_mime_type (file_data);
if ((mime_type == NULL) || g_content_type_is_unknown (mime_type))
continue;
if (g_hash_table_lookup (used_mime_types, mime_type) != NULL)
continue;
appinfo_list = g_list_concat (appinfo_list, g_app_info_get_all_for_type (mime_type));
g_hash_table_insert (used_mime_types, (gpointer) mime_type, GINT_TO_POINTER (1));
}
g_hash_table_destroy (used_mime_types);
icon_cache = gth_browser_get_menu_icon_cache (browser);
used_apps = g_hash_table_new (g_str_hash, g_str_equal);
for (scan = appinfo_list; scan; scan = scan->next) {
GAppInfo *appinfo = scan->data;
char *label;
GtkWidget *menu_item;
GIcon *icon;
if (strcmp (g_app_info_get_executable (appinfo), "pix") == 0)
continue;
if (g_hash_table_lookup (used_apps, g_app_info_get_id (appinfo)) != NULL)
continue;
g_hash_table_insert (used_apps, (gpointer) g_app_info_get_id (appinfo), GINT_TO_POINTER (1));
label = g_strdup_printf ("%s", g_app_info_get_name (appinfo));
menu_item = gtk_image_menu_item_new_with_label (label);
icon = g_app_info_get_icon (appinfo);
if (icon != NULL) {
GdkPixbuf *pixbuf;
pixbuf = gth_icon_cache_get_pixbuf (icon_cache, icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), gtk_image_new_from_pixbuf (pixbuf));
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menu_item), TRUE);
g_object_unref (pixbuf);
}
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
g_object_set_data_full (G_OBJECT (menu_item),
"appinfo",
g_object_ref (appinfo),
g_object_unref);
g_signal_connect (menu_item,
"activate",
G_CALLBACK (activate_open_with_application_item),
browser);
g_free (label);
}
/*
if (appinfo_list == NULL) {
GtkWidget *menu_item;
menu_item = gtk_image_menu_item_new_with_label (_("No application available"));
gtk_widget_set_sensitive (menu_item, FALSE);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
}*/
gtk_widget_set_sensitive (openwith_item, appinfo_list != NULL);
gtk_widget_show (openwith_item);
g_hash_table_destroy (used_apps);
_g_object_list_unref (appinfo_list);
_g_object_list_unref (file_list);
_gtk_tree_path_list_free (items);
}
