GTK: Fancy html5 draggy stuff.

chrome/browser/tab_contents/tab_contents_view_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/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
@@ skipping 171 matching lines @@
 
   if (event->hardware_keycode < arraysize(kHardwareCodeToGdkKeyval)) {
     int keyval = kHardwareCodeToGdkKeyval[event->hardware_keycode];
     if (keyval)
       return keyval;
   }
 
   return event->keyval;
 }
 
+// Get the current location of the mouse cursor relative to the screen.
+gfx::Point ScreenPoint(GtkWidget* widget) {
+  int x, y;
+  gdk_display_get_pointer(gtk_widget_get_display(widget), NULL, &x, &y,
+                          NULL);
+  return gfx::Point(x, y);
+}
+
+// Get the current location of the mouse cursor relative to the widget.
+gfx::Point ClientPoint(GtkWidget* widget) {
+  int x, y;
+  gtk_widget_get_pointer(widget, &x, &y);
+  return gfx::Point(x, y);
+}
+
 }  // namespace
 
 // A helper class that handles DnD for drops in the renderer. In GTK parlance,
 // this handles destination-side DnD, but not source-side DnD.
 class WebDragDest {
  public:
   explicit WebDragDest(TabContents* tab_contents, GtkWidget* widget)
       : tab_contents_(tab_contents),
         widget_(widget),
         context_(NULL),
@@ skipping 78 matching lines @@
       };
 
       data_requests_ = arraysize(supported_targets);
       for (size_t i = 0; i < arraysize(supported_targets); ++i) {
         gtk_drag_get_data(widget_, context,
                           GtkDndUtil::GetAtomForTarget(supported_targets[i]),
                           time);
       }
     } else if (data_requests_ == 0) {
       tab_contents_->render_view_host()->
-          DragTargetDragOver(ClientPoint(), ScreenPoint());
+          DragTargetDragOver(ClientPoint(widget_), ScreenPoint(widget_));
       drag_over_time_ = time;
     }
 
     // Pretend we are a drag destination because we don't want to wait for
     // the renderer to tell us if we really are or not.
     return TRUE;
   }
 
   // We make a series of requests for the drag data when the drag first enters
   // the render view. This is the callback that is used to give us the data
@@ skipping 40 matching lines @@
         drop_data_->text_html = UTF8ToUTF16(std::string(
             reinterpret_cast<char*>(data->data), data->length));
         // We leave the base URL empty.
       }
     }
 
     if (data_requests_ == 0) {
       // Tell the renderer about the drag.
       // |x| and |y| are seemingly arbitrary at this point.
       tab_contents_->render_view_host()->
-          DragTargetDragEnter(*drop_data_.get(), ClientPoint(), ScreenPoint());
+          DragTargetDragEnter(*drop_data_.get(),
+                              ClientPoint(widget_), ScreenPoint(widget_));
       drag_over_time_ = time;
     }
   }
 
   // The drag has left our widget; forward this information to the renderer.
   void OnDragLeave(GdkDragContext* context, guint time) {
     // Set |context_| to NULL to make sure we will recognize the next DragMotion
     // as an enter.
     context_ = NULL;
     drop_data_.reset();
     // When GTK sends us a drag-drop signal, it is shortly (and synchronously)
     // preceded by a drag-leave. The renderer doesn't like getting the signals
     // in this order so delay telling it about the drag-leave till we are sure
     // we are not getting a drop as well.
     MessageLoop::current()->PostTask(FROM_HERE,
         method_factory_.NewRunnableMethod(&WebDragDest::DragLeave));
   }
 
   // Called by GTK when the user releases the mouse, executing a drop.
   gboolean OnDragDrop(GdkDragContext* context, gint x, gint y, guint time) {
     // Cancel that drag leave!
     method_factory_.RevokeAll();
 
     tab_contents_->render_view_host()->
-        DragTargetDrop(ClientPoint(), ScreenPoint());
+        DragTargetDrop(ClientPoint(widget_), ScreenPoint(widget_));
 
     // The second parameter is just an educated guess, but at least we will
     // get the drag-end animation right sometimes.
     gtk_drag_finish(context, is_drop_target_, FALSE, time);
     return TRUE;
   }
 
-  // Get the current location of the mouse cursor, relative to the screen.
-  gfx::Point ScreenPoint() {
-    int x, y;
-    gdk_display_get_pointer(gtk_widget_get_display(widget_), NULL, &x, &y,
-                            NULL);
-    return gfx::Point(x, y);
-  }
-
-  // Get the current location of the mouse cursor, relative to the render view.
-  gfx::Point ClientPoint() {
-    int x, y;
-    gtk_widget_get_pointer(widget_, &x, &y);
-    return gfx::Point(x, y);
-  }
 
   TabContents* tab_contents_;
   // The render view.
   GtkWidget* widget_;
   // The current drag context for system drags over our render view, or NULL if
   // there is no system drag or the system drag is not over our render view.
   GdkDragContext* context_;
   // The data for the current drag, or NULL if |context_| is NULL.
   scoped_ptr<WebDropData> drop_data_;
 
