static void
update_bookmarks (NautilusWindow *window)
{
NautilusBookmarkList *bookmarks;
NautilusBookmark *bookmark;
guint bookmark_count;
guint index;
GtkUIManager *ui_manager;
g_assert (NAUTILUS_IS_WINDOW (window));
g_assert (window->details->bookmarks_merge_id == 0);
g_assert (window->details->bookmarks_action_group == NULL);
if (window->details->bookmark_list == NULL) {
window->details->bookmark_list = nautilus_bookmark_list_new ();
}
bookmarks = window->details->bookmark_list;
ui_manager = nautilus_window_get_ui_manager (NAUTILUS_WINDOW (window));
window->details->bookmarks_merge_id = gtk_ui_manager_new_merge_id (ui_manager);
window->details->bookmarks_action_group = gtk_action_group_new ("BookmarksGroup");
g_signal_connect (window->details->bookmarks_action_group, "connect-proxy",
G_CALLBACK (connect_proxy_cb), NULL);
gtk_ui_manager_insert_action_group (ui_manager,
window->details->bookmarks_action_group,
-1);
g_object_unref (window->details->bookmarks_action_group);
/* append new set of bookmarks */
bookmark_count = nautilus_bookmark_list_length (bookmarks);
for (index = 0; index < bookmark_count; ++index) {
bookmark = nautilus_bookmark_list_item_at (bookmarks, index);
if (nautilus_bookmark_uri_known_not_to_exist (bookmark)) {
continue;
}
nautilus_menus_append_bookmark_to_menu
(NAUTILUS_WINDOW (window),
bookmark,
NAUTILUS_WINDOW_GET_CLASS (window)->bookmarks_placeholder,
"dynamic",
index,
window->details->bookmarks_action_group,
window->details->bookmarks_merge_id,
G_CALLBACK (refresh_bookmarks_menu),
show_bogus_bookmark_window);
}
}
static NautilusBookmark *
get_selected_bookmark (void)
{
g_return_val_if_fail(NAUTILUS_IS_BOOKMARK_LIST(bookmarks), NULL);
if (!get_selection_exists())
return NULL;
if (nautilus_bookmark_list_length (bookmarks) < 1)
return NULL;
return nautilus_bookmark_list_item_at(bookmarks, get_selected_row ());
}
static NautilusBookmark *
get_selected_bookmark (NautilusBookmarksWindow *self)
{
if (!get_selection_exists (self)) {
return NULL;
}
if (nautilus_bookmark_list_length (self->priv->bookmarks) < 1) {
return NULL;
}
return nautilus_bookmark_list_item_at (self->priv->bookmarks,
get_selected_row (self));
}
/* This is a bit of a kludge to get DnD to work. We check if the row in the
GtkListStore matches the one in the bookmark list. If it doesn't, we assume
the bookmark has just been dragged here and we insert it into the bookmark
list. */
static void
on_row_changed (GtkListStore *store,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
NautilusBookmark *bookmark = NULL, *bookmark_in_list;
gint *indices, row;
gboolean insert_bookmark = TRUE;
store = bookmark_list_store;
indices = gtk_tree_path_get_indices (path);
row = indices[0];
gtk_tree_model_get (GTK_TREE_MODEL (store), iter,
BOOKMARK_LIST_COLUMN_BOOKMARK, &bookmark,
-1);
/* If the bookmark in the list doesn't match the changed one, it must
have been dragged here, so we insert it into the list. */
if (row < (gint) nautilus_bookmark_list_length (bookmarks)) {
bookmark_in_list = nautilus_bookmark_list_item_at (bookmarks,
row);
if (bookmark_in_list == bookmark)
insert_bookmark = FALSE;
}
if (insert_bookmark) {
g_signal_handler_block (bookmarks,
bookmark_list_changed_signal_id);
nautilus_bookmark_list_insert_item (bookmarks, bookmark, row);
g_signal_handler_unblock (bookmarks,
bookmark_list_changed_signal_id);
/* The bookmark will be copied when inserted into the list, so
we have to update the pointer in the list store. */
bookmark = nautilus_bookmark_list_item_at (bookmarks, row);
g_signal_handler_block (store, row_changed_signal_id);
gtk_list_store_set (store, iter,
BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark,
-1);
g_signal_handler_unblock (store, row_changed_signal_id);
}
}
static void
bookmarks_set_empty (NautilusBookmarksWindow *self,
gboolean empty)
{
GtkTreeIter iter;
if (empty) {
setup_empty_list (self);
gtk_widget_set_sensitive (GTK_WIDGET (self->priv->tree_view), FALSE);
} else {
gtk_tree_view_set_model (self->priv->tree_view, GTK_TREE_MODEL (self->priv->model));
gtk_widget_set_sensitive (GTK_WIDGET (self->priv->tree_view), TRUE);
if (nautilus_bookmark_list_length (self->priv->bookmarks) > 0 &&
!get_selection_exists (self)) {
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (self->priv->model),
&iter, NULL, 0);
gtk_tree_selection_select_iter (self->priv->selection, &iter);
}
}
on_selection_changed (self->priv->selection, self);
}
static void
bookmarks_set_empty (gboolean empty)
{
GtkTreeIter iter;
if (empty) {
gtk_tree_view_set_model (bookmark_list_widget,
GTK_TREE_MODEL (bookmark_empty_list_store));
gtk_widget_set_sensitive (GTK_WIDGET (bookmark_list_widget), FALSE);
} else {
gtk_tree_view_set_model (bookmark_list_widget,
GTK_TREE_MODEL (bookmark_list_store));
gtk_widget_set_sensitive (GTK_WIDGET (bookmark_list_widget), TRUE);
if (nautilus_bookmark_list_length (bookmarks) > 0 &&
!get_selection_exists ()) {
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (bookmark_list_store),
&iter, NULL, 0);
gtk_tree_selection_select_iter (bookmark_selection, &iter);
}
}
on_selection_changed (bookmark_selection, NULL);
}
static void
repopulate (void)
{
NautilusBookmark *selected;
GtkListStore *store;
GtkTreePath *path;
GtkTreeRowReference *reference;
guint index;
g_assert (GTK_IS_TREE_VIEW (bookmark_list_widget));
g_assert (NAUTILUS_IS_BOOKMARK_LIST (bookmarks));
store = GTK_LIST_STORE (bookmark_list_store);
selected = get_selected_bookmark ();
g_signal_handler_block (bookmark_selection,
selection_changed_id);
g_signal_handler_block (bookmark_list_store,
row_deleted_signal_id);
g_signal_handler_block (bookmark_list_widget,
row_activated_signal_id);
g_signal_handler_block (bookmark_list_widget,
key_pressed_signal_id);
g_signal_handler_block (bookmark_list_widget,
button_pressed_signal_id);
gtk_list_store_clear (store);
g_signal_handler_unblock (bookmark_list_widget,
row_activated_signal_id);
g_signal_handler_unblock (bookmark_list_widget,
key_pressed_signal_id);
g_signal_handler_unblock (bookmark_list_widget,
button_pressed_signal_id);
g_signal_handler_unblock (bookmark_list_store,
row_deleted_signal_id);
g_signal_handler_unblock (bookmark_selection,
selection_changed_id);
/* Fill the list in with the bookmark names. */
g_signal_handler_block (store, row_changed_signal_id);
reference = NULL;
for (index = 0; index < nautilus_bookmark_list_length (bookmarks); ++index) {
NautilusBookmark *bookmark;
const char *bookmark_name;
GIcon *bookmark_icon;
GtkTreeIter iter;
bookmark = nautilus_bookmark_list_item_at (bookmarks, index);
bookmark_name = nautilus_bookmark_get_name (bookmark);
bookmark_icon = nautilus_bookmark_get_icon (bookmark);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
BOOKMARK_LIST_COLUMN_ICON, bookmark_icon,
BOOKMARK_LIST_COLUMN_NAME, bookmark_name,
BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark,
BOOKMARK_LIST_COLUMN_STYLE, PANGO_STYLE_NORMAL,
-1);
if (bookmark == selected) {
/* save old selection */
GtkTreePath *path;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
reference = gtk_tree_row_reference_new (GTK_TREE_MODEL (store), path);
gtk_tree_path_free (path);
}
g_object_unref (bookmark_icon);
}
g_signal_handler_unblock (store, row_changed_signal_id);
if (reference != NULL) {
/* restore old selection */
/* bookmarks_set_empty() will call the selection change handler,
* so we block it here in case of selection change.
*/
g_signal_handler_block (bookmark_selection, selection_changed_id);
g_assert (index != 0);
g_assert (gtk_tree_row_reference_valid (reference));
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_selection_select_path (bookmark_selection, path);
gtk_tree_row_reference_free (reference);
gtk_tree_path_free (path);
g_signal_handler_unblock (bookmark_selection, selection_changed_id);
}
bookmarks_set_empty (index == 0);
}