Correctly update drag status for drags over renderer. This makes things look ...

chrome/browser/gtk/bookmark_bar_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_bar_gtk.h"
 
 #include <vector>
 
 #include "app/gfx/text_elider.h"
 #include "app/l10n_util.h"
@@ skipping 30 matching lines @@
 
 // The height of the bar.
 const int kBookmarkBarHeight = 29;
 
 // Left-padding for the instructional text.
 const int kInstructionsPadding = 6;
 
 // Color of the instructional text.
 const GdkColor kInstructionsColor = GDK_COLOR_RGB(128, 128, 142);
 
+const int kDestTargetList[] = { GtkDndUtil::CHROME_BOOKMARK_ITEM,

[tony, 2009/07/27 23:33:03]

Nit: Comment?

+                                GtkDndUtil::CHROME_NAMED_URL,
+                                GtkDndUtil::TEXT_URI_LIST,
+                                GtkDndUtil::TEXT_PLAIN, 0 };
+
 void SetToolBarStyle() {
   static bool style_was_set = false;
 
   if (style_was_set)
     return;
   style_was_set = true;
 
   gtk_rc_parse_string(
       "style \"chrome-bookmark-toolbar\" {"
       "  xthickness = 0\n"
@@ skipping 91 matching lines @@
   SetToolBarStyle();
   gtk_widget_set_name(bookmark_toolbar_.get(), "chrome-bookmark-toolbar");
   gtk_widget_set_app_paintable(bookmark_toolbar_.get(), TRUE);
   g_signal_connect(G_OBJECT(bookmark_toolbar_.get()), "expose-event",
                    G_CALLBACK(&OnToolbarExpose), this);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), bookmark_toolbar_.get(),
                      TRUE, TRUE, 0);
 
   gtk_drag_dest_set(bookmark_toolbar_.get(), GTK_DEST_DEFAULT_DROP,
                     NULL, 0, GDK_ACTION_MOVE);
-  GtkDndUtil::SetDestTargetListFromCodeMask(bookmark_toolbar_.get(),
-                                            GtkDndUtil::CHROME_BOOKMARK_ITEM |
-                                            GtkDndUtil::CHROME_NAMED_URL);
+  GtkDndUtil::SetDestTargetList(bookmark_toolbar_.get(), kDestTargetList);
   g_signal_connect(bookmark_toolbar_.get(), "drag-motion",
                    G_CALLBACK(&OnToolbarDragMotion), this);
   g_signal_connect(bookmark_toolbar_.get(), "drag-leave",
                    G_CALLBACK(&OnToolbarDragLeave), this);
   g_signal_connect(bookmark_toolbar_.get(), "drag-data-received",
-                   G_CALLBACK(&OnToolbarDragReceived), this);
+                   G_CALLBACK(&OnDragReceived), this);
   g_signal_connect(bookmark_toolbar_.get(), "button-press-event",
                    G_CALLBACK(&OnButtonPressed), this);
 
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), gtk_vseparator_new(),
                      FALSE, FALSE, 0);
 
   // We pack the button manually (rather than using gtk_button_set_*) so that
   // we can have finer control over its label.
   other_bookmarks_button_ = theme_provider_->BuildChromeButton();
   ConnectFolderButtonEvents(other_bookmarks_button_);
@@ skipping 261 matching lines @@
 
   GtkToolItem* item = gtk_tool_item_new();
   gtk_container_add(GTK_CONTAINER(item), button);
   gtk_widget_show_all(GTK_WIDGET(item));
 
   return item;
 }
 
 void BookmarkBarGtk::ConnectFolderButtonEvents(GtkWidget* widget) {
   gtk_drag_dest_set(widget, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_MOVE);
-  GtkDndUtil::SetDestTargetListFromCodeMask(widget,
-                                            GtkDndUtil::CHROME_BOOKMARK_ITEM |
-                                            GtkDndUtil::CHROME_NAMED_URL);
+  GtkDndUtil::SetDestTargetList(widget, kDestTargetList);
   g_signal_connect(widget, "drag-data-received",
-                   G_CALLBACK(&OnFolderDragReceived), this);
+                   G_CALLBACK(&OnDragReceived), this);
 
   // Connect to 'button-release-event' instead of 'clicked' because we need
   // access to the modifier keys and we do different things on each
   // button.
   g_signal_connect(G_OBJECT(widget), "button-press-event",
                    G_CALLBACK(OnButtonPressed), this);
   g_signal_connect(G_OBJECT(widget), "button-release-event",
                    G_CALLBACK(OnFolderButtonReleased), this);
 }
 
@@ skipping 192 matching lines @@
                                  node,
                                  0,
                                  false));
   bar->current_menu_->Popup(sender, event->button, event->time);
 
   // Allow other handlers to run so the button state is updated correctly.
   return FALSE;
 }
 
 // static
