Move more dnd related files to ui/base

chrome/browser/ui/gtk/bookmark_bar_gtk.cc

 // Copyright (c) 2011 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/ui/gtk/bookmark_bar_gtk.h"
 
 #include <vector>
 
-#include "app/gtk_dnd_util.h"
 #include "app/resource_bundle.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/importer/importer_data_types.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/ntp_background_util.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/ui/gtk/tabstrip_origin_provider.h"
 #include "chrome/browser/ui/gtk/view_id_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "gfx/canvas_skia_paint.h"
 #include "gfx/gtk_util.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/animation/slide_animation.h"
+#include "ui/base/dragdrop/gtk_dnd_util.h"
 
 namespace {
 
 // The showing height of the bar.
 const int kBookmarkBarHeight = 29;
 
 // Padding for when the bookmark bar is floating.
 const int kTopBottomNTPPadding = 12;
 const int kLeftRightNTPPadding = 8;
 
@@ skipping 10 matching lines @@
 const int kBookmarkBarMinimumHeight = 3;
 
 // Left-padding for the instructional text.
 const int kInstructionsPadding = 6;
 
 // Padding around the "Other Bookmarks" button.
 const int kOtherBookmarksPaddingHorizontal = 2;
 const int kOtherBookmarksPaddingVertical = 1;
 
 // The targets accepted by the toolbar and folder buttons for DnD.
-const int kDestTargetList[] = { gtk_dnd_util::CHROME_BOOKMARK_ITEM,
-                                gtk_dnd_util::CHROME_NAMED_URL,
-                                gtk_dnd_util::TEXT_URI_LIST,
-                                gtk_dnd_util::NETSCAPE_URL,
-                                gtk_dnd_util::TEXT_PLAIN, -1 };
+const int kDestTargetList[] = { ui::CHROME_BOOKMARK_ITEM,
+                                ui::CHROME_NAMED_URL,
+                                ui::TEXT_URI_LIST,
+                                ui::NETSCAPE_URL,
+                                ui::TEXT_PLAIN, -1 };
 
 // Acceptable drag actions for the bookmark bar drag destinations.
 const GdkDragAction kDragAction =
     GdkDragAction(GDK_ACTION_MOVE | GDK_ACTION_COPY);
 
 void SetToolBarStyle() {
   static bool style_was_set = false;
 
   if (style_was_set)
     return;
@@ skipping 111 matching lines @@
   gtk_alignment_set_padding(GTK_ALIGNMENT(instructions_), 0, 0,
                             kInstructionsPadding, 0);
   instructions_gtk_.reset(new BookmarkBarInstructionsGtk(this, profile));
   gtk_container_add(GTK_CONTAINER(instructions_), instructions_gtk_->widget());
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), instructions_,
                      TRUE, TRUE, 0);
 
   gtk_drag_dest_set(instructions_,
       GtkDestDefaults(GTK_DEST_DEFAULT_DROP | GTK_DEST_DEFAULT_MOTION),
       NULL, 0, kDragAction);
-  gtk_dnd_util::SetDestTargetList(instructions_, kDestTargetList);
+  ui::SetDestTargetList(instructions_, kDestTargetList);
   g_signal_connect(instructions_, "drag-data-received",
                    G_CALLBACK(&OnDragReceivedThunk), this);
 
   g_signal_connect(event_box_.get(), "expose-event",
                    G_CALLBACK(&OnEventBoxExposeThunk), this);
   UpdateEventBoxPaintability();
 
   bookmark_toolbar_.Own(gtk_toolbar_new());
   SetToolBarStyle();
   gtk_widget_set_name(bookmark_toolbar_.get(), "chrome-bookmark-toolbar");
   gtk_util::SuppressDefaultPainting(bookmark_toolbar_.get());
   g_signal_connect(bookmark_toolbar_.get(), "size-allocate",
                    G_CALLBACK(&OnToolbarSizeAllocateThunk), this);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), bookmark_toolbar_.get(),
                      TRUE, TRUE, 0);
 
   overflow_button_ = theme_provider_->BuildChromeButton();
   g_object_set_data(G_OBJECT(overflow_button_), "left-align-popup",
                     reinterpret_cast<void*>(true));
   SetOverflowButtonAppearance();
   ConnectFolderButtonEvents(overflow_button_, false);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), overflow_button_,
                      FALSE, FALSE, 0);
 
   gtk_drag_dest_set(bookmark_toolbar_.get(), GTK_DEST_DEFAULT_DROP,
                     NULL, 0, kDragAction);
