Implement DraggedTabGtk, the object that handles rendering either a dragged t...

chrome/browser/gtk/tabs/tab_gtk.cc

 // Copyright (c) 2006-2008 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/tabs/tab_gtk.h"
 
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "chrome/browser/gtk/custom_button.h"
@@ skipping 82 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ContextMenuController);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabGtk, public:
 
 TabGtk::TabGtk(TabDelegate* delegate)
     : TabRendererGtk(),
       delegate_(delegate),
-      closing_(false) {
+      closing_(false),
+      dragging_(false) {
   event_box_.Own(gtk_event_box_new());
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), FALSE);
   gtk_drag_source_set(event_box_.get(), GDK_BUTTON1_MASK,
                       target_table, G_N_ELEMENTS(target_table),
                       GDK_ACTION_MOVE);
-  gtk_drag_dest_set(event_box_.get(), GTK_DEST_DEFAULT_DROP,
-                    target_table, G_N_ELEMENTS(target_table),
-                    GDK_ACTION_MOVE);
-  gtk_drag_dest_set_track_motion(event_box_.get(), true);
   g_signal_connect(G_OBJECT(event_box_.get()), "button-press-event",
                    G_CALLBACK(OnMousePress), this);
   g_signal_connect(G_OBJECT(event_box_.get()), "button-release-event",
                    G_CALLBACK(OnMouseRelease), this);
   g_signal_connect(G_OBJECT(event_box_.get()), "enter-notify-event",
                    G_CALLBACK(OnEnterNotify), this);
   g_signal_connect(G_OBJECT(event_box_.get()), "leave-notify-event",
                    G_CALLBACK(OnLeaveNotify), this);
   g_signal_connect_after(G_OBJECT(event_box_.get()), "drag-begin",
-                           G_CALLBACK(&OnDragBegin), this);
+                           G_CALLBACK(OnDragBegin), this);
   g_signal_connect_after(G_OBJECT(event_box_.get()), "drag-end",
-                         G_CALLBACK(&OnDragEnd), this);
+                         G_CALLBACK(OnDragEnd), this);
   g_signal_connect_after(G_OBJECT(event_box_.get()), "drag-failed",
-                           G_CALLBACK(&OnDragFailed), this);
-  g_signal_connect_after(G_OBJECT(event_box_.get()), "drag-motion",
-                         G_CALLBACK(&OnDragMotion), this);
+                           G_CALLBACK(OnDragFailed), this);
   gtk_widget_add_events(event_box_.get(),
         GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
         GDK_LEAVE_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
   gtk_container_add(GTK_CONTAINER(event_box_.get()), TabRendererGtk::widget());
   gtk_widget_show_all(event_box_.get());
 
   close_button_.reset(MakeCloseButton());
 }
 
 TabGtk::~TabGtk() {
   if (menu_controller_.get()) {
     // The menu is showing. Close the menu.
     menu_controller_->Cancel();
 
     // Invoke this so that we hide the highlight.
     ContextMenuClosed();
   }
 
   event_box_.Destroy();
 }
 
 // static
+void TabGtk::GdkEventHandler(GdkEvent* event, void* data) {
+  TabGtk* tab = static_cast<TabGtk*>(data);
+
+  if (event->type == GDK_MOTION_NOTIFY && tab->dragging_) {
+    tab->delegate_->ContinueDrag(NULL);
+  }
+
+  gtk_main_do_event(event);
+}
+
+// static
 gboolean TabGtk::OnMousePress(GtkWidget* widget, GdkEventButton* event,
                               TabGtk* tab) {
   if (event->button == 1) {
     // Store whether or not we were selected just now... we only want to be
     // able to drag foreground tabs, so we don't start dragging the tab if
     // it was in the background.
     bool just_selected = !tab->IsSelected();
     if (just_selected) {
       tab->delegate_->SelectTab(tab);
     }
@@ skipping 24 matching lines @@
 // static
 gboolean TabGtk::OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event,
                                TabGtk* tab) {
   tab->OnMouseExited();
   return TRUE;
 }
 
 // static
 void TabGtk::OnDragBegin(GtkWidget* widget, GdkDragContext* context,
                          TabGtk* tab) {
+  gdk_event_handler_set(TabGtk::GdkEventHandler, tab, NULL);
+
   int x, y;
   gdk_window_get_pointer(tab->event_box_.get()->window, &x, &y, NULL);
+
+  // Make the mouse coordinate relative to the tab.
+  x -= tab->bounds().x();
+  y -= tab->bounds().y();
+
+  tab->dragging_ = true;
   tab->delegate_->MaybeStartDrag(tab, gfx::Point(x, y));
 }
 
 // static
 void TabGtk::OnDragEnd(GtkWidget* widget, GdkDragContext* context,
                        TabGtk* tab) {
+  tab->dragging_ = false;
   // Notify the drag helper that we're done with any potential drag operations.
   // Clean up the drag helper, which is re-created on the next mouse press.
   tab->delegate_->EndDrag(false);
 }
 
 // static
 gboolean TabGtk::OnDragMotion(GtkWidget* widget,
                               GdkDragContext* context,
                               guint x, guint y,
                               guint time,
                               TabGtk* tab) {
   tab->delegate_->ContinueDrag(context);
   return TRUE;
 }
 
 // static
 gboolean TabGtk::OnDragFailed(GtkWidget* widget, GdkDragContext* context,
                               GtkDragResult result,
                               TabGtk* tab) {
-  tab->delegate_->EndDrag(true);
+  tab->delegate_->EndDrag(false);
   return TRUE;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabGtk, TabRendererGtk overrides:
 
 bool TabGtk::IsSelected() const {
   return delegate_->IsTabSelected(this);
 }
 
+bool TabGtk::IsVisible() const {
+  return GTK_WIDGET_FLAGS(event_box_.get()) & GTK_VISIBLE;
+}
+
+void TabGtk::SetVisible(bool visible) const {
+  if (visible) {
+    gtk_widget_show(event_box_.get());
+  } else {
+    gtk_widget_hide(event_box_.get());
+  }
+}
+
 void TabGtk::CloseButtonResized(const gfx::Rect& bounds) {
   gtk_fixed_move(GTK_FIXED(TabRendererGtk::widget()),
       close_button_.get()->widget(), bounds.x(), bounds.y());
 }
 
 void TabGtk::Paint(GdkEventExpose* event) {
   TabRendererGtk::Paint(event);
 
   gtk_container_propagate_expose(GTK_CONTAINER(TabRendererGtk::widget()),
         close_button_.get()->widget(), event);
@@ skipping 24 matching lines @@
       IDR_TAB_CLOSE_P, IDR_TAB_CLOSE_H, IDR_TAB_CLOSE);
 
   g_signal_connect(G_OBJECT(button->widget()), "clicked",
                    G_CALLBACK(OnCloseButtonClicked), this);
   GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
   gtk_fixed_put(GTK_FIXED(TabRendererGtk::widget()), button->widget(), 0, 0);
   gtk_widget_show(button->widget());
 
   return button;
 }