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;
}
GtkWidget* panel_place_menu_item_new(gboolean use_image)
{
PanelPlaceMenuItem* menuitem;
GtkWidget* image;
menuitem = g_object_new(PANEL_TYPE_PLACE_MENU_ITEM, NULL);
if (use_image)
{
image = gtk_image_new_from_icon_name(PANEL_ICON_FOLDER, panel_menu_icon_get_size());
}
else
{
image = NULL;
}
setup_menuitem(GTK_WIDGET(menuitem), image ? panel_menu_icon_get_size() : GTK_ICON_SIZE_INVALID, image, _("Places"));
menuitem->priv->use_image = use_image;
menuitem->priv->menu = panel_place_menu_item_create_menu(menuitem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menuitem->priv->menu);
return GTK_WIDGET(menuitem);
}
GtkWidget *
panel_desktop_menu_item_new (gboolean use_image,
gboolean append_lock_logout)
{
PanelDesktopMenuItem *menuitem;
GtkWidget *image;
menuitem = g_object_new (PANEL_TYPE_DESKTOP_MENU_ITEM, NULL);
if (use_image)
image = gtk_image_new_from_icon_name ("computer",
panel_menu_icon_get_size ());
else
image = NULL;
setup_menuitem (GTK_WIDGET (menuitem),
image ? panel_menu_icon_get_size () : GTK_ICON_SIZE_INVALID,
image,
_("System"));
menuitem->priv->use_image = use_image;
menuitem->priv->append_lock_logout = append_lock_logout;
if (append_lock_logout)
panel_lockdown_notify_add (G_CALLBACK (panel_desktop_menu_item_recreate_menu),
menuitem);
menuitem->priv->menu = panel_desktop_menu_item_create_menu (menuitem);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
menuitem->priv->menu);
return GTK_WIDGET (menuitem);
}
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);
}
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 = panel_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);
if (g_str_has_prefix (uri, "file:")) /*Links only work for local files*/
setup_uri_drag (item, uri, icon_name, GDK_ACTION_LINK);
}
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;
}
static GtkWidget *
panel_menu_item_drive_new (GDrive *drive)
{
GtkWidget *item;
GIcon *icon;
char *title;
char *tooltip;
icon = g_drive_get_icon (drive);
title = g_drive_get_name (drive);
item = panel_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 (_("Rescan %s"), title);
panel_util_set_tooltip_text (item, tooltip);
g_free (tooltip);
g_free (title);
g_signal_connect_data (item, "activate",
G_CALLBACK (panel_menu_item_rescan_drive),
g_object_ref (drive),
(GClosureNotify) g_object_unref, 0);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
return item;
}
static GtkWidget *
panel_menu_item_uri_new (const char *uri,
const char *icon_name,
GIcon *gicon,
const char *title,
const char *tooltip,
GCallback callback)
{
GtkWidget *item;
char *user_data;
item = panel_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);
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);
return item;
}
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 = panel_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 void
panel_desktop_menu_item_on_presence_changed (PanelSessionManager *manager,
PanelSessionManagerPresenceType presence_type,
PanelDesktopMenuItem *desktop_item)
{
const char *icon;
GtkWidget *image;
GList *l;
switch (presence_type) {
case PANEL_SESSION_MANAGER_PRESENCE_AVAILABLE:
icon = PANEL_ICON_USER_AVAILABLE;
break;
case PANEL_SESSION_MANAGER_PRESENCE_INVISIBLE:
icon = PANEL_ICON_USER_INVISIBLE;
break;
case PANEL_SESSION_MANAGER_PRESENCE_BUSY:
icon = PANEL_ICON_USER_BUSY;
break;
case PANEL_SESSION_MANAGER_PRESENCE_IDLE:
default:
icon = PANEL_ICON_USER_IDLE;
break;
}
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (desktop_item));
/* we only have an image if we are specifically using an icon for this
* menu */
if (image) {
gtk_image_set_from_icon_name (GTK_IMAGE (image),
icon, panel_menu_icon_get_size ());
}
for (l = desktop_item->priv->presence_items; l != NULL; l = l->next) {
PanelSessionManagerPresenceType for_presence;
GObject *object = l->data;
for_presence = GPOINTER_TO_INT (g_object_get_data (object,
"panel-menu-presence"));
g_signal_handlers_block_by_func (object,
panel_menu_item_activate_presence,
desktop_item->priv->account_manager);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (object),
for_presence == presence_type);
g_signal_handlers_unblock_by_func (object,
panel_menu_item_activate_presence,
desktop_item->priv->account_manager);
}
}
static 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 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;
}
static void
create_menuitem (GtkWidget *menu,
MateMenuTreeEntry *entry,
MateMenuTreeDirectory *alias_directory)
{
GtkWidget *menuitem;
menuitem = panel_image_menu_item_new ();
g_object_set_data_full (G_OBJECT (menuitem),
"panel-menu-tree-entry",
matemenu_tree_item_ref (entry),
(GDestroyNotify) matemenu_tree_item_unref);
if (alias_directory)
//FIXME: we should probably use this data when we do dnd or
//context menu for this menu item
g_object_set_data_full (G_OBJECT (menuitem),
"panel-menu-tree-alias-directory",
matemenu_tree_item_ref (alias_directory),
(GDestroyNotify) matemenu_tree_item_unref);
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
NULL, NULL,
alias_directory ? matemenu_tree_directory_get_icon (alias_directory) :
matemenu_tree_entry_get_icon (entry),
PANEL_STOCK_DEFAULT_ICON);
setup_menuitem (menuitem,
panel_menu_icon_get_size (),
NULL,
alias_directory ? matemenu_tree_directory_get_name (alias_directory) :
matemenu_tree_entry_get_display_name (entry));
if (alias_directory &&
matemenu_tree_directory_get_comment (alias_directory))
panel_util_set_tooltip_text (menuitem,
matemenu_tree_directory_get_comment (alias_directory));
else if (!alias_directory &&
matemenu_tree_entry_get_comment (entry))
panel_util_set_tooltip_text (menuitem,
matemenu_tree_entry_get_comment (entry));
else if (!alias_directory &&
matemenu_tree_entry_get_generic_name (entry))
panel_util_set_tooltip_text (menuitem,
matemenu_tree_entry_get_generic_name (entry));
g_signal_connect_after (menuitem, "button_press_event",
G_CALLBACK (menuitem_button_press_event), NULL);
if (!panel_lockdown_get_locked_down ()) {
static GtkTargetEntry menu_item_targets[] = {
{ "text/uri-list", 0, 0 }
};
gtk_drag_source_set (menuitem,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
menu_item_targets, 1,
GDK_ACTION_COPY);
if (matemenu_tree_entry_get_icon (entry) != NULL) {
const char *icon;
char *icon_no_ext;
icon = matemenu_tree_entry_get_icon (entry);
if (!g_path_is_absolute (icon)) {
icon_no_ext = panel_xdg_icon_remove_extension (icon);
gtk_drag_source_set_icon_name (menuitem,
icon_no_ext);
g_free (icon_no_ext);
}
}
g_signal_connect (G_OBJECT (menuitem), "drag_begin",
G_CALLBACK (drag_begin_menu_cb), NULL);
g_signal_connect (menuitem, "drag_data_get",
G_CALLBACK (drag_data_get_menu_cb), entry);
g_signal_connect (menuitem, "drag_end",
G_CALLBACK (drag_end_menu_cb), NULL);
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_app_def), entry);
gtk_widget_show (menuitem);
}
static gboolean
panel_run_dialog_add_items_idle (PanelRunDialog *dialog)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model_filter;
GSList *all_applications;
GSList *l;
GSList *next;
const char *prev_name;
/* create list store */
dialog->program_list_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_ICON,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
all_applications = get_all_applications ();
/* Strip duplicates */
prev_name = NULL;
for (l = all_applications; l; l = next) {
MateMenuTreeEntry *entry = l->data;
const char *entry_name;
next = l->next;
entry_name = matemenu_tree_entry_get_display_name (entry);
if (prev_name && entry_name && strcmp (entry_name, prev_name) == 0) {
matemenu_tree_item_unref (entry);
all_applications = g_slist_delete_link (all_applications, l);
} else {
prev_name = entry_name;
}
}
for (l = all_applications; l; l = l->next) {
MateMenuTreeEntry *entry = l->data;
GtkTreeIter iter;
const gchar *icon = matemenu_tree_entry_get_icon (entry);
GIcon *gicon = panel_gicon_from_icon_name (icon);
gtk_list_store_append (dialog->program_list_store, &iter);
gtk_list_store_set (dialog->program_list_store, &iter,
COLUMN_GICON, gicon,
COLUMN_NAME, matemenu_tree_entry_get_display_name (entry),
COLUMN_COMMENT, matemenu_tree_entry_get_comment (entry),
COLUMN_EXEC, matemenu_tree_entry_get_exec (entry),
COLUMN_PATH, matemenu_tree_entry_get_desktop_file_path (entry),
COLUMN_VISIBLE, TRUE,
-1);
g_object_unref (gicon);
matemenu_tree_item_unref (entry);
}
g_slist_free (all_applications);
model_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (dialog->program_list_store),
NULL);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (model_filter),
COLUMN_VISIBLE);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->program_list),
model_filter);
//FIXME use the same search than the fuzzy one?
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->program_list),
COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", panel_menu_icon_get_size(), NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COLUMN_GICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COLUMN_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->program_list), column);
dialog->add_items_idle_id = 0;
return G_SOURCE_REMOVE;
}
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
create_menuitem (GtkWidget *menu,
GMenuTreeEntry *entry,
GMenuTreeDirectory *alias_directory)
{
GtkWidget *menuitem;
menuitem = panel_image_menu_item_new2 ();
if (alias_directory)
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
gmenu_tree_directory_get_icon (alias_directory),
NULL,
NULL);
else
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))),
NULL, NULL);
setup_menuitem (menuitem,
panel_menu_icon_get_size (),
NULL,
alias_directory ? gmenu_tree_directory_get_name (alias_directory) :
g_app_info_get_display_name (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))));
if (alias_directory &&
gmenu_tree_directory_get_comment (alias_directory))
panel_util_set_tooltip_text (menuitem,
gmenu_tree_directory_get_comment (alias_directory));
else if (!alias_directory) {
const char *description = g_app_info_get_description (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)));
if (!description)
description = g_desktop_app_info_get_generic_name (gmenu_tree_entry_get_app_info (entry));
if (description)
panel_util_set_tooltip_text (menuitem,
description);
}
g_signal_connect_after (menuitem, "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
if (!panel_lockdown_get_panels_locked_down_s ()) {
GIcon *icon;
static GtkTargetEntry menu_item_targets[] = {
{ "text/uri-list", 0, 0 }
};
gtk_drag_source_set (menuitem,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
menu_item_targets, 1,
GDK_ACTION_COPY);
icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)));
if (icon != NULL)
gtk_drag_source_set_icon_gicon (menuitem, icon);
g_signal_connect (G_OBJECT (menuitem), "drag_begin",
G_CALLBACK (drag_begin_menu_cb), NULL);
g_signal_connect (menuitem, "drag_data_get",
G_CALLBACK (drag_data_get_menu_cb), entry);
g_signal_connect (menuitem, "drag_end",
G_CALLBACK (drag_end_menu_cb), NULL);
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_app_def), entry);
gtk_widget_show (menuitem);
}
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);
}
/* 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,
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);
}
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);
}
/* this is loosely based on update_places() from caja-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;
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);
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 = panel_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);
}
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);
}