-  gtk_dnd_util::SetDestTargetList(bookmark_toolbar_.get(), kDestTargetList);
+  ui::SetDestTargetList(bookmark_toolbar_.get(), kDestTargetList);
   g_signal_connect(bookmark_toolbar_.get(), "drag-motion",
                    G_CALLBACK(&OnToolbarDragMotionThunk), this);
   g_signal_connect(bookmark_toolbar_.get(), "drag-leave",
                    G_CALLBACK(&OnDragLeaveThunk), this);
   g_signal_connect(bookmark_toolbar_.get(), "drag-data-received",
                    G_CALLBACK(&OnDragReceivedThunk), this);
 
   GtkWidget* vseparator = theme_provider_->CreateToolbarSeparator();
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), vseparator,
                      FALSE, FALSE, 0);
@@ skipping 580 matching lines @@
 }
 
 GtkWidget* BookmarkBarGtk::CreateBookmarkButton(const BookmarkNode* node) {
   GtkWidget* button = theme_provider_->BuildChromeButton();
   bookmark_utils::ConfigureButtonForNode(node, model_, button, theme_provider_);
 
   // The tool item is also a source for dragging
   gtk_drag_source_set(button, GDK_BUTTON1_MASK, NULL, 0,
       static_cast<GdkDragAction>(GDK_ACTION_MOVE | GDK_ACTION_COPY));
   int target_mask = bookmark_utils::GetCodeMask(node->is_folder());
-  gtk_dnd_util::SetSourceTargetListFromCodeMask(button, target_mask);
+  ui::SetSourceTargetListFromCodeMask(button, target_mask);
   g_signal_connect(button, "drag-begin",
                    G_CALLBACK(&OnButtonDragBeginThunk), this);
   g_signal_connect(button, "drag-end",
                    G_CALLBACK(&OnButtonDragEndThunk), this);
   g_signal_connect(button, "drag-data-get",
                    G_CALLBACK(&OnButtonDragGetThunk), this);
   // We deliberately don't connect to "drag-data-delete" because the action of
   // moving a button will regenerate all the contents of the bookmarks bar
   // anyway.
 
@@ skipping 28 matching lines @@
 void BookmarkBarGtk::ConnectFolderButtonEvents(GtkWidget* widget,
                                                bool is_tool_item) {
   // For toolbar items (i.e. not the overflow button or other bookmarks
   // button), we handle motion and highlighting manually.
   gtk_drag_dest_set(widget,
                     is_tool_item ? GTK_DEST_DEFAULT_DROP :
                                    GTK_DEST_DEFAULT_ALL,
                     NULL,
                     0,
                     kDragAction);
-  gtk_dnd_util::SetDestTargetList(widget, kDestTargetList);
+  ui::SetDestTargetList(widget, kDestTargetList);
   g_signal_connect(widget, "drag-data-received",
                    G_CALLBACK(&OnDragReceivedThunk), this);
   if (is_tool_item) {
     g_signal_connect(widget, "drag-motion",
                      G_CALLBACK(&OnFolderDragMotionThunk), this);
     g_signal_connect(widget, "drag-leave",
                      G_CALLBACK(&OnDragLeaveThunk), this);
   }
 
   g_signal_connect(widget, "button-press-event",
@@ skipping 206 matching lines @@
       // TODO(erg): Maybe somehow figure out the real size for the drop target?
       toolbar_drop_item_ =
           CreateBookmarkToolItem(model_->other_node());
       g_object_ref_sink(GTK_OBJECT(toolbar_drop_item_));
     }
   }
 
   gtk_toolbar_set_drop_highlight_item(GTK_TOOLBAR(bookmark_toolbar_.get()),
                                       GTK_TOOL_ITEM(toolbar_drop_item_),
                                       index);
-  if (target_type ==
-      gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::CHROME_BOOKMARK_ITEM)) {
+  if (target_type == ui::GetAtomForTarget(ui::CHROME_BOOKMARK_ITEM)) {
     gdk_drag_status(context, GDK_ACTION_MOVE, time);
   } else {
     gdk_drag_status(context, GDK_ACTION_COPY, time);
   }
 
   return TRUE;
 }
 
 gboolean BookmarkBarGtk::OnToolbarDragMotion(GtkWidget* toolbar,
                                              GdkDragContext* context,
@@ skipping 25 matching lines @@
   GdkAtom target_type = gtk_drag_dest_find_target(button, context, NULL);
   if (target_type == GDK_NONE)
     return FALSE;
 
   int index = GetToolbarIndexForDragOverFolder(button, x);
   if (index < 0) {
     ClearToolbarDropHighlighting();
 
     // Drag is over middle of folder.
     gtk_drag_highlight(button);
-    if (target_type ==
-        gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::CHROME_BOOKMARK_ITEM)) {
+    if (target_type == ui::GetAtomForTarget(ui::CHROME_BOOKMARK_ITEM)) {
       gdk_drag_status(context, GDK_ACTION_MOVE, time);
     } else {
       gdk_drag_status(context, GDK_ACTION_COPY, time);
     }
 
     return TRUE;
   }
 
   // Remove previous highlighting.
   gtk_drag_unhighlight(button);
@@ skipping 52 matching lines @@
     index = 0;
   } else {
     index = GetToolbarIndexForDragOverFolder(widget, x);
     if (index < 0) {
       dest_node = GetNodeForToolButton(widget);
       index = dest_node->GetChildCount();
     }
   }
 
   switch (target_type) {
-    case gtk_dnd_util::CHROME_BOOKMARK_ITEM: {
+    case ui::CHROME_BOOKMARK_ITEM: {
       std::vector<const BookmarkNode*> nodes =
           bookmark_utils::GetNodesFromSelection(context, selection_data,
                                                 target_type,
                                                 profile_,
                                                 &delete_selection_data,
                                                 &dnd_success);
       DCHECK(!nodes.empty());
       for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
            it != nodes.end(); ++it) {
         model_->Move(*it, dest_node, index);
         index = dest_node->IndexOfChild(*it) + 1;
       }
       break;
     }
 
-    case gtk_dnd_util::CHROME_NAMED_URL: {
+    case ui::CHROME_NAMED_URL: {
       dnd_success = bookmark_utils::CreateNewBookmarkFromNamedUrl(
           selection_data, model_, dest_node, index);
       break;
     }
 
-    case gtk_dnd_util::TEXT_URI_LIST: {
+    case ui::TEXT_URI_LIST: {
       dnd_success = bookmark_utils::CreateNewBookmarksFromURIList(
           selection_data, model_, dest_node, index);
       break;
     }
 
-    case gtk_dnd_util::NETSCAPE_URL: {
+    case ui::NETSCAPE_URL: {
       dnd_success = bookmark_utils::CreateNewBookmarkFromNetscapeURL(
           selection_data, model_, dest_node, index);
       break;
     }
 
-    case gtk_dnd_util::TEXT_PLAIN: {
+    case ui::TEXT_PLAIN: {
       guchar* text = gtk_selection_data_get_text(selection_data);
       if (!text)
         break;
       GURL url(reinterpret_cast<char*>(text));
       g_free(text);
       // TODO(estade): It would be nice to head this case off at drag motion,
       // so that it doesn't look like we can drag onto the bookmark bar.
       if (!url.is_valid())
         break;
       std::string title = bookmark_utils::GetNameForURL(url);
@@ skipping 124 matching lines @@
 
   // Find the GtkWidget* for the actual target button.
   int shift = dir == GTK_MENU_DIR_PARENT ? -1 : 1;
   button_idx = (button_idx + shift + folder_list.size()) % folder_list.size();
   PopupForButton(folder_list[button_idx]);
 }
 
 void BookmarkBarGtk::CloseMenu() {
   current_context_menu_->Cancel();
 }