Bookmark dragging cleanup....

chrome/browser/gtk/bookmark_manager_gtk.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/gtk/bookmark_manager_gtk.h"
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "chrome/browser/bookmarks/bookmark_manager.h"
@@ skipping 94 matching lines @@
   BookmarkNode* node = parent->GetChild(index);
   // Update left store.
   if (node->is_folder()) {
     GtkTreeIter iter = { 0, };
     if (RecursiveFind(GTK_TREE_MODEL(left_store_), &iter, parent->id()))
       bookmark_utils::AddToTreeStoreAt(node, 0, left_store_, NULL, &iter);
   }
 
   // Update right store.
   if (parent->id() == GetFolder()->id()) {
-    GtkTreeIter iter = { 0, };
-    if (RecursiveFind(GTK_TREE_MODEL(right_store_), &iter,
-        parent->GetChild(index - 1)->id())) {
-      AppendNodeToRightStore(node, &iter);
-    }
+    AppendNodeToRightStore(node, index);
   }
 }
 
 void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
                                              BookmarkNode* parent,
                                              int index) {
   NOTREACHED();
 }
 
 void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
@@ skipping 175 matching lines @@
   right_tree_view_ = gtk_tree_view_new_with_model(GTK_TREE_MODEL(right_store_));
   // Let |tree_view| own the store.
   g_object_unref(right_store_);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), title_column);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), url_column);
   g_signal_connect(right_tree_view_, "row-activated",
                    G_CALLBACK(OnRightTreeViewRowActivated), this);
   g_signal_connect(right_selection(), "changed",
                    G_CALLBACK(OnRightSelectionChanged), this);
 
-  gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(right_tree_view_),
-                                         GDK_BUTTON1_MASK,
-                                         bookmark_utils::kTargetTable,
-                                         bookmark_utils::kTargetTableSize,
-                                         GDK_ACTION_MOVE);
-  gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(right_tree_view_),
-                                       bookmark_utils::kTargetTable,
-                                       bookmark_utils::kTargetTableSize,
-                                       GDK_ACTION_MOVE);
+  // TODO(estade): support GDK_ACTION_COPY for dragging to other apps.
+  gtk_drag_source_set(right_tree_view_,
+                      GDK_BUTTON1_MASK,
+                      bookmark_utils::kTargetTable,
+                      bookmark_utils::kTargetTableSize,
+                      GDK_ACTION_MOVE);
+  gtk_drag_dest_set(right_tree_view_, GTK_DEST_DEFAULT_ALL,
+                    bookmark_utils::kTargetTable,
+                    bookmark_utils::kTargetTableSize,
+                    GDK_ACTION_MOVE);
   g_signal_connect(right_tree_view_, "drag-data-get",
                    G_CALLBACK(&OnRightTreeViewDragGet), this);
   g_signal_connect(right_tree_view_, "drag-data-received",
                    G_CALLBACK(&OnRightTreeViewDragReceived), this);
   g_signal_connect(right_tree_view_, "drag-motion",
                    G_CALLBACK(&OnRightTreeViewDragMotion), this);
