static void
unity_bookmarks_handler_update_bookmarks () {
NemoBookmark *bookmark;
guint bookmark_count;
guint index;
GList *l;
/* append new set of bookmarks */
bookmark_count = nemo_bookmark_list_length (bookmarks);
for (index = 0; index < bookmark_count; ++index) {
bookmark = nemo_bookmark_list_item_at (bookmarks, index);
if (nemo_bookmark_uri_known_not_to_exist (bookmark)) {
continue;
}
for (l = unity_quicklist_get_launcher_entries (unity_quicklist_handler); l; l = l->next) {
UnityLauncherEntry *entry = l->data;
DbusmenuMenuitem* menuitem = dbusmenu_menuitem_new();
gchar *bookmark_name_dbusmenu = eel_str_replace_substring (nemo_bookmark_get_name (bookmark), "_", "__");
dbusmenu_menuitem_property_set (menuitem, "label", bookmark_name_dbusmenu);
g_free (bookmark_name_dbusmenu);
g_signal_connect (menuitem, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
(GCallback) activate_bookmark_by_quicklist,
bookmark);
unity_quicklist_handler_append_menuitem (entry, menuitem);
}
}
}
/* 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)
{
NemoBookmark *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) nemo_bookmark_list_length (bookmarks)) {
bookmark_in_list = nemo_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);
nemo_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 = nemo_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_bookmarks (NemoWindow *window)
{
NemoBookmarkList *bookmarks;
NemoBookmark *bookmark;
guint bookmark_count;
guint index;
GtkUIManager *ui_manager;
g_assert (NEMO_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 = nemo_bookmark_list_new ();
}
bookmarks = window->details->bookmark_list;
ui_manager = nemo_window_get_ui_manager (NEMO_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 = nemo_bookmark_list_length (bookmarks);
for (index = 0; index < bookmark_count; ++index) {
bookmark = nemo_bookmark_list_item_at (bookmarks, index);
if (!nemo_bookmark_get_exists (bookmark)) {
continue;
}
nemo_menus_append_bookmark_to_menu
(NEMO_WINDOW (window),
bookmark,
MENU_PATH_BOOKMARKS_PLACEHOLDER,
"dynamic",
index,
window->details->bookmarks_action_group,
window->details->bookmarks_merge_id,
G_CALLBACK (refresh_bookmarks_menu),
show_bogus_bookmark_window);
}
}
static NemoBookmark *
get_selected_bookmark (void)
{
g_return_val_if_fail(NEMO_IS_BOOKMARK_LIST(bookmarks), NULL);
if (!get_selection_exists())
return NULL;
if (nemo_bookmark_list_length (bookmarks) < 1)
return NULL;
return nemo_bookmark_list_item_at(bookmarks, get_selected_row ());
}
static void
repopulate (void)
{
NemoBookmark *selected;
GtkListStore *store;
GtkTreePath *path;
GtkTreeRowReference *reference;
guint index;
g_assert (GTK_IS_TREE_VIEW (bookmark_list_widget));
g_assert (NEMO_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 < nemo_bookmark_list_length (bookmarks); ++index) {
NemoBookmark *bookmark;
const char *bookmark_name;
GIcon *bookmark_icon;
GtkTreeIter iter;
bookmark = nemo_bookmark_list_item_at (bookmarks, index);
bookmark_name = nemo_bookmark_get_name (bookmark);
bookmark_icon = nemo_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);
}
static void
update_bookmark_from_text (void)
{
if (text_changed) {
NemoBookmark *bookmark, *bookmark_in_list;
const char *name;
GIcon *icon;
guint selected_row;
GtkTreeIter iter;
GFile *location;
g_assert (GTK_IS_ENTRY (name_field));
g_assert (GTK_IS_ENTRY (uri_field));
if (gtk_entry_get_text_length (GTK_ENTRY (uri_field)) == 0) {
return;
}
location = g_file_parse_name
(gtk_entry_get_text (GTK_ENTRY (uri_field)));
bookmark = nemo_bookmark_new (location,
name_text_changed ? gtk_entry_get_text (GTK_ENTRY (name_field)) : NULL,
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);
nemo_bookmark_list_delete_item_at (bookmarks, selected_row);
nemo_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 = nemo_bookmark_list_item_at (bookmarks,
selected_row);
name = nemo_bookmark_get_name (bookmark_in_list);
icon = nemo_bookmark_get_icon (bookmark_in_list);
gtk_list_store_set (bookmark_list_store, &iter,
BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark_in_list,
BOOKMARK_LIST_COLUMN_NAME, name,
BOOKMARK_LIST_COLUMN_ICON, icon,
-1);
g_signal_handler_unblock (bookmark_list_store,
row_changed_signal_id);
g_object_unref (icon);
}
}
