static GtkWidget *
menu_item_new (MenuItem *menuitem, int workspace_id)
{
unsigned int key;
MetaVirtualModifier mods;
const char *i18n_label;
GtkWidget *mi;
GtkWidget *accel_label;
if (menuitem->type == MENU_ITEM_NORMAL)
{
mi = gtk_menu_item_new ();
}
else if (menuitem->type == MENU_ITEM_IMAGE)
{
GtkWidget *image;
image = gtk_image_new_from_stock (menuitem->stock_id, GTK_ICON_SIZE_MENU);
mi = gtk_image_menu_item_new ();
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image);
gtk_widget_show (image);
}
else if (menuitem->type == MENU_ITEM_CHECKBOX)
{
mi = gtk_check_menu_item_new ();
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
menuitem->checked);
}
else if (menuitem->type == MENU_ITEM_RADIOBUTTON)
{
mi = gtk_check_menu_item_new ();
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi),
TRUE);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
menuitem->checked);
}
else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST)
return NULL;
else
return gtk_separator_menu_item_new ();
i18n_label = _(menuitem->label);
meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);
accel_label = meta_accel_label_new_with_mnemonic (i18n_label);
gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (mi), accel_label);
gtk_widget_show (accel_label);
meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label),
key, mods);
return mi;
}
static GtkWidget * AddMenuCheckItem(GtkWidget *window1, const char * immagine_xpm, GtkWidget* Menu,const char* label, gboolean state, int Number)
{
GtkWidget * Label = NULL;
GtkWidget * Pixmap = NULL;
GtkWidget * hbox = NULL;
GtkWidget * Item = NULL;
GdkPixmap *PixmapIcon = NULL;
GdkColor transparent;
GdkBitmap *MaskIcon = NULL;
PixmapIcon = gdk_pixmap_create_from_xpm_d (window1->window, &MaskIcon, &transparent,(gchar **)immagine_xpm );
Pixmap = gtk_pixmap_new (PixmapIcon, MaskIcon);
gdk_pixmap_unref (PixmapIcon);
Item=gtk_check_menu_item_new();
Label = gtk_label_new (label);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), Pixmap, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), Label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (Item), hbox);
gtk_menu_append( GTK_MENU( Menu ),Item );
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(Item),state);
gtk_signal_connect_object( GTK_OBJECT(Item),"activate",
GTK_SIGNAL_FUNC(ActivateMenuItem),(gpointer)Number );
gtk_menu_item_right_justify (GTK_MENU_ITEM (Item));
gtk_widget_show_all(Item);
return Item;
}
// Operator cast to GtkWidget* for packing into a menu
TextMenuItemAccelerator::operator GtkWidget* () {
// Create the menu item, with or without a toggle
GtkWidget* menuItem;
if (_isToggle)
menuItem = gtk_check_menu_item_new();
else
menuItem = gtk_menu_item_new();
// Create the text. This consists of the icon, the label string (left-
// aligned) and the accelerator string (right-aligned).
GtkWidget* hbx = gtk_hbox_new(FALSE, 4);
// Try to pack in icon ONLY if it is valid
if (_icon != NULL) {
_iconImage = gtk_image_new_from_pixbuf(_icon);
gtk_box_pack_start(GTK_BOX(hbx), _iconImage, FALSE, FALSE, 0);
}
_label = gtk_label_new_with_mnemonic(_labelText.c_str());
_accel = gtk_label_new_with_mnemonic(_accelLabelText.c_str());
gtk_box_pack_start(GTK_BOX(hbx), _label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbx), gtk_label_new(" "), FALSE, FALSE, 12);
gtk_box_pack_end(GTK_BOX(hbx), _accel, FALSE, FALSE, 0);
// Pack the label structure into the MenuItem
gtk_container_add(GTK_CONTAINER(menuItem), hbx);
return menuItem;
}
/* colorlabel_create_check_color_menu_item() - creates a color
* menu item with a check box */
GtkWidget *colorlabel_create_check_color_menu_item(gint color_index, gboolean force, gint menu_index)
{
GtkWidget *label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *item;
gchar *accel;
G_RETURN_VAL_IF_INVALID_COLOR(color_index, NULL);
item = gtk_check_menu_item_new();
if (force) {
label_colors[menu_index][color_index].changed |= LCCF_COLOR;
label_colors[menu_index][color_index].changed |= LCCF_LABEL;
}
colorlabel_recreate(color_index);
/* XXX: gnome-core::panel::menu.c is a great example of
* how to create pixmap menus */
label = gtk_label_new(label_colors[menu_index][color_index].label);
gtk_widget_show(label);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_container_add(GTK_CONTAINER(item), hbox);
vbox = gtk_vbox_new(TRUE, 0);
gtk_widget_show(vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
gtk_container_add(GTK_CONTAINER(vbox),
label_colors[menu_index][color_index].widget);
gtk_widget_show(label_colors[menu_index][color_index].widget);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 4);
if (color_index < 9) {
accel = gtk_accelerator_get_label(GDK_KEY_1+color_index, GDK_CONTROL_MASK);
label = gtk_label_new(accel);
gtk_widget_show(label);
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
g_free(accel);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 4);
g_object_set_data(G_OBJECT(item), "accel_label", label);
} else {
label = gtk_label_new("");
gtk_widget_show(label);
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 4);
g_object_set_data(G_OBJECT(item), "accel_label", label);
}
return item;
}
static GtkWidget *build_roll_menu(void)
{
GtkWidget *menu;
gint i;
gchar buffer[128];
MapTheme *theme = theme_get_current();
THEME_COLOR tcolor;
GdkColor *color;
GtkWidget *item;
GtkWidget *label;
menu = gtk_menu_new();
for (i = 2; i <= 12; i++) {
if (i == 7)
continue;
tcolor = (i == 6 || i == 8) ? TC_CHIP_H_FG : TC_CHIP_FG;
color = &theme->colors[tcolor].color;
sprintf(buffer,
"<span foreground=\"#%04x%04x%04x\">%d</span>",
color->red, color->green, color->blue, i);
item = gtk_check_menu_item_new();
label = gtk_label_new("");
gtk_label_set_markup(GTK_LABEL(label), buffer);
gtk_container_add(GTK_CONTAINER(item), label);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_roll_cb),
GINT_TO_POINTER(i));
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM
(item), TRUE);
roll_numbers[i] = item;
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
/* Menu item */
item = gtk_check_menu_item_new_with_label(_("Shuffle"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_shuffle_cb), NULL);
shuffle_tile = GTK_CHECK_MENU_ITEM(item);
gtk_widget_show_all(menu);
return menu;
}
static GtkWidget *
panel_menu_item_presence_new (TpAccountManager *account_manager,
PanelSessionManagerPresenceType presence_type,
const char *name,
const char *icon,
gboolean use_icon)
{
GtkWidget *item;
if (!account_manager)
return NULL;
item = gtk_check_menu_item_new ();
setup_menuitem (item, GTK_ICON_SIZE_INVALID, NULL, name);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (item), TRUE);
/* TODO: we need to add an icon at the right of this CheckMenuItem */
#if 0
if (use_icon) {
GtkWidget *image;
image = gtk_image_new_from_icon_name (icon,
panel_menu_icon_get_size ());
gtk_container_add (GTK_CONTAINER (item), image);
}
#endif
g_object_set_data (G_OBJECT (item), "panel-menu-presence",
GINT_TO_POINTER (presence_type));
g_signal_connect (item, "activate",
G_CALLBACK (panel_menu_item_activate_presence),
account_manager);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
return item;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkCheckMenuItem_gtk_1check_1menu_1item_1new
(
JNIEnv* env,
jclass cls
)
{
GtkWidget* result;
jlong _result;
// call function
result = gtk_check_menu_item_new();
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
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
sensor_enabled(IsManager *manager,
IsSensor *sensor,
gint position,
IsIndicator *self)
{
IsIndicatorPrivate *priv = self->priv;
/* make sure we haven't seen this sensor before - if sensor has a
* menu-item then ignore it */
if (!g_object_get_data(G_OBJECT(sensor), "menu-item"))
{
GtkMenu *menu;
GtkWidget *menu_item;
is_debug("indicator", "Creating menu item for newly enabled sensor %s",
is_sensor_get_path(sensor));
g_signal_connect(sensor, "notify::value",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::label",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::alarmed",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::low-value",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::high-value",
G_CALLBACK(sensor_notify),
self);
/* add a menu entry for this sensor */
menu = is_indicator_get_menu(self);
menu_item = gtk_check_menu_item_new();
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
g_object_set_data(G_OBJECT(sensor), "menu-item", menu_item);
g_object_set_data(G_OBJECT(menu_item), "sensor", sensor);
priv->menu_items = g_slist_insert(priv->menu_items, menu_item,
position);
/* if we haven't seen our primary sensor yet or if this is the
* primary sensor, display this as primary anyway */
if (!priv->primary ||
g_strcmp0(is_sensor_get_path(sensor),
priv->primary_sensor_path) == 0)
{
is_debug("indicator", "Using sensor with path %s as primary",
is_sensor_get_path(sensor));
if (priv->primary)
{
GtkCheckMenuItem *item;
/* uncheck menu item if exists for this
* existing primary sensor */
item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(priv->primary),
"menu-item"));
if (item)
{
is_debug("indicator", "Unchecking current primary sensor item");
gtk_check_menu_item_set_active(item, FALSE);
}
g_object_unref(priv->primary);
}
priv->primary = g_object_ref(sensor);
is_debug("indicator", "Checking new primary sensor item");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
update_sensor_menu_item_label(self, sensor,
GTK_MENU_ITEM(menu_item));
}
/* connect to toggled signal now - if we connect to it earlier
* we may interpret the above menu_item_set_active as a user
* initiated setting of the primary sensor rather than us just
* picking the first available sensor */
g_signal_connect(menu_item, "toggled",
G_CALLBACK(sensor_menu_item_toggled),
self);
gtk_widget_show_all(menu_item);
update_sensor_menu_item_label(self, sensor, GTK_MENU_ITEM(menu_item));
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menu_item, position);
}
else
{
is_debug("indicator", "Newly enabled sensor %s already has a menu-item, ignoring...",
is_sensor_get_path(sensor));
}
}
static void sico_activated (GtkWidget *data)
{
stashes_popup_menu = gtk_menu_new ();
GtkWidget *mi = gtk_menu_item_new ();
GtkWidget *w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), _("<b>Encrypted folders:</b>"));
gtk_container_add (GTK_CONTAINER (mi), w);
gtk_widget_set_sensitive (mi, FALSE);
gtk_menu_append (stashes_popup_menu, mi);
int i = 0;
std::vector<CryptPoint>::iterator it;
// find out which ones are mounted
for (it = cryptPoints.begin (); it != cryptPoints.end (); ++it, i++) {
struct stat s;
(*it).SetIsMounted (false);
(*it).SetIsAvailable (false);
if (stat ((*it).GetCryptDir (), &s) != -1) {
if (S_ISDIR (s.st_mode)) (*it).SetIsAvailable (true);
}
// to get rid of festering mount points
if (!config_keep_mountpoints) rmdir ((*it).GetMountDir ());
if (is_mounted((*it).GetMountDir())) {
if (S_ISDIR (s.st_mode)) (*it).SetIsMounted (true);
}
}
i = 0;
for (it = cryptPoints.begin (); it != cryptPoints.end (); ++it, i++) {
mi = gtk_check_menu_item_new ();
char buf[256];
if ((*it).GetIsAvailable ()) {
snprintf (buf, sizeof (buf), "%s", (*it).GetMountDir ());
} else {
snprintf (buf, sizeof (buf), "<span foreground=\"grey\">%s</span>", (*it).GetMountDir ());
}
GtkWidget *label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), buf);
gtk_container_add (GTK_CONTAINER (mi), label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), (*it).GetIsMounted ());
//gtk_widget_set_sensitive (mi, (*it).GetIsAvailable ());
gtk_menu_append (stashes_popup_menu, mi);
g_signal_connect (G_OBJECT (mi), "toggled", G_CALLBACK (on_mount_check_item_toggled), GINT_TO_POINTER (i));
g_signal_connect (G_OBJECT (mi), "button-release-event", G_CALLBACK (on_button_release), GINT_TO_POINTER (i));
}
mi = gtk_separator_menu_item_new ();
gtk_menu_append (stashes_popup_menu, mi);
mi = gtk_menu_item_new_with_label (_("Import EncFS folder"));
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (on_import_stash_clicked), NULL);
gtk_menu_append (stashes_popup_menu, mi);
mi = gtk_menu_item_new_with_label (_("New encrypted folder"));
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (on_create_new_stash_clicked), NULL);
gtk_menu_append (stashes_popup_menu, mi);
gtk_widget_show_all (stashes_popup_menu);
gtk_menu_popup (GTK_MENU (stashes_popup_menu), NULL, NULL, gtk_status_icon_position_menu, sico,
0, gtk_get_current_event_time ());
}