@@ skipping 20 matching lines @@
 
 // static
 TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
   return new TabContentsViewGtk(tab_contents);
 }
 
 TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents)
     : TabContentsView(tab_contents),
       floating_(gtk_floating_container_new()),
       fixed_(gtk_fixed_new()),
-      popup_view_(NULL) {
+      popup_view_(NULL),
+      drag_failed_(false),
+      drag_widget_(NULL) {
   g_signal_connect(fixed_, "size-allocate",
                    G_CALLBACK(OnSizeAllocate), this);
   g_signal_connect(floating_.get(), "set-floating-position",
                    G_CALLBACK(OnSetFloatingPosition), this);
 
   gtk_container_add(GTK_CONTAINER(floating_.get()), fixed_);
   gtk_widget_show(fixed_);
   gtk_widget_show(floating_.get());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  Source<TabContents>(tab_contents));
+
+  // Renderer source DnD.
+  drag_widget_ = gtk_invisible_new();
+  g_signal_connect(drag_widget_, "drag-failed",
+                   G_CALLBACK(OnDragFailedThunk), this);
+  g_signal_connect(drag_widget_, "drag-end", G_CALLBACK(OnDragEndThunk), this);
+  g_signal_connect(drag_widget_, "drag-data-get",
+                   G_CALLBACK(OnDragDataGetThunk), this);
+  g_object_ref_sink(drag_widget_);
 }
 
 TabContentsViewGtk::~TabContentsViewGtk() {
   floating_.Destroy();
 }
 
 void TabContentsViewGtk::AttachBlockedPopupView(
     BlockedPopupContainerViewGtk* popup_view) {
   DCHECK(popup_view_ == NULL);
   popup_view_ = popup_view;
@@ skipping 56 matching lines @@
   g_signal_connect(content_view, "leave-notify-event",
                    G_CALLBACK(OnLeaveNotify), tab_contents());
   g_signal_connect(content_view, "motion-notify-event",
                    G_CALLBACK(OnMouseMove), tab_contents());
   g_signal_connect(content_view, "scroll-event",
                    G_CALLBACK(OnMouseScroll), tab_contents());
   gtk_widget_add_events(content_view, GDK_LEAVE_NOTIFY_MASK |
                         GDK_POINTER_MOTION_MASK);
   g_signal_connect(content_view, "button-press-event",
                    G_CALLBACK(OnMouseDown), this);
+  InsertIntoContentArea(content_view);
 
-  // Renderer DnD.
-  g_signal_connect(content_view, "drag-end", G_CALLBACK(OnDragEnd), this);
-  g_signal_connect(content_view, "drag-data-get", G_CALLBACK(OnDragDataGet),
-                   this);
+  // Renderer target DnD.
   drag_dest_.reset(new WebDragDest(tab_contents(), content_view));
 
-  InsertIntoContentArea(content_view);
   return view;
 }
 
 gfx::NativeView TabContentsViewGtk::GetNativeView() const {
   return floating_.get();
 }
 
 gfx::NativeView TabContentsViewGtk::GetContentNativeView() const {
   if (!tab_contents()->render_widget_host_view())
     return NULL;
   return tab_contents()->render_widget_host_view()->GetNativeView();
 }
 
-
 gfx::NativeWindow TabContentsViewGtk::GetTopLevelNativeWindow() const {
   GtkWidget* window = gtk_widget_get_ancestor(GetNativeView(), GTK_TYPE_WINDOW);
   return window ? GTK_WINDOW(window) : NULL;
 }
 
 void TabContentsViewGtk::InitRendererPrefs(RendererPreferences* prefs) {
   GtkSettings* gtk_settings = gtk_settings_get_default();
 
   gint antialias = 0;
   gint hinting = 0;
@@ skipping 48 matching lines @@
   // animation.
   int x = 0;
   int y = 0;
   if (fixed_->window)
     gdk_window_get_origin(fixed_->window, &x, &y);
   out->SetRect(x + fixed_->allocation.x, y + fixed_->allocation.y,
                fixed_->allocation.width, fixed_->allocation.height);
 }
 
 void TabContentsViewGtk::OnContentsDestroy() {
-  // TODO(estade): Windows uses this for some sort of plugin-related stuff.
+  // We don't want to try to handle drag events from this point on.
+  g_signal_handlers_disconnect_by_func(drag_widget_,
+      reinterpret_cast<gpointer>(OnDragFailedThunk), this);
+  g_signal_handlers_disconnect_by_func(drag_widget_,
+      reinterpret_cast<gpointer>(OnDragEndThunk), this);
+  g_signal_handlers_disconnect_by_func(drag_widget_,
+      reinterpret_cast<gpointer>(OnDragDataGetThunk), this);
+
+  // Break the current drag, if any.
+  if (drop_data_.get()) {
+    gtk_grab_add(drag_widget_);
+    gtk_grab_remove(drag_widget_);
+    MessageLoopForUI::current()->RemoveObserver(this);
+    drop_data_.reset();
+  }
+
+  gtk_widget_destroy(drag_widget_);
+  g_object_unref(drag_widget_);
+  drag_widget_ = NULL;
 }
 
 void TabContentsViewGtk::SetPageTitle(const std::wstring& title) {
   // Set the window name to include the page title so it's easier to spot
   // when debugging (e.g. via xwininfo -tree).
   gfx::NativeView content_view = GetContentNativeView();
   if (content_view && content_view->window)
     gdk_window_set_title(content_view->window, WideToUTF8(title).c_str());
 }
 
@@ skipping 89 matching lines @@
       // vbox's children.
       sad_tab_.reset();
       break;
     }
     default:
       NOTREACHED() << "Got a notification we didn't register for.";
       break;
   }
 }
 
+void TabContentsViewGtk::WillProcessEvent(GdkEvent* event) {
+  // No-op.
+}
+
+void TabContentsViewGtk::DidProcessEvent(GdkEvent* event) {
+  if (event->type != GDK_MOTION_NOTIFY)
+    return;
+
+  GdkEventMotion* event_motion = reinterpret_cast<GdkEventMotion*>(event);
+  gfx::Point client = ClientPoint(GetContentNativeView());
+
+  if (tab_contents()->render_view_host()) {
+    tab_contents()->render_view_host()->DragSourceMovedTo(
+        client.x(), client.y(), event_motion->x_root, event_motion->y_root);
+  }
+}
+
 void TabContentsViewGtk::ShowContextMenu(const ContextMenuParams& params) {
   context_menu_.reset(new RenderViewContextMenuGtk(tab_contents(), params,
                                                    last_mouse_down_.time));
   context_menu_->Init();
   context_menu_->Popup();
 }
 
 // Render view DnD -------------------------------------------------------------
 
-void TabContentsViewGtk::DragEnded() {
-  if (tab_contents()->render_view_host())
-    tab_contents()->render_view_host()->DragSourceSystemDragEnded();
-}
-
 void TabContentsViewGtk::StartDragging(const WebDropData& drop_data) {
   DCHECK(GetContentNativeView());
 
   int targets_mask = 0;
 
   if (!drop_data.plain_text.empty())
     targets_mask |= GtkDndUtil::TEXT_PLAIN;
   if (drop_data.url.is_valid()) {
     targets_mask |= GtkDndUtil::TEXT_URI_LIST;
     targets_mask |= GtkDndUtil::CHROME_NAMED_URL;
   }
   if (!drop_data.text_html.empty())
     targets_mask |= GtkDndUtil::TEXT_HTML;
   if (!drop_data.file_contents.empty())
     targets_mask |= GtkDndUtil::CHROME_WEBDROP_FILE_CONTENTS;
 
   if (targets_mask == 0) {
     NOTIMPLEMENTED();
-    DragEnded();
-    return;
+    if (tab_contents()->render_view_host())
+      tab_contents()->render_view_host()->DragSourceSystemDragEnded();
   }
 
   drop_data_.reset(new WebDropData(drop_data));
 
   GtkTargetList* list = GtkDndUtil::GetTargetListFromCodeMask(targets_mask);
   if (targets_mask & GtkDndUtil::CHROME_WEBDROP_FILE_CONTENTS) {
     drag_file_mime_type_ = gdk_atom_intern(
         mime_util::GetDataMimeType(drop_data.file_contents).c_str(), FALSE);
     gtk_target_list_add(list, drag_file_mime_type_,
                         0, GtkDndUtil::CHROME_WEBDROP_FILE_CONTENTS);
   }
 
+  drag_failed_ = false;
   // If we don't pass an event, GDK won't know what event time to start grabbing
   // mouse events. Technically it's the mouse motion event and not the mouse
   // down event that causes the drag, but there's no reliable way to know
   // *which* motion event initiated the drag, so this will have to do.
   // TODO(estade): This can sometimes be very far off, e.g. if the user clicks
   // and holds and doesn't start dragging for a long time. I doubt it matters
   // much, but we should probably look into the possibility of getting the
   // initiating event from webkit.
-  gtk_drag_begin(GetContentNativeView(), list, GDK_ACTION_COPY,
+  gtk_drag_begin(drag_widget_, list, GDK_ACTION_COPY,
                  1,  // Drags are always initiated by the left button.
                  reinterpret_cast<GdkEvent*>(&last_mouse_down_));
+  MessageLoopForUI::current()->AddObserver(this);
   // The drag adds a ref; let it own the list.
   gtk_target_list_unref(list);
 }
 
-// static
 void TabContentsViewGtk::OnDragDataGet(
-    GtkWidget* drag_widget,
     GdkDragContext* context, GtkSelectionData* selection_data,
-    guint target_type, guint time, TabContentsViewGtk* view) {
+    guint target_type, guint time) {
   const int bits_per_byte = 8;
 
   switch (target_type) {
     case GtkDndUtil::TEXT_PLAIN: {
-      std::string utf8_text = UTF16ToUTF8(view->drop_data_->plain_text);
+      std::string utf8_text = UTF16ToUTF8(drop_data_->plain_text);
       gtk_selection_data_set_text(selection_data, utf8_text.c_str(),
                                   utf8_text.length());
       break;
     }
 
     case GtkDndUtil::TEXT_URI_LIST: {
       gchar* uri_array[2];
-      uri_array[0] = strdup(view->drop_data_->url.spec().c_str());
+      uri_array[0] = strdup(drop_data_->url.spec().c_str());
       uri_array[1] = NULL;
       gtk_selection_data_set_uris(selection_data, uri_array);
       free(uri_array[0]);
       break;
     }
 
     case GtkDndUtil::TEXT_HTML: {
       // TODO(estade): change relative links to be absolute using
       // |html_base_url|.
-      std::string utf8_text = UTF16ToUTF8(view->drop_data_->text_html);
+      std::string utf8_text = UTF16ToUTF8(drop_data_->text_html);
       gtk_selection_data_set(selection_data,
           GtkDndUtil::GetAtomForTarget(GtkDndUtil::TEXT_HTML),
           bits_per_byte,
           reinterpret_cast<const guchar*>(utf8_text.c_str()),
           utf8_text.length());
       break;
     }
 
     case GtkDndUtil::CHROME_NAMED_URL: {
       Pickle pickle;
-      pickle.WriteString(UTF16ToUTF8(view->drop_data_->url_title));
-      pickle.WriteString(view->drop_data_->url.spec());
+      pickle.WriteString(UTF16ToUTF8(drop_data_->url_title));
+      pickle.WriteString(drop_data_->url.spec());
       gtk_selection_data_set(selection_data,
           GtkDndUtil::GetAtomForTarget(GtkDndUtil::CHROME_NAMED_URL),
           bits_per_byte,
           reinterpret_cast<const guchar*>(pickle.data()),
           pickle.size());
       break;
     }
 
     case GtkDndUtil::CHROME_WEBDROP_FILE_CONTENTS: {
       gtk_selection_data_set(selection_data,
-          view->drag_file_mime_type_, bits_per_byte,
-          reinterpret_cast<const guchar*>(
-              view->drop_data_->file_contents.data()),
-          view->drop_data_->file_contents.length());
+          drag_file_mime_type_, bits_per_byte,
+          reinterpret_cast<const guchar*>(drop_data_->file_contents.data()),
+          drop_data_->file_contents.length());
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
-// static
-void TabContentsViewGtk::OnDragEnd(GtkWidget* widget,
-     GdkDragContext* drag_context, TabContentsViewGtk* view) {
-  view->DragEnded();
-  view->drop_data_.reset();
+gboolean TabContentsViewGtk::OnDragFailed() {
+  drag_failed_ = true;
+
+  gfx::Point root = ScreenPoint(GetContentNativeView());
+  gfx::Point client = ClientPoint(GetContentNativeView());
+
+  if (tab_contents()->render_view_host()) {
+    tab_contents()->render_view_host()->DragSourceCancelledAt(
+        client.x(), client.y(), root.x(), root.y());
+  }
+
+  // Let the native failure animation run.
+  return FALSE;
+}
+
+void TabContentsViewGtk::OnDragEnd() {
+  MessageLoopForUI::current()->RemoveObserver(this);
+
+  if (!drag_failed_) {
+    gfx::Point root = ScreenPoint(GetContentNativeView());
+    gfx::Point client = ClientPoint(GetContentNativeView());
+
+    if (tab_contents()->render_view_host()) {
+      tab_contents()->render_view_host()->DragSourceEndedAt(
+          client.x(), client.y(), root.x(), root.y());
+    }
+  }
+
+  if (tab_contents()->render_view_host())
+      tab_contents()->render_view_host()->DragSourceSystemDragEnded();
+
+  drop_data_.reset();
 }
 
 // -----------------------------------------------------------------------------
 
 void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
   gtk_fixed_put(GTK_FIXED(fixed_), widget, 0, 0);
 }
 
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
     GdkEventButton* event, TabContentsViewGtk* view) {
@@ skipping 67 matching lines @@
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "x", &value);
 
     int child_y = std::max(half_view_height - (requisition.height / 2), 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 }