/* 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
panel_menu_items_append_place_item (const char *icon_name,
GIcon *gicon,
const char *title,
const char *tooltip,
GtkWidget *menu,
GCallback callback,
const char *uri)
{
GtkWidget *item;
char *user_data;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item,
panel_menu_icon_get_size (),
icon_name, NULL, gicon,
title);
panel_util_set_tooltip_text (item, tooltip);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
user_data = g_strdup (uri);
g_signal_connect_data (item, "activate", callback, user_data,
(GClosureNotify) g_free, 0);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
setup_uri_drag (item, uri, icon_name);
}
static GtkWidget *
create_submenu_entry (GtkWidget *menu,
MateMenuTreeDirectory *directory)
{
GtkWidget *menuitem;
gboolean force_categories_icon;
force_categories_icon = g_object_get_data (G_OBJECT (menu),
"panel-menu-force-icon-for-categories") != NULL;
if (force_categories_icon)
menuitem = panel_image_menu_item_new ();
else
menuitem = gtk_image_menu_item_new ();
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
NULL, NULL,
matemenu_tree_directory_get_icon (directory),
PANEL_ICON_FOLDER);
setup_menuitem (menuitem,
panel_menu_icon_get_size (),
NULL,
matemenu_tree_directory_get_name (directory));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
return menuitem;
}
static void
panel_menu_item_append_volume (GtkWidget *menu,
GVolume *volume)
{
GtkWidget *item;
GIcon *icon;
char *title;
char *tooltip;
icon = g_volume_get_icon (volume);
title = g_volume_get_name (volume);
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item,
panel_menu_icon_get_size (),
NULL, NULL, icon,
title);
g_object_unref (icon);
tooltip = g_strdup_printf (_("Mount %s"), title);
panel_util_set_tooltip_text (item, tooltip);
g_free (tooltip);
g_free (title);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect_data (item, "activate",
G_CALLBACK (panel_menu_item_mount_volume),
g_object_ref (volume),
(GClosureNotify) g_object_unref, 0);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
}
static GtkWidget *
panel_menu_items_create_action_item_full (PanelActionButtonType action_type,
const char *label,
const char *tooltip)
{
GtkWidget *item;
if (panel_action_get_is_disabled (action_type))
return NULL;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item,
panel_menu_icon_get_size (),
panel_action_get_icon_name (action_type),
NULL, NULL,
label ? label : panel_action_get_text (action_type));
panel_util_set_tooltip_text (item,
tooltip ?
tooltip :
panel_action_get_tooltip (action_type));
g_signal_connect (item, "activate",
panel_action_get_invoke (action_type), NULL);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
setup_internal_applet_drag (item, action_type);
return item;
}
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 VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE label, use_underline_or_accel_group;
GtkWidget *widget = NULL;
if (rb_scan_args(argc, argv, "02", &label, &use_underline_or_accel_group) > 0) {
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline_or_accel_group) || RVAL2CBOOL(use_underline_or_accel_group)){
widget = gtk_image_menu_item_new_with_mnemonic(RVAL2CSTR(label));
} else {
widget = gtk_image_menu_item_new_with_label(RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_image_menu_item_new_from_stock(rb_id2name(SYM2ID(label)),
NIL_P(use_underline_or_accel_group) ? NULL :
GTK_ACCEL_GROUP(RVAL2GOBJ(use_underline_or_accel_group)));
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
} else {
widget = gtk_image_menu_item_new();
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
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 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;
}
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;
}
static GtkWidget *
face_action_create_menu_item (GtkAction *action)
{
GtkWidget *item;
GtkWidget *menu;
item = gtk_image_menu_item_new ();
menu = gtk_action_create_menu (action);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu);
gtk_widget_show (menu);
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;
}
/**
* Show satellite popup menu.
* @param sat Pointer to the satellite data.
* @param qth The current location.
* @param event The mouse-click related event info.
* @param toplevel The top level window.
*/
void gtk_event_list_popup_exec(sat_t * sat, qth_t * qth,
GdkEventButton * event, GtkEventList * list)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *label;
GtkWidget *image;
gchar *buff;
menu = gtk_menu_new();
/* first menu item is the satellite name, centered */
menuitem = gtk_image_menu_item_new();
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
buff = g_markup_printf_escaped("<b>%s</b>", sat->nickname);
gtk_label_set_markup(GTK_LABEL(label), buff);
g_free(buff);
gtk_container_add(GTK_CONTAINER(menuitem), label);
image = gtk_image_new_from_stock(GTK_STOCK_INFO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
/* attach data to menuitem and connect callback */
g_object_set_data(G_OBJECT(menuitem), "sat", sat);
g_object_set_data(G_OBJECT(menuitem), "qth", qth);
g_signal_connect(menuitem, "activate",
G_CALLBACK(show_sat_info_menu_cb),
gtk_widget_get_toplevel(GTK_WIDGET(list)));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* add the menu items for current,next, and future passes. */
add_pass_menu_items(menu, sat, qth, &list->tstamp, GTK_WIDGET(list));
gtk_widget_show_all(menu);
/* Note: event can be NULL here when called from view_onPopupMenu;
* gdk_event_get_time() accepts a NULL argument */
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent *) event));
}
GtkWidget*
window_menu_item_new (WnckWindow* window)
{
WnckApplication* application;
GdkPixbuf* pixbuf;
GtkWidget* item;
GtkWidget* label;
gchar * markup;
g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
item = gtk_image_menu_item_new ();
application = wnck_window_get_application (window);
/* FIXME: track icon changes */
pixbuf = wnck_application_get_icon (application);
if (pixbuf)
{
GtkWidget* image = gtk_image_new_from_pixbuf (pixbuf);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
}
g_signal_connect (item, "activate",
G_CALLBACK (window_item_activated), window);
/* FIXME: track name changes */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
markup = g_strdup_printf ("<b>%s</b>\n<small>%s</small>",
wnck_application_get_name (application),
wnck_window_get_name (window));
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (item), label);
return item;
}
int
clip_GTK_IMAGEMENUITEMNEW(ClipMachine * cm)
{
ClipVar *cv = _clip_spar(cm, 1);
C_widget *cimage ;
GtkWidget *image ;
CHECKOPT(1,MAP_t);
image = gtk_image_menu_item_new();
if (image)
{
cimage = _list_get_cwidget(cm, image);
if (!cimage) cimage = _register_widget(cm, image, cv);
if (cimage) _clip_mclone(cm, RETPTR(cm), &cimage->obj);
}
return 0;
err:
return 1;
}
static GtkWidget *
go_action_combo_pixmaps_create_menu_item (GtkAction *a)
{
GOActionComboPixmaps *paction = (GOActionComboPixmaps *)a;
GOMenuPixmaps *submenu = go_menu_pixmaps_new (paction->ncols);
GOActionComboPixmapsElement const *el= paction->elements;
GtkWidget *item = gtk_image_menu_item_new ();
for ( ; el->stock_id != NULL ; el++)
go_menu_pixmaps_add_element
(submenu,
make_icon (a, el->stock_id, item),
el->id,
gettext (el->untranslated_tooltip));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), GTK_WIDGET (submenu));
gtk_widget_show (GTK_WIDGET (submenu));
g_signal_connect (G_OBJECT (submenu),
"changed",
G_CALLBACK (cb_selection_changed), a);
return item;
}
static GtkWidget *
panel_menu_items_create_switch_user (gboolean use_icon)
{
GtkWidget *item;
if (use_icon) {
item = panel_image_menu_item_new ();
} else {
item = gtk_image_menu_item_new ();
}
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
NULL, NULL, NULL, _("Switch User"));
g_signal_connect (item, "activate",
G_CALLBACK (panel_menu_item_activate_switch_user),
NULL);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
return item;
}
static void
panel_menu_items_append_from_desktop (GtkWidget *menu,
char *path,
char *force_name,
gboolean use_icon)
{
GKeyFile *key_file;
gboolean loaded;
GtkWidget *item;
char *path_freeme;
char *full_path;
char *uri;
char *type;
gboolean is_application;
char *tryexec;
char *icon;
char *name;
char *comment;
path_freeme = NULL;
key_file = g_key_file_new ();
if (g_path_is_absolute (path)) {
loaded = g_key_file_load_from_file (key_file, path,
G_KEY_FILE_NONE, NULL);
full_path = path;
} else {
char *lookup_file;
char *desktop_path;
if (!g_str_has_suffix (path, ".desktop")) {
desktop_path = g_strconcat (path, ".desktop", NULL);
} else {
desktop_path = path;
}
lookup_file = g_strconcat ("applications", G_DIR_SEPARATOR_S,
desktop_path, NULL);
loaded = g_key_file_load_from_data_dirs (key_file, lookup_file,
&path_freeme,
G_KEY_FILE_NONE,
NULL);
full_path = path_freeme;
g_free (lookup_file);
if (desktop_path != path)
g_free (desktop_path);
}
if (!loaded) {
g_key_file_free (key_file);
if (path_freeme)
g_free (path_freeme);
return;
}
/* For Application desktop files, respect TryExec */
type = panel_key_file_get_string (key_file, "Type");
if (!type) {
g_key_file_free (key_file);
if (path_freeme)
g_free (path_freeme);
return;
}
is_application = (strcmp (type, "Application") == 0);
g_free (type);
if (is_application) {
tryexec = panel_key_file_get_string (key_file, "TryExec");
if (tryexec) {
char *prog;
prog = g_find_program_in_path (tryexec);
g_free (tryexec);
if (!prog) {
/* FIXME: we could add some file monitor magic,
* so that the menu items appears when the
* program appears, but that's really complex
* for not a huge benefit */
g_key_file_free (key_file);
if (path_freeme)
g_free (path_freeme);
return;
}
g_free (prog);
}
}
/* Now, simply build the menu item */
icon = panel_key_file_get_locale_string (key_file, "Icon");
comment = panel_key_file_get_locale_string (key_file, "Comment");
if (PANEL_GLIB_STR_EMPTY (force_name))
name = panel_key_file_get_locale_string (key_file, "Name");
else
name = g_strdup (force_name);
if (use_icon) {
item = panel_image_menu_item_new ();
} else {
item = gtk_image_menu_item_new ();
}
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
icon, NULL, NULL, name);
panel_util_set_tooltip_text (item, comment);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect_data (item, "activate",
G_CALLBACK (panel_menu_item_activate_desktop_file),
g_strdup (full_path),
(GClosureNotify) g_free, 0);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
uri = g_filename_to_uri (full_path, NULL, NULL);
setup_uri_drag (item, uri, icon, GDK_ACTION_COPY);
g_free (uri);
g_key_file_free (key_file);
if (icon)
g_free (icon);
if (name)
g_free (name);
if (comment)
g_free (comment);
if (path_freeme)
g_free (path_freeme);
}
/* this is loosely based on update_places() from nautilus-places-sidebar.c */
static void
panel_place_menu_item_append_remote_gio (PanelPlaceMenuItem *place_item,
GtkWidget *menu)
{
GtkWidget *add_menu;
GList *mounts, *l;
GMount *mount;
GSList *add_mounts, *sl;
/* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */
mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor);
add_mounts = NULL;
for (l = mounts; l; l = l->next) {
GVolume *volume;
GFile *root;
mount = l->data;
volume = g_mount_get_volume (mount);
if (volume != NULL) {
g_object_unref (volume);
g_object_unref (mount);
continue;
}
root = g_mount_get_root (mount);
if (g_file_is_native (root)) {
g_object_unref (root);
g_object_unref (mount);
continue;
}
g_object_unref (root);
add_mounts = g_slist_prepend (add_mounts, mount);
}
add_mounts = g_slist_reverse (add_mounts);
if (g_slist_length (add_mounts) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_NETWORK_SERVER,
NULL, NULL,
_("Network Places"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (sl = add_mounts; sl; sl = sl->next) {
mount = sl->data;
panel_menu_item_append_mount (add_menu, mount);
g_object_unref (mount);
}
g_slist_free (add_mounts);
g_list_free (mounts);
}
/* this is loosely based on update_places() from caja-places-sidebar.c */
static void
panel_place_menu_item_append_local_gio (PanelPlaceMenuItem *place_item,
GtkWidget *menu)
{
GList *l;
GList *ll;
GList *drives;
GDrive *drive;
GList *volumes;
GVolume *volume;
GList *mounts;
GMount *mount;
GSList *items;
GSList *sl;
PanelGioItem *item;
GtkWidget *add_menu;
items = NULL;
/* first go through all connected drives */
drives = g_volume_monitor_get_connected_drives (place_item->priv->volume_monitor);
for (l = drives; l != NULL; l = l->next) {
drive = l->data;
volumes = g_drive_get_volumes (drive);
if (volumes != NULL) {
for (ll = volumes; ll != NULL; ll = ll->next) {
volume = ll->data;
mount = g_volume_get_mount (volume);
item = g_slice_new (PanelGioItem);
if (mount != NULL) {
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
} else {
/* Do show the unmounted volumes; this
* is so the user can mount it (in case
* automounting is off).
*
* Also, even if automounting is
* enabled, this gives a visual cue
* that the user should remember to
* yank out the media if he just
* unmounted it.
*/
item->type = PANEL_GIO_VOLUME;
item->u.volume = g_object_ref (volume);
}
items = g_slist_prepend (items, item);
g_object_unref (volume);
}
g_list_free (volumes);
} else {
if (g_drive_is_media_removable (drive) &&
!g_drive_is_media_check_automatic (drive)) {
/* If the drive has no mountable volumes and we
* cannot detect media change.. we display the
* drive so the user can manually poll the
* drive by clicking on it..."
*
* This is mainly for drives like floppies
* where media detection doesn't work.. but
* it's also for human beings who like to turn
* off media detection in the OS to save
* battery juice.
*/
item = g_slice_new (PanelGioItem);
item->type = PANEL_GIO_DRIVE;
item->u.drive = g_object_ref (drive);
items = g_slist_prepend (items, item);
}
}
g_object_unref (drive);
}
g_list_free (drives);
/* add all volumes that is not associated with a drive */
volumes = g_volume_monitor_get_volumes (place_item->priv->volume_monitor);
for (l = volumes; l != NULL; l = l->next) {
volume = l->data;
drive = g_volume_get_drive (volume);
if (drive != NULL) {
g_object_unref (volume);
g_object_unref (drive);
continue;
}
mount = g_volume_get_mount (volume);
item = g_slice_new (PanelGioItem);
if (mount != NULL) {
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
} else {
/* see comment above in why we add an icon for an
* unmounted mountable volume */
item->type = PANEL_GIO_VOLUME;
item->u.volume = g_object_ref (volume);
}
items = g_slist_prepend (items, item);
g_object_unref (volume);
}
g_list_free (volumes);
/* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */
mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GFile *root;
mount = l->data;
if (g_mount_is_shadowed (mount)) {
g_object_unref (mount);
continue;
}
volume = g_mount_get_volume (mount);
if (volume != NULL) {
g_object_unref (volume);
g_object_unref (mount);
continue;
}
root = g_mount_get_root (mount);
if (!g_file_is_native (root)) {
g_object_unref (root);
g_object_unref (mount);
continue;
}
g_object_unref (root);
item = g_slice_new (PanelGioItem);
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
items = g_slist_prepend (items, item);
}
g_list_free (mounts);
/* now that we have everything, add the items inline or in a submenu */
items = g_slist_reverse (items);
if (g_slist_length (items) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_REMOVABLE_MEDIA,
NULL, NULL,
_("Removable Media"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (sl = items; sl; sl = sl->next) {
item = sl->data;
switch (item->type) {
case PANEL_GIO_DRIVE:
panel_menu_item_append_drive (add_menu, item->u.drive);
g_object_unref (item->u.drive);
break;
case PANEL_GIO_VOLUME:
panel_menu_item_append_volume (add_menu, item->u.volume);
g_object_unref (item->u.volume);
break;
case PANEL_GIO_MOUNT:
panel_menu_item_append_mount (add_menu, item->u.mount);
g_object_unref (item->u.mount);
break;
default:
g_assert_not_reached ();
}
g_slice_free (PanelGioItem, item);
}
g_slist_free (items);
}
static void
panel_menu_items_append_from_desktop (GtkWidget *menu,
char *path,
char *force_name)
{
GKeyFile *key_file;
gboolean loaded;
GtkWidget *item;
char *path_freeme;
char *full_path;
char *uri;
char *icon;
char *name;
char *comment;
path_freeme = NULL;
key_file = g_key_file_new ();
if (g_path_is_absolute (path)) {
loaded = g_key_file_load_from_file (key_file, path,
G_KEY_FILE_NONE, NULL);
full_path = path;
} else {
char *lookup_file;
char *desktop_path;
if (!g_str_has_suffix (path, ".desktop")) {
desktop_path = g_strconcat (path, ".desktop", NULL);
} else {
desktop_path = path;
}
lookup_file = g_strconcat ("applications", G_DIR_SEPARATOR_S,
desktop_path, NULL);
loaded = g_key_file_load_from_data_dirs (key_file, lookup_file,
&path_freeme,
G_KEY_FILE_NONE,
NULL);
full_path = path_freeme;
g_free (lookup_file);
if (desktop_path != path)
g_free (desktop_path);
}
if (!loaded) {
g_key_file_free (key_file);
if (path_freeme)
g_free (path_freeme);
return;
}
icon = panel_util_key_file_get_locale_string (key_file, "Icon");
comment = panel_util_key_file_get_locale_string (key_file, "Comment");
if (string_empty (force_name))
name = panel_util_key_file_get_locale_string (key_file, "Name");
else
name = g_strdup (force_name);
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
icon, NULL, NULL, name);
panel_util_set_tooltip_text (item, comment);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect_data (item, "activate",
G_CALLBACK (panel_menu_item_activate_desktop_file),
g_strdup (full_path),
(GClosureNotify) g_free, 0);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
uri = g_filename_to_uri (full_path, NULL, NULL);
setup_uri_drag (item, uri, icon);
g_free (uri);
g_key_file_free (key_file);
if (icon)
g_free (icon);
if (name)
g_free (name);
if (comment)
g_free (comment);
if (path_freeme)
g_free (path_freeme);
}
static void
start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attr_names,
const gchar **attr_values,
gpointer user_data,
GError **error)
{
DeskmenuObject *dm_object = user_data;
DeskmenuElementType element_type;
const gchar **ncursor = attr_names, **vcursor = attr_values;
GtkWidget *item, *menu;
gint w, h;
element_type = GPOINTER_TO_INT (g_hash_table_lookup
(element_hash, element_name));
if ((dm_object->menu && !dm_object->current_menu)
|| (!dm_object->menu && element_type != DESKMENU_ELEMENT_MENU))
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num, &char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element '%s' declared outside of "
"toplevel menu element", line_num, char_num, element_name);
return;
}
switch (element_type)
{
case DESKMENU_ELEMENT_MENU:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
if (!dm_object->menu)
{
/*if (strcmp (*ncursor, "size") == 0) {
deskmenu->w = g_strdup (*vcursor);
deskmenu->h = g_strdup (*vcursor);
}
else {
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, deskmenu->w, deskmenu->h);
}*/
dm_object->menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (dm_object->menu), "parent menu",
NULL);
dm_object->current_menu = dm_object->menu;
}
else
{
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
name = g_strdup (*vcursor);
else if (strcmp (*ncursor, "icon") == 0)
icon = g_strdup (*vcursor);
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (name_exec)
{
GtkWidget *label;
GHook *hook;
item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (name)
item = gtk_image_menu_item_new_with_mnemonic (name);
else
item = gtk_image_menu_item_new_with_mnemonic ("");
}
if (icon)
{
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL)));
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "parent menu",
dm_object->current_menu);
dm_object->current_menu = menu;
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
dm_object->current_menu);
if (!dm_object->make_from_pipe)
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
dm_object->pin_items = g_slist_prepend (dm_object->pin_items, pin);
}
else
{
if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu)))
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
}
}
g_free (name);
g_free (icon);
}
break;
case DESKMENU_ELEMENT_SEPARATOR:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
else {
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
gboolean decorate = FALSE;
gint w, h;
item = gtk_separator_menu_item_new();
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
{
name = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if (strcmp (*ncursor, "icon") == 0)
{
icon = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (decorate)
{
GtkWidget *box = gtk_hbox_new (FALSE, 3);
gtk_container_add (GTK_CONTAINER(item), GTK_WIDGET(box));
if (name_exec)
{
GtkWidget *label;
GHook *hook;
label = gtk_label_new_with_mnemonic (NULL);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_box_pack_end (GTK_BOX(box), label, TRUE, FALSE, 0);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
gtk_box_pack_end (GTK_BOX(box), gtk_label_new_with_mnemonic (name), TRUE, FALSE, 0);
}
if (icon)
{
GtkWidget *image;
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
image = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL));
}
else {
image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU);
}
gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 0);
}
gtk_widget_set_state (item, GTK_STATE_PRELIGHT); /*derive colors from menu hover*/
g_free (name);
g_free (icon);
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
}
break;
case DESKMENU_ELEMENT_ITEM:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'item' cannot be nested "
"inside of another item element", line_num, char_num);
return;
}
dm_object->current_item = g_slice_new0 (DeskmenuItem);
while (*ncursor)
{
if (strcmp (*ncursor, "type") == 0)
dm_object->current_item->type = GPOINTER_TO_INT
(g_hash_table_lookup (item_hash, *vcursor));
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
break;
case DESKMENU_ELEMENT_NAME:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
dm_object->current_item->name_exec = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_ICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->icon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_VPICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->vpicon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_COMMAND:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode2") == 0)
&& (strcmp (*vcursor, "pipe") == 0))
dm_object->current_item->command_pipe = TRUE;
if (dm_object->current_item->command_pipe == TRUE
&& (strcmp (*ncursor, "cache") == 0)
&& (strcmp (*vcursor, "true") == 0))
dm_object->current_item->cache_output = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_WRAP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_THISVP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_MINIONLY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_QUANTITY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_SORT:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_AGE:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
default:
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
"Unknown element: %s", element_name);
break;
}
}
static gboolean gtkdial_signal_emission_hook(GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GObject *p = G_OBJECT(g_value_peek_pointer(param_values+0));
GtkMenu *m = GTK_MENU(g_value_peek_pointer(param_values+1));
GtkClipboard *c = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
GObject *o = gtk_clipboard_get_owner(c);
GtkTextBuffer *b = GTK_IS_TEXT_VIEW(p) ? gtk_text_view_get_buffer(GTK_TEXT_VIEW(p)) : NULL;
const gchar *text = NULL;
int out[3];
if (o && (p == o || (gpointer)b == o)) {
/* text is local; should be fast */
text = gtk_clipboard_wait_for_text(c);
} else if (GTK_IS_ENTRY(p)) {
text = gtk_entry_get_text(GTK_ENTRY(p));
} else if (GTK_IS_LABEL(p)) {
text = gtk_label_get_label(GTK_LABEL(p));
}
if (text != NULL && pcre_exec(regexp_phone, regexp_phone_extra, text, strlen(text),
0, 0, out, 3) && out[1] > out[0]) {
gchar *label;
int need, len = out[1] - out[0];
const char *str = text + out[0];
free(last_phone_number);
last_phone_number = NULL;
if ((need = gtkdial_make_canonical(NULL, str, len)) > 1) {
last_phone_number = malloc(1 + need);
gtkdial_make_canonical(last_phone_number, str, len);
last_phone_number[need] = '\0';
}
if (last_phone_number != NULL && asprintf(&label, "Dial: %s", last_phone_number)) {
GtkIconSet *icon_set = gtk_style_lookup_icon_set(gtk_widget_get_style(GTK_WIDGET(m)),
"call-start");
GtkImageMenuItem *item;
GtkImage *icon;
if (!icon_set) {
icon = GTK_IMAGE(gtk_image_new_from_file("/usr/share/icons/gnome-human/16x16/actions/call-start.png"));
} else {
icon = GTK_IMAGE(gtk_image_new_from_icon_set(icon_set, GTK_ICON_SIZE_MENU));
}
item = GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new());
gtk_image_menu_item_set_image(item, GTK_WIDGET(icon));
gtk_menu_item_set_label(GTK_MENU_ITEM(item), label);
free(label);
g_signal_connect(G_OBJECT(item), "activate", (void*)gtkdial_doit, NULL);
gtk_widget_show(GTK_WIDGET(item));
gtk_menu_prepend(m, GTK_WIDGET(item));
}
}
return TRUE;
}
/* Builds a menu item representing a running application in the
messaging menu */
static gboolean
new_application_item (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client)
{
gchar *cName = g_strdup (dbusmenu_menuitem_property_get(newitem, APPLICATION_MENUITEM_PROP_NAME));
const gchar *sIconName = dbusmenu_menuitem_property_get (newitem, APPLICATION_MENUITEM_PROP_ICON);
cd_debug ("%s (\"%s\")", __func__, cName);
#ifdef FORCE_REMOVE_DOUBLE_ENTRIES
#if (INDICATOR_OLD_NAMES == 0)
if (newitem == NULL || !dbusmenu_menuitem_property_get_bool(newitem, DBUSMENU_MENUITEM_PROP_VISIBLE)
#if INDICATOR_MESSAGES_HAS_LOZENGE == 1
&& sIconName != NULL && *sIconName != '\0' // these menu
#endif
)
{
dbusmenu_menuitem_child_delete (parent, newitem);
cd_debug ("Not visible: %s", cName);
g_free (cName);
return TRUE;
}
#endif
#endif
GtkMenuItem * gmi = GTK_MENU_ITEM(gtk_image_menu_item_new());
gint padding = 4;
gtk_widget_style_get(GTK_WIDGET(gmi), "toggle-spacing", &padding, NULL);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, padding);
// Added for Cairo-Dock
#if INDICATOR_MESSAGES_HAS_LOZENGE == 1 // we add a left margin
if (! dbusmenu_menuitem_property_get_bool(newitem, DBUSMENU_MENUITEM_PROP_VISIBLE)
&& (sIconName == NULL || *sIconName == '\0'))
{
gint width, height;
gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
gtk_widget_set_size_request(GTK_WIDGET (gmi), -1, height + 4);
gtk_widget_set_margin_left (hbox, width + padding);
}
#endif
// end
GtkWidget * icon = gtk_image_new_from_icon_name(sIconName, GTK_ICON_SIZE_MENU);
gtk_misc_set_alignment(GTK_MISC(icon), 1.0 /* right aligned */, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
/* Application name in a label */
GtkWidget * label = gtk_label_new(cName);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(gmi), hbox);
gtk_widget_show_all (GTK_WIDGET (gmi));
/* Attach some of the standard GTK stuff */
dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, gmi, parent);
/* Make sure we can handle the label changing */
g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(application_prop_change_cb), label);
g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(application_icon_change_cb), icon);
g_signal_connect_after(G_OBJECT (gmi), "draw", G_CALLBACK (application_triangle_draw_cb), newitem);
g_free (cName);
return TRUE;
}
static void
deskmenu_construct_item (DeskmenuObject *dm_object)
{
DeskmenuItem *item = dm_object->current_item;
GtkWidget *menu_item, *submenu;
gchar *name, *icon, *command, *vpicon;
gboolean images;
gint w, h;
//constructs the items in menu
switch (item->type)
{
case DESKMENU_ITEM_LAUNCHER:
if (item->name_exec)
{
GtkWidget *label;
GHook *hook;
name = g_strstrip (item->name->str);
menu_item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (menu_item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (item->name)
name = g_strstrip (item->name->str);
else
name = "";
menu_item = gtk_image_menu_item_new_with_mnemonic (name);
}
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
if (item->command_pipe)
{
command = g_strstrip (item->command->str);
if (item->cache_output)
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("yes"));
}
else
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("no"));
}
g_object_set_data(G_OBJECT(menu_item), "menu", dm_object);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (pipe_menu_recreate), g_strdup(command));
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
}
else
{
if (item->command)
{
command = g_strstrip (item->command->str);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (launcher_activated), g_strdup (command));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
#if HAVE_WNCK
case DESKMENU_ITEM_WINDOWLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Windows");
images = FALSE;
gboolean this_vp = FALSE;
gboolean mini_only = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->thisvp
&& strcmp (g_strstrip (item->thisvp->str), "true") == 0)
this_vp = TRUE;
if (item->mini_only
&& strcmp (g_strstrip (item->mini_only->str), "true") == 0)
mini_only = TRUE;
g_object_set_data(G_OBJECT(menu_item), "windowlist", deskmenu_windowlist_initialize (images, this_vp, mini_only));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_windowlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_DESKTOPLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Desktops");
gboolean file;
images = FALSE;
file = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "dplist", deskmenu_dplist_initialize (images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_desktoplist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_VIEWPORTLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Viewports");
gboolean wrap;
wrap = FALSE;
images = FALSE;
file = FALSE;
if (item->wrap && strcmp (g_strstrip (item->wrap->str), "true") == 0)
wrap = TRUE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "vplist", deskmenu_vplist_initialize (wrap, images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_viewportlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
#endif
case DESKMENU_ITEM_RELOAD:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Reload");
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (quit), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
case DESKMENU_ITEM_DOCUMENTS:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Recent Doc_uments");
gint limit, age;
gchar *sort_type;
images = FALSE;
sort_type = "least used";
age = 25;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->age)
{
age = atoi(g_strstrip (item->age->str));
}
if (item->sort_type)
{
sort_type = g_strstrip (item->sort_type->str);
}
if (item->quantity)
{
limit = atoi(g_strstrip (item->quantity->str));
}
else
{
limit = -1;
}
if (item->command)
{
command = g_strstrip (item->command->str);
}
else
{
command = g_strdup ("xdg-open");
}
GtkWidget *docs = make_recent_documents_list(images, command, limit, age, sort_type);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
docs);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
default:
break;
}
}
static void
panel_place_menu_item_append_gtk_bookmarks (GtkWidget *menu)
{
typedef struct {
char *full_uri;
char *label;
} PanelBookmark;
GtkWidget *add_menu;
char *filename;
GIOChannel *io_channel;
GHashTable *table;
int i;
GSList *lines = NULL;
GSList *add_bookmarks, *l;
PanelBookmark *bookmark;
filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
io_channel = g_io_channel_new_file (filename, "r", NULL);
g_free (filename);
if (!io_channel)
return;
/* We use a hard limit to avoid having users shooting their
* own feet, and to avoid crashing the system if a misbehaving
* application creates a big bookmars file.
*/
for (i = 0; i < MAX_BOOKMARK_ITEMS; i++) {
char *contents;
gsize length;
gsize terminator_pos;
GIOStatus status;
status = g_io_channel_read_line (io_channel, &contents, &length, &terminator_pos, NULL);
if (status != G_IO_STATUS_NORMAL)
break;
if (length == 0)
break;
/* Clear the line terminator (\n), if any */
if (terminator_pos > 0)
contents[terminator_pos] = '\0';
lines = g_slist_prepend (lines, contents);
}
g_io_channel_shutdown (io_channel, FALSE, NULL);
g_io_channel_unref (io_channel);
if (!lines)
return;
lines = g_slist_reverse (lines);
table = g_hash_table_new (g_str_hash, g_str_equal);
add_bookmarks = NULL;
for (l = lines; l; l = l->next) {
char *line = (char*) l->data;
if (line[0] && !g_hash_table_lookup (table, line)) {
GFile *file;
char *space;
char *label;
gboolean keep;
g_hash_table_insert (table, line, line);
space = strchr (line, ' ');
if (space) {
*space = '\0';
label = g_strdup (space + 1);
} else {
label = NULL;
}
keep = FALSE;
if (g_str_has_prefix (line, "x-caja-search:"))
keep = TRUE;
if (!keep) {
file = g_file_new_for_uri (line);
keep = !g_file_is_native (file) ||
g_file_query_exists (file, NULL);
g_object_unref (file);
}
if (!keep) {
if (label)
g_free (label);
continue;
}
bookmark = g_malloc (sizeof (PanelBookmark));
bookmark->full_uri = g_strdup (line);
bookmark->label = label;
add_bookmarks = g_slist_prepend (add_bookmarks, bookmark);
}
}
g_hash_table_destroy (table);
g_slist_foreach (lines, (GFunc) g_free, NULL);
g_slist_free (lines);
add_bookmarks = g_slist_reverse (add_bookmarks);
if (g_slist_length (add_bookmarks) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_BOOKMARKS, NULL, NULL,
_("Bookmarks"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (l = add_bookmarks; l; l = l->next) {
char *display_name;
char *tooltip;
char *label;
char *icon;
GFile *file;
GIcon *gicon;
bookmark = l->data;
file = g_file_new_for_uri (bookmark->full_uri);
display_name = g_file_get_parse_name (file);
g_object_unref (file);
/* Translators: %s is a URI */
tooltip = g_strdup_printf (_("Open '%s'"), display_name);
g_free (display_name);
label = NULL;
if (bookmark->label) {
label = g_strdup (g_strstrip (bookmark->label));
if (!label [0]) {
g_free (label);
label = NULL;
}
}
if (!label) {
label = panel_util_get_label_for_uri (bookmark->full_uri);
if (!label) {
g_free (tooltip);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
continue;
}
}
icon = panel_util_get_icon_for_uri (bookmark->full_uri);
/*FIXME: we should probably get a GIcon if possible, so that we
* have customized icons for cd-rom, eg */
if (!icon)
icon = g_strdup (PANEL_ICON_FOLDER);
gicon = g_themed_icon_new_with_default_fallbacks (icon);
//FIXME: drag and drop will be broken for x-caja-search uris
panel_menu_items_append_place_item (icon, gicon,
label,
tooltip,
add_menu,
G_CALLBACK (activate_uri),
bookmark->full_uri);
g_free (icon);
g_object_unref (gicon);
g_free (tooltip);
g_free (label);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
}
g_slist_free (add_bookmarks);
}
static void
panel_place_menu_item_append_gtk_bookmarks (GtkWidget *menu)
{
typedef struct {
char *full_uri;
char *label;
} PanelBookmark;
GtkWidget *add_menu;
char *filename;
char *contents;
gchar **lines;
GHashTable *table;
int i;
GSList *add_bookmarks, *l;
PanelBookmark *bookmark;
filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
if (!g_file_get_contents (filename, &contents, NULL, NULL)) {
g_free (filename);
return;
}
g_free (filename);
lines = g_strsplit (contents, "\n", -1);
g_free (contents);
table = g_hash_table_new (g_str_hash, g_str_equal);
add_bookmarks = NULL;
for (i = 0; lines[i]; i++) {
if (lines[i][0] && !g_hash_table_lookup (table, lines[i])) {
GFile *file;
char *space;
char *label;
gboolean keep;
g_hash_table_insert (table, lines[i], lines[i]);
space = strchr (lines[i], ' ');
if (space) {
*space = '\0';
label = g_strdup (space + 1);
} else {
label = NULL;
}
keep = FALSE;
if (g_str_has_prefix (lines[i], "x-nautilus-search:"))
keep = TRUE;
if (!keep) {
file = g_file_new_for_uri (lines[i]);
keep = !g_file_is_native (file) ||
g_file_query_exists (file, NULL);
g_object_unref (file);
}
if (!keep) {
if (label)
g_free (label);
continue;
}
bookmark = g_malloc (sizeof (PanelBookmark));
bookmark->full_uri = g_strdup (lines[i]);
bookmark->label = label;
add_bookmarks = g_slist_prepend (add_bookmarks, bookmark);
}
}
g_hash_table_destroy (table);
g_strfreev (lines);
add_bookmarks = g_slist_reverse (add_bookmarks);
if (g_slist_length (add_bookmarks) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_BOOKMARKS, NULL, NULL,
_("Bookmarks"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (l = add_bookmarks; l; l = l->next) {
char *display_name;
char *tooltip;
char *label;
char *icon;
GFile *file;
bookmark = l->data;
file = g_file_new_for_uri (bookmark->full_uri);
display_name = g_file_get_parse_name (file);
g_object_unref (file);
/* Translators: %s is a URI */
tooltip = g_strdup_printf (_("Open '%s'"), display_name);
g_free (display_name);
label = NULL;
if (bookmark->label) {
label = g_strdup (g_strstrip (bookmark->label));
if (!label [0]) {
g_free (label);
label = NULL;
}
}
if (!label) {
label = panel_util_get_label_for_uri (bookmark->full_uri);
if (!label) {
g_free (tooltip);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
continue;
}
}
icon = panel_util_get_icon_for_uri (bookmark->full_uri);
/*FIXME: we should probably get a GIcon if possible, so that we
* have customized icons for cd-rom, eg */
if (!icon)
icon = g_strdup (PANEL_ICON_FOLDER);
//FIXME: drag and drop will be broken for x-nautilus-search uris
panel_menu_items_append_place_item (icon, NULL,
label,
tooltip,
add_menu,
G_CALLBACK (activate_uri),
bookmark->full_uri);
g_free (icon);
g_free (tooltip);
g_free (label);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
}
g_slist_free (add_bookmarks);
}
/** \brief Show satellite popup menu.
* \param sat Pointer to the satellite data.
* \param qth The current location.
* \param pview The GtkPolarView widget.
* \param event The mouse-click related event info
* \param toplevel The toplevel window or NULL.
*
*/
void
gtk_polar_view_popup_exec(sat_t * sat,
qth_t * qth,
GtkPolarView * pview,
GdkEventButton * event, GtkWidget * toplevel)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *label;
GtkWidget *image;
gchar *buff;
sat_obj_t *obj = NULL;
gint *catnum;
menu = gtk_menu_new();
/* first menu item is the satellite name, centered */
menuitem = gtk_image_menu_item_new();
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
buff = g_markup_printf_escaped("<b>%s</b>", sat->nickname);
gtk_label_set_markup(GTK_LABEL(label), buff);
g_free(buff);
gtk_container_add(GTK_CONTAINER(menuitem), label);
image = gtk_image_new_from_stock(GTK_STOCK_INFO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
/* attach data to menuitem and connect callback */
g_object_set_data(G_OBJECT(menuitem), "sat", sat);
g_object_set_data(G_OBJECT(menuitem), "qth", qth);
g_signal_connect(menuitem, "activate", G_CALLBACK(show_sat_info_menu_cb),
toplevel);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* add the menu items for current,next, and future passes. */
add_pass_menu_items(menu, sat, qth, &pview->tstamp, GTK_WIDGET(pview));
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* get sat obj since we'll need it for the remaining items */
catnum = g_new0(gint, 1);
*catnum = sat->tle.catnr;
obj = SAT_OBJ(g_hash_table_lookup(pview->obj, catnum));
g_free(catnum);
/* show track */
menuitem = gtk_check_menu_item_new_with_label(_("Sky track"));
g_object_set_data(G_OBJECT(menuitem), "sat", sat);
g_object_set_data(G_OBJECT(menuitem), "qth", qth);
g_object_set_data(G_OBJECT(menuitem), "obj", obj);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
obj->showtrack);
g_signal_connect(menuitem, "activate", G_CALLBACK(track_toggled), pview);
/* disable menu item if satellite is geostationary */
if (sat->otype == ORBIT_TYPE_GEO)
gtk_widget_set_sensitive(menuitem, FALSE);
/* target */
/* menuitem = gtk_check_menu_item_new_with_label (_("Set as target")); */
/* g_object_set_data (G_OBJECT (menuitem), "sat", sat); */
/* g_object_set_data (G_OBJECT (menuitem), "qth", qth); */
/* g_object_set_data (G_OBJECT (menuitem), "obj", obj); */
/* gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); */
/* gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), obj->istarget); */
/* g_signal_connect (menuitem, "activate", G_CALLBACK (target_toggled), pview); */
gtk_widget_show_all(menu);
/* Note: event can be NULL here when called from view_onPopupMenu;
* gdk_event_get_time() accepts a NULL argument */
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent *) event));
}
void
panel_recent_append_documents_menu (GtkWidget *top_menu,
GtkRecentManager *manager)
{
GtkWidget *recent_menu;
GtkWidget *menu_item;
int size;
menu_item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (menu_item,
panel_menu_icon_get_size (),
PANEL_ICON_RECENT,
NULL, NULL,
_("Recent Documents"));
recent_menu = gtk_recent_chooser_menu_new_for_manager (manager);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), recent_menu);
g_signal_connect (G_OBJECT (recent_menu), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (top_menu), menu_item);
gtk_widget_show_all (menu_item);
gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (recent_menu),
FALSE);
gtk_recent_chooser_set_show_tips (GTK_RECENT_CHOOSER (recent_menu),
TRUE);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (recent_menu),
GTK_RECENT_SORT_MRU);
g_signal_connect (GTK_RECENT_CHOOSER (recent_menu),
"item-activated",
G_CALLBACK (recent_documents_activate_cb),
NULL);
//FIXME this is not possible with GtkRecent...: egg_recent_view_gtk_set_icon_size (view, panel_menu_icon_get_size ());
g_signal_connect_object (manager, "changed",
G_CALLBACK (panel_recent_manager_changed_cb),
menu_item, 0);
size = 0;
g_object_get (manager, "size", &size, NULL);
gtk_widget_set_sensitive (menu_item, size > 0);
add_menu_separator (recent_menu);
menu_item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (menu_item,
panel_menu_icon_get_size (),
NULL,
GTK_STOCK_CLEAR, NULL,
_("Clear Recent Documents..."));
panel_util_set_tooltip_text (menu_item,
_("Clear all items from the recent documents list"));
gtk_menu_shell_append (GTK_MENU_SHELL (recent_menu), menu_item);
g_signal_connect (menu_item, "activate",
G_CALLBACK (recent_documents_clear_cb),
manager);
}