Make GTK Panels ignore mouse/keyboard events after drag is ended until mouse is released.

chrome/browser/ui/panels/panel_drag_gtk.cc

 // Copyright (c) 2012 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/panels/panel_drag_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_constants.h"
@@ skipping 115 matching lines @@
   g_signal_connect(drag_widget_, "button-press-event",
                    G_CALLBACK(OnButtonPressEventThunk), this);
   g_signal_connect(drag_widget_, "button-release-event",
                    G_CALLBACK(OnButtonReleaseEventThunk), this);
   g_signal_connect(drag_widget_, "grab-broken-event",
                    G_CALLBACK(OnGrabBrokenEventThunk), this);
 }
 
 PanelDragGtk::~PanelDragGtk() {
   EndDrag(true);  // Clean up drag state.
+  ReleasePointerAndKeyboardGrab();
 }
 
 void PanelDragGtk::AssertCleanState() {
   DCHECK_EQ(NOT_DRAGGING, drag_state_);
   DCHECK(!drag_delegate_);
   DCHECK(!initial_mouse_down_);
   DCHECK(!click_handler_);
 }
 
 void PanelDragGtk::InitialWindowEdgeMousePress(GdkEventButton* event,
@@ skipping 40 matching lines @@
     DLOG(ERROR) << "Unable to grab pointer or keyboard (pointer_status="
                 << pointer_grab_status << ", keyboard_status="
                 << keyboard_grab_status << ")";
     EndDrag(true);
     return;
   }
 
   gtk_grab_add(drag_widget_);
 }
 
+void PanelDragGtk::ReleasePointerAndKeyboardGrab() {

[Dmitry Titov, 2012/04/27 22:28:32]

This function can be called twice it seems. If we can guard against calling
gdk/gtk stuff unnecessary, it'd probably be better. In previous version, it was
guarded.

[jennb, 2012/04/27 22:52:06]

Done.

+  DCHECK_NE(DRAG_IN_PROGRESS, drag_state_);
+  gdk_pointer_ungrab(GDK_CURRENT_TIME);
+  gdk_keyboard_ungrab(GDK_CURRENT_TIME);
+  gtk_grab_remove(drag_widget_);
+  drag_state_ = NOT_DRAGGING;  // Drag is truly over now.
+}
+
 void PanelDragGtk::EndDrag(bool canceled) {
   if (initial_mouse_down_) {
     gdk_event_free(initial_mouse_down_);
     initial_mouse_down_ = NULL;
   }
 
   if (drag_delegate_) {
-    gdk_pointer_ungrab(GDK_CURRENT_TIME);
-    gdk_keyboard_ungrab(GDK_CURRENT_TIME);
-    gtk_grab_remove(drag_widget_);
-
     if (drag_state_ == DRAG_IN_PROGRESS) {
       drag_delegate_->DragEnded(canceled);
-      drag_state_ = NOT_DRAGGING;
+      drag_state_ = DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE;
     }
 
     delete drag_delegate_;
     drag_delegate_ = NULL;
   }
 
   click_handler_ = NULL;
 }
 
 gboolean PanelDragGtk::OnMouseMoveEvent(GtkWidget* widget,
                                         GdkEventMotion* event) {
-  DCHECK(drag_delegate_);
+  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
+  if (!drag_delegate_)
+    return TRUE;
 
   gdouble new_x_double;
   gdouble new_y_double;
   gdk_event_get_root_coords(reinterpret_cast<GdkEvent*>(event),
                             &new_x_double, &new_y_double);
   gint new_x = static_cast<gint>(new_x_double);
   gint new_y = static_cast<gint>(new_y_double);
 
   // Begin dragging only after mouse has moved beyond the drag threshold.
   if (drag_state_ == NOT_DRAGGING) {
@@ skipping 15 matching lines @@
   }
 
   if (drag_state_ == DRAG_IN_PROGRESS)
     drag_delegate_->Dragged(gfx::Point(new_x, new_y));
 
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnButtonPressEvent(GtkWidget* widget,
                                           GdkEventButton* event) {
-  DCHECK(drag_delegate_);
+  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnButtonReleaseEvent(GtkWidget* widget,
                                             GdkEventButton* event) {
-  DCHECK(drag_delegate_);
-
+  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
   if (event->button == 1) {
-    // Treat release as a mouse click if drag was never started.
-    if (drag_state_ == NOT_DRAGGING && click_handler_) {
-      gtk_propagate_event(click_handler_,
-                          reinterpret_cast<GdkEvent*>(event));
+    // There will be no drag delegate if drag was canceled/ended using
+    // the keyboard before the mouse was released.
+    if (drag_delegate_) {
+      // Treat release as a mouse click if drag was never started.
+      if (drag_state_ == NOT_DRAGGING && click_handler_) {
+        gtk_propagate_event(click_handler_,
+                            reinterpret_cast<GdkEvent*>(event));
+      }
+      //  Cleanup state regardless.
+      EndDrag(false);
+    } else {
+      DCHECK_EQ(DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE, drag_state_);
     }
-    // Cleanup state regardless.
-    EndDrag(false);
+    ReleasePointerAndKeyboardGrab();
   }
 
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnKeyPressEvent(GtkWidget* widget,
                                        GdkEventKey* event) {
-  DCHECK(drag_delegate_);
+  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnKeyReleaseEvent(GtkWidget* widget,
                                          GdkEventKey* event) {
-  DCHECK(drag_delegate_);
+  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
+  if (!drag_delegate_)
+    return TRUE;
 
   switch (event->keyval) {
   case GDK_Escape:
     EndDrag(true);  // Cancel drag.
     break;
   case GDK_Return:
   case GDK_KP_Enter:
   case GDK_ISO_Enter:
   case GDK_space:
     EndDrag(false);  // Normal end.
     break;
   }
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnGrabBrokenEvent(GtkWidget* widget,
                                          GdkEventGrabBroken* event) {
-  DCHECK(drag_delegate_);
+  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
   EndDrag(true);  // Cancel drag.
+  ReleasePointerAndKeyboardGrab();
   return TRUE;
 }