-  // Connect after so we can overwrite the drag icon.
-  g_signal_connect_after(right_tree_view_, "drag-begin",
-                         G_CALLBACK(&OnRightTreeViewDragBegin), this);
+  g_signal_connect(right_tree_view_, "drag-begin",
+                   G_CALLBACK(&OnRightTreeViewDragBegin), this);
 
   GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
                                       GTK_SHADOW_ETCHED_IN);
   gtk_container_add(GTK_CONTAINER(scrolled), right_tree_view_);
 
   return scrolled;
 }
 
 void BookmarkManagerGtk::BuildLeftStore() {
   GtkTreeIter select_iter;
   bookmark_utils::AddToTreeStore(model_,
       model_->GetBookmarkBarNode()->id(), left_store_, &select_iter);
   gtk_tree_selection_select_iter(left_selection(), &select_iter);
 
   // TODO(estade): Add recently bookmarked node and search node.
 }
 
 void BookmarkManagerGtk::BuildRightStore() {
   BookmarkNode* node = GetFolder();
   // TODO(estade): eventually we may hit a fake node here (recently bookmarked
   // or search), but until then we require that node != NULL.
   DCHECK(node);
   gtk_list_store_clear(right_store_);
-  GtkTreeIter iter;
 
-  for (int i = 0; i < node->GetChildCount(); ++i) {
-    AppendNodeToRightStore(node->GetChild(i), &iter);
-  }
+  for (int i = 0; i < node->GetChildCount(); ++i)
+    AppendNodeToRightStore(node->GetChild(i), i);
 }
 
 BookmarkNode* BookmarkManagerGtk::GetNodeAt(GtkTreeModel* model,
                                             GtkTreeIter* iter) {
   bool left = model == GTK_TREE_MODEL(left_store_);
   GValue value = { 0, };
   if (left)
     gtk_tree_model_get_value(model, iter, bookmark_utils::ITEM_ID, &value);
   else
     gtk_tree_model_get_value(model, iter, RIGHT_PANE_ID, &value);
@@ skipping 20 matching lines @@
     gtk_tree_model_get_iter(model, &iter,
                             reinterpret_cast<GtkTreePath*>(item->data));
     nodes.push_back(GetNodeAt(model, &iter));
   }
   g_list_free(paths);
 
   return nodes;
 }
 
 void BookmarkManagerGtk::AppendNodeToRightStore(BookmarkNode* node,
-                                                GtkTreeIter* iter) {
+                                                int index) {
+  GtkTreeIter iter;
+  if (index == 0) {
+    gtk_tree_model_get_iter_first(GTK_TREE_MODEL(right_store_), &iter);
+    gtk_list_store_prepend(right_store_, &iter);
+  } else {
+    gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(right_store_), &iter, NULL,
+                                  index - 1);
+    gtk_list_store_append(right_store_, &iter);
+  }
+
   GdkPixbuf* pixbuf = bookmark_utils::GetPixbufForNode(node, model_);
-  gtk_list_store_append(right_store_, iter);
-  gtk_list_store_set(right_store_, iter,
+  gtk_list_store_set(right_store_, &iter,
                      RIGHT_PANE_PIXBUF, pixbuf,
                      RIGHT_PANE_TITLE, WideToUTF8(node->GetTitle()).c_str(),
                      RIGHT_PANE_URL, node->GetURL().spec().c_str(),
                      RIGHT_PANE_ID, node->id(), -1);
   g_object_unref(pixbuf);
 }
 
 bool BookmarkManagerGtk::RecursiveFind(GtkTreeModel* model, GtkTreeIter* iter,
                                        int target) {
   GValue value = { 0, };
@@ skipping 91 matching lines @@
     return;
   }
 
   GtkTreeIter iter;
   gtk_tree_model_get_iter(GTK_TREE_MODEL(bm->left_store_), &iter, path);
   BookmarkNode* folder = bm->GetNodeAt(GTK_TREE_MODEL(bm->left_store_), &iter);
   for (std::vector<BookmarkNode*>::iterator it = nodes.begin();
        it != nodes.end(); ++it) {
     // Don't try to drop a node into one of its descendants.
     if (!folder->HasAncestor(*it))
-      bm->model_->Move(*it, folder, 0);
+      bm->model_->Move(*it, folder, folder->GetChildCount());
   }
 
   gtk_tree_path_free(path);
   gtk_drag_finish(context, dnd_success, delete_selection_data, time);
 }
 
 // static
 gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion(GtkWidget* tree_view,
     GdkDragContext* context, gint x, gint y, guint time,
     BookmarkManagerGtk* bm) {
@@ skipping 154 matching lines @@
   std::vector<BookmarkNode*> nodes = bm->GetRightSelection();
   if (nodes.empty())
     return;
   if (nodes.size() == 1 && nodes[0]->is_folder()) {
     // Double click on a folder descends into the folder.
     bm->SelectInTree(nodes[0]);
     return;
   }
   bookmark_utils::OpenAll(bm->window_, bm->profile_, NULL, nodes, CURRENT_TAB);
 }