-void BookmarkBarGtk::OnFolderDragReceived(GtkWidget* widget,
-    GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data,
-    guint target_type, guint time, BookmarkBarGtk* bar) {
-  gboolean dnd_success = FALSE;
-  gboolean delete_selection_data = FALSE;
-
-  const BookmarkNode* dest_node = bar->GetNodeForToolButton(widget);
-  DCHECK(dest_node->is_folder());
-
-  if (target_type == GtkDndUtil::CHROME_BOOKMARK_ITEM) {
-    std::vector<const BookmarkNode*> nodes =
-        bookmark_utils::GetNodesFromSelection(context, selection_data,
-                                              target_type,
-                                              bar->profile_,
-                                              &delete_selection_data,
-                                              &dnd_success);
-    DCHECK(!nodes.empty());
-    DCHECK(dnd_success);
-
-    for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
-         it != nodes.end(); ++it) {
-      bar->model_->Move(*it, dest_node, dest_node->GetChildCount());
-    }
-  } else if (target_type == GtkDndUtil::CHROME_NAMED_URL) {
-    dnd_success = bookmark_utils::CreateNewBookmarkFromNamedUrl(
-        selection_data, bar->model_, dest_node, dest_node->GetChildCount());
-  } else {
-    NOTREACHED();
-  }
-
-  gtk_drag_finish(context, dnd_success, delete_selection_data, time);
-}
-
-// static
 gboolean BookmarkBarGtk::OnToolbarExpose(GtkWidget* widget,
                                          GdkEventExpose* event,
                                          BookmarkBarGtk* bar) {
   // A GtkToolbar's expose handler first draws a box. We don't want that so we
   // need to propagate the expose event to all the container's children.
   GList* children = gtk_container_get_children(GTK_CONTAINER(widget));
   for (GList* item = children; item; item = item->next) {
     gtk_container_propagate_expose(GTK_CONTAINER(widget),
                                    GTK_WIDGET(item->data),
                                    event);
@@ skipping 51 matching lines @@
                                         BookmarkBarGtk* bar) {
   if (bar->toolbar_drop_item_) {
     g_object_unref(bar->toolbar_drop_item_);
     bar->toolbar_drop_item_ = NULL;
   }
 
   gtk_toolbar_set_drop_highlight_item(toolbar, NULL, 0);
 }
 
 // static
-void BookmarkBarGtk::OnToolbarDragReceived(GtkWidget* widget,
-                                           GdkDragContext* context,
-                                           gint x, gint y,
-                                           GtkSelectionData* selection_data,
-                                           guint target_type, guint time,
-                                           BookmarkBarGtk* bar) {
+void BookmarkBarGtk::OnDragReceived(GtkWidget* widget,
+                                    GdkDragContext* context,
+                                    gint x, gint y,
+                                    GtkSelectionData* selection_data,
+                                    guint target_type, guint time,
+                                    BookmarkBarGtk* bar) {
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
-  gint index = gtk_toolbar_get_drop_index(
+  const BookmarkNode* dest_node;
+  gint index;
+  if (widget == bar->bookmark_toolbar_.get()) {
+    dest_node = bar->model_->GetBookmarkBarNode();
+    index = gtk_toolbar_get_drop_index(
       GTK_TOOLBAR(bar->bookmark_toolbar_.get()), x, y);
+  } else {
+    dest_node = bar->GetNodeForToolButton(widget);
+    index = dest_node->GetChildCount();
+  }
 
-  if (target_type == GtkDndUtil::CHROME_BOOKMARK_ITEM) {
-    std::vector<const BookmarkNode*> nodes =
-        bookmark_utils::GetNodesFromSelection(context, selection_data,
-                                              target_type,
-                                              bar->profile_,
-                                              &delete_selection_data,
-                                              &dnd_success);
-    DCHECK(!nodes.empty());
-    for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
-         it != nodes.end(); ++it) {
-      bar->model_->Move(*it, bar->model_->GetBookmarkBarNode(), index);
-      index = bar->model_->GetBookmarkBarNode()->IndexOfChild(*it) + 1;
+  switch (target_type) {
+    case GtkDndUtil::CHROME_BOOKMARK_ITEM: {
+      std::vector<const BookmarkNode*> nodes =
+          bookmark_utils::GetNodesFromSelection(context, selection_data,
+                                                target_type,
+                                                bar->profile_,
+                                                &delete_selection_data,
+                                                &dnd_success);
+      DCHECK(!nodes.empty());
+      for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
+           it != nodes.end(); ++it) {
+        bar->model_->Move(*it, dest_node, index);
+        index = dest_node->IndexOfChild(*it) + 1;
+      }
+      break;
     }
-  } else if (target_type == GtkDndUtil::CHROME_NAMED_URL) {
-    dnd_success = bookmark_utils::CreateNewBookmarkFromNamedUrl(
-        selection_data, bar->model_, bar->model_->GetBookmarkBarNode(), index);
-  } else {
-    NOTREACHED();
+
+    case GtkDndUtil::CHROME_NAMED_URL: {
+      dnd_success = bookmark_utils::CreateNewBookmarkFromNamedUrl(
+          selection_data, bar->model_, dest_node, index);
+      break;
+    }
+
+    case GtkDndUtil::TEXT_URI_LIST: {
+      dnd_success = bookmark_utils::CreateNewBookmarksFromURIList(
+          selection_data, bar->model_, dest_node, index);
+      break;
+    }
+
+    case GtkDndUtil::TEXT_PLAIN: {
+      guchar* text = gtk_selection_data_get_text(selection_data);
+      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);
+      bar->model_->AddURL(dest_node, index, UTF8ToWide(title), url);
+      dnd_success = TRUE;
+      break;
+    }
   }
 
   gtk_drag_finish(context, dnd_success, delete_selection_data, time);
 }
 
 // static
 gboolean BookmarkBarGtk::OnHBoxExpose(GtkWidget* widget,
                                       GdkEventExpose* event,
                                       BookmarkBarGtk* bar) {
   // Paint the background theme image.
   cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
   cairo_rectangle(cr, event->area.x, event->area.y,
                   event->area.width, event->area.height);
   cairo_clip(cr);
   bar->InitBackground();
   gfx::Point tabstrip_origin =
       bar->window_->tabstrip()->GetTabStripOriginForWidget(widget);
   bar->background_ninebox_->RenderTopCenterStrip(
       cr, tabstrip_origin.x(), tabstrip_origin.y(),
       event->area.x + event->area.width - tabstrip_origin.x());
   cairo_destroy(cr);
 
   return FALSE;  // Propagate expose to children.
 }