static void update_bookmark_from_text (void) { if (text_changed) { NautilusBookmark *bookmark, *bookmark_in_list; char *name; GdkPixbuf *pixbuf; guint selected_row; GtkTreeIter iter; GFile *location; g_assert (GTK_IS_ENTRY (name_field)); g_assert (GTK_IS_ENTRY (uri_field)); location = g_file_new_for_uri (gtk_entry_get_text (GTK_ENTRY (uri_field))); bookmark = nautilus_bookmark_new_with_icon (location, gtk_entry_get_text (GTK_ENTRY (name_field)), name_text_changed, NULL); g_object_unref (location); selected_row = get_selected_row (); /* turn off list updating 'cuz otherwise the list-reordering code runs * after repopulate(), thus reordering the correctly-ordered list. */ g_signal_handler_block (bookmarks, bookmark_list_changed_signal_id); nautilus_bookmark_list_delete_item_at (bookmarks, selected_row); nautilus_bookmark_list_insert_item (bookmarks, bookmark, selected_row); g_signal_handler_unblock (bookmarks, bookmark_list_changed_signal_id); g_object_unref (bookmark); /* We also have to update the bookmark pointer in the list store. */ gtk_tree_selection_get_selected (bookmark_selection, NULL, &iter); g_signal_handler_block (bookmark_list_store, row_changed_signal_id); bookmark_in_list = nautilus_bookmark_list_item_at (bookmarks, selected_row); name = nautilus_bookmark_get_name (bookmark_in_list); pixbuf = nautilus_bookmark_get_pixbuf (bookmark_in_list, GTK_ICON_SIZE_MENU); gtk_list_store_set (bookmark_list_store, &iter, BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark_in_list, BOOKMARK_LIST_COLUMN_NAME, name, BOOKMARK_LIST_COLUMN_ICON, pixbuf, -1); g_signal_handler_unblock (bookmark_list_store, row_changed_signal_id); gdk_pixbuf_unref (pixbuf); g_free (name); } }
/* 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 update_bookmark_from_text (NautilusBookmarksWindow *self) { NautilusBookmark *bookmark, *bookmark_in_list; const char *name; GIcon *icon; guint selected_row; GtkTreeIter iter; GFile *location; if (!self->priv->text_changed || gtk_entry_get_text_length (GTK_ENTRY (self->priv->uri_field)) == 0) { return; } location = g_file_parse_name (gtk_entry_get_text (GTK_ENTRY (self->priv->uri_field))); bookmark = nautilus_bookmark_new (location, self->priv->name_text_changed ? gtk_entry_get_text (GTK_ENTRY (self->priv->name_field)) : NULL, NULL); g_object_unref (location); selected_row = get_selected_row (self); /* turn off list updating 'cuz otherwise the list-reordering code runs * after repopulate(), thus reordering the correctly-ordered list. */ g_signal_handler_block (self->priv->bookmarks, self->priv->bookmarks_changed_id); nautilus_bookmark_list_delete_item_at (self->priv->bookmarks, selected_row); nautilus_bookmark_list_insert_item (self->priv->bookmarks, bookmark, selected_row); g_signal_handler_unblock (self->priv->bookmarks, self->priv->bookmarks_changed_id); g_object_unref (bookmark); /* We also have to update the bookmark pointer in the list store. */ gtk_tree_selection_get_selected (self->priv->selection, NULL, &iter); g_signal_handler_block (self->priv->model, self->priv->row_changed_id); bookmark_in_list = nautilus_bookmark_list_item_at (self->priv->bookmarks, selected_row); name = nautilus_bookmark_get_name (bookmark_in_list); icon = nautilus_bookmark_get_icon (bookmark_in_list); gtk_list_store_set (self->priv->model, &iter, BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark_in_list, BOOKMARK_LIST_COLUMN_NAME, name, BOOKMARK_LIST_COLUMN_ICON, icon, -1); g_signal_handler_unblock (self->priv->model, self->priv->row_changed_id); g_object_unref (icon); }
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)); }
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); }