chrome/browser/ui/gtk/panels/panel_drag_gtk.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/gtk/panels/panel_drag_gtk.h"
   6
   7 #include <gdk/gdkkeysyms.h>
   8
   9 #include "chrome/browser/ui/panels/panel.h"
  10 #include "chrome/browser/ui/panels/panel_constants.h"
  11 #include "chrome/browser/ui/panels/panel_manager.h"
  12 #include "ui/gfx/gtk_util.h"
  13
  14 namespace {
  15
  16 panel::ResizingSides GdkWindowEdgeToResizingSide(GdkWindowEdge edge) {
  17   switch (edge) {
  18   case GDK_WINDOW_EDGE_NORTH_WEST:
  19     return panel::RESIZE_TOP_LEFT;
  20   case GDK_WINDOW_EDGE_NORTH:
  21     return panel::RESIZE_TOP;
  22   case GDK_WINDOW_EDGE_NORTH_EAST:
  23     return panel::RESIZE_TOP_RIGHT;
  24   case GDK_WINDOW_EDGE_WEST:
  25     return panel::RESIZE_LEFT;
  26   case GDK_WINDOW_EDGE_EAST:
  27     return panel::RESIZE_RIGHT;
  28   case GDK_WINDOW_EDGE_SOUTH_WEST:
  29     return panel::RESIZE_BOTTOM_LEFT;
  30   case GDK_WINDOW_EDGE_SOUTH:
  31     return panel::RESIZE_BOTTOM;
  32   case GDK_WINDOW_EDGE_SOUTH_EAST:
  33     return panel::RESIZE_BOTTOM_RIGHT;
  34   default:
  35     return panel::RESIZE_NONE;
  36   }
  37 }
  38
  39 }  // namespace
  40
  41 // Virtual base class to abstract move vs resize drag logic.
  42 class PanelDragDelegate {
  43  public:
  44   explicit PanelDragDelegate(Panel* panel) : panel_(panel) {}
  45   virtual ~PanelDragDelegate() {}
  46
  47   Panel* panel() const { return panel_; }
  48   PanelManager* panel_manager() const { return panel_->manager(); }
  49
  50   // |point| is the mouse location in screen coordinates.
  51   virtual void DragStarted(gfx::Point point) = 0;
  52   virtual void Dragged(gfx::Point point) = 0;
  53
  54   // |canceled| is true to abort the drag.
  55   virtual void DragEnded(bool canceled) = 0;
  56
  57  private:
  58   Panel* panel_;  // Weak pointer to the panel being dragged.
  59
  60   DISALLOW_COPY_AND_ASSIGN(PanelDragDelegate);
  61 };
  62
  63 // Delegate for moving a panel by dragging the mouse.
  64 class MoveDragDelegate : public PanelDragDelegate {
  65  public:
  66   explicit MoveDragDelegate(Panel* panel)
  67       : PanelDragDelegate(panel) {}
  68   virtual ~MoveDragDelegate() {}
  69
  70   virtual void DragStarted(gfx::Point point) OVERRIDE {
  71     panel_manager()->StartDragging(panel(), point);
  72   }
  73   virtual void Dragged(gfx::Point point) OVERRIDE {
  74     panel_manager()->Drag(point);
  75   }
  76   virtual void DragEnded(bool canceled) OVERRIDE {
  77     panel_manager()->EndDragging(canceled);
  78   }
  79
  80   DISALLOW_COPY_AND_ASSIGN(MoveDragDelegate);
  81 };
  82
  83 // Delegate for resizing a panel by dragging the mouse.
  84 class ResizeDragDelegate : public PanelDragDelegate {
  85  public:
  86   ResizeDragDelegate(Panel* panel, GdkWindowEdge edge)
  87       : PanelDragDelegate(panel),
  88         resizing_side_(GdkWindowEdgeToResizingSide(edge)) {}
  89   virtual ~ResizeDragDelegate() {}
  90
  91   virtual void DragStarted(gfx::Point point) OVERRIDE {
  92     panel_manager()->StartResizingByMouse(panel(), point, resizing_side_);
  93   }
  94   virtual void Dragged(gfx::Point point) OVERRIDE {
  95     panel_manager()->ResizeByMouse(point);
  96   }
  97   virtual void DragEnded(bool canceled) OVERRIDE {
  98     panel_manager()->EndResizingByMouse(canceled);
  99   }
 100  private:
 101   // The edge from which the panel is being resized.
 102   panel::ResizingSides resizing_side_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(ResizeDragDelegate);
 105 };
 106
 107 // Panel drag helper for processing mouse and keyboard events while
 108 // the left mouse button is pressed.
 109 PanelDragGtk::PanelDragGtk(Panel* panel)
 110     : panel_(panel),
 111       drag_state_(NOT_DRAGGING),
 112       initial_mouse_down_(NULL),
 113       click_handler_(NULL),
 114       drag_delegate_(NULL) {
 115   // Create an invisible event box to receive mouse and key events.
 116   drag_widget_ = gtk_event_box_new();
 117   gtk_event_box_set_visible_window(GTK_EVENT_BOX(drag_widget_), FALSE);
 118
 119   // Connect signals for events during a drag.
 120   g_signal_connect(drag_widget_, "motion-notify-event",
 121                    G_CALLBACK(OnMouseMoveEventThunk), this);
 122   g_signal_connect(drag_widget_, "key-press-event",
 123                    G_CALLBACK(OnKeyPressEventThunk), this);
 124   g_signal_connect(drag_widget_, "key-release-event",
 125                    G_CALLBACK(OnKeyReleaseEventThunk), this);
 126   g_signal_connect(drag_widget_, "button-press-event",
 127                    G_CALLBACK(OnButtonPressEventThunk), this);
 128   g_signal_connect(drag_widget_, "button-release-event",
 129                    G_CALLBACK(OnButtonReleaseEventThunk), this);
 130   g_signal_connect(drag_widget_, "grab-broken-event",
 131                    G_CALLBACK(OnGrabBrokenEventThunk), this);
 132 }
 133
 134 PanelDragGtk::~PanelDragGtk() {
 135   EndDrag(true);  // Clean up drag state.
 136   ReleasePointerAndKeyboardGrab();
 137 }
 138
 139 void PanelDragGtk::AssertCleanState() {
 140   DCHECK_EQ(NOT_DRAGGING, drag_state_);
 141   DCHECK(!drag_delegate_);
 142   DCHECK(!initial_mouse_down_);
 143   DCHECK(!click_handler_);
 144 }
 145
 146 void PanelDragGtk::InitialWindowEdgeMousePress(GdkEventButton* event,
 147                                                GdkCursor* cursor,
 148                                                GdkWindowEdge& edge) {
 149   AssertCleanState();
 150   drag_delegate_ = new ResizeDragDelegate(panel_, edge);
 151   drag_state_ = DRAG_CAN_START;
 152   GrabPointerAndKeyboard(event, cursor);
 153 }
 154
 155 void PanelDragGtk::InitialTitlebarMousePress(GdkEventButton* event,
 156                                              GtkWidget* titlebar_widget) {
 157   AssertCleanState();
 158   click_handler_ = titlebar_widget;
 159   drag_delegate_ = new MoveDragDelegate(panel_);
 160   drag_state_ = DRAG_CAN_START;
 161   GrabPointerAndKeyboard(event, gfx::GetCursor(GDK_FLEUR));  // Drag cursor.
 162 }
 163
 164 void PanelDragGtk::GrabPointerAndKeyboard(GdkEventButton* event,
 165                                           GdkCursor* cursor) {
 166   // Remember initial mouse event for use in determining when drag
 167   // threshold has been exceeded.
 168   initial_mouse_down_ = gdk_event_copy(reinterpret_cast<GdkEvent*>(event));
 169
 170   // Grab pointer and keyboard to make sure we have the focus and get
 171   // all mouse and keyboard events during the drag.
 172   GdkWindow* gdk_window = gtk_widget_get_window(drag_widget_);
 173   DCHECK(gdk_window);
 174   GdkGrabStatus pointer_grab_status =
 175       gdk_pointer_grab(gdk_window,
 176                        TRUE,
 177                        GdkEventMask(GDK_BUTTON_PRESS_MASK |
 178                                     GDK_BUTTON_RELEASE_MASK |
 179                                     GDK_POINTER_MOTION_MASK),
 180                        NULL,
 181                        cursor,
 182                        event->time);
 183   GdkGrabStatus keyboard_grab_status =
 184       gdk_keyboard_grab(gdk_window, TRUE, event->time);
 185   if (pointer_grab_status != GDK_GRAB_SUCCESS ||
 186       keyboard_grab_status != GDK_GRAB_SUCCESS) {
 187     // Grab could fail if someone else already has the pointer/keyboard
 188     // grabbed. Cancel the drag.
 189     DLOG(ERROR) << "Unable to grab pointer or keyboard (pointer_status="
 190                 << pointer_grab_status << ", keyboard_status="
 191                 << keyboard_grab_status << ")";
 192     EndDrag(true);
 193     ReleasePointerAndKeyboardGrab();
 194     return;
 195   }
 196
 197   gtk_grab_add(drag_widget_);
 198 }
 199
 200 void PanelDragGtk::ReleasePointerAndKeyboardGrab() {
 201   DCHECK(!drag_delegate_);
 202   if (drag_state_ == NOT_DRAGGING)
 203     return;
 204
 205   DCHECK_EQ(DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE, drag_state_);
 206   gdk_pointer_ungrab(GDK_CURRENT_TIME);
 207   gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 208   gtk_grab_remove(drag_widget_);
 209   drag_state_ = NOT_DRAGGING;  // Drag is truly over now.
 210 }
 211
 212 void PanelDragGtk::EndDrag(bool canceled) {
 213   if (drag_state_ == NOT_DRAGGING ||
 214       drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE) {
 215     DCHECK(!drag_delegate_);
 216     return;
 217   }
 218
 219   DCHECK(drag_delegate_);
 220
 221   if (initial_mouse_down_) {
 222     gdk_event_free(initial_mouse_down_);
 223     initial_mouse_down_ = NULL;
 224   }
 225
 226   if (drag_state_ == DRAG_IN_PROGRESS) {
 227     drag_delegate_->DragEnded(canceled);
 228   }
 229   drag_state_ = DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE;
 230
 231   delete drag_delegate_;
 232   drag_delegate_ = NULL;
 233
 234   click_handler_ = NULL;
 235 }
 236
 237 gboolean PanelDragGtk::OnMouseMoveEvent(GtkWidget* widget,
 238                                         GdkEventMotion* event) {
 239   DCHECK(drag_state_ != NOT_DRAGGING);
 240
 241   if (drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE) {
 242     DCHECK(!drag_delegate_);
 243     return TRUE;
 244   }
 245
 246   DCHECK(drag_delegate_);
 247
 248   gdouble new_x_double;
 249   gdouble new_y_double;
 250   gdk_event_get_root_coords(reinterpret_cast<GdkEvent*>(event),
 251                             &new_x_double, &new_y_double);
 252   gint new_x = static_cast<gint>(new_x_double);
 253   gint new_y = static_cast<gint>(new_y_double);
 254
 255   // Begin dragging only after mouse has moved beyond the drag threshold.
 256   if (drag_state_ == DRAG_CAN_START) {
 257     DCHECK(initial_mouse_down_);
 258     gdouble old_x_double;
 259     gdouble old_y_double;
 260     gdk_event_get_root_coords(initial_mouse_down_,
 261                               &old_x_double, &old_y_double);
 262     gint old_x = static_cast<gint>(old_x_double);
 263     gint old_y = static_cast<gint>(old_y_double);
 264
 265     if (gtk_drag_check_threshold(drag_widget_, old_x, old_y,
 266                                  new_x, new_y)) {
 267       drag_state_ = DRAG_IN_PROGRESS;
 268       drag_delegate_->DragStarted(gfx::Point(old_x, old_y));
 269       gdk_event_free(initial_mouse_down_);
 270       initial_mouse_down_ = NULL;
 271     }
 272   }
 273
 274   if (drag_state_ == DRAG_IN_PROGRESS)
 275     drag_delegate_->Dragged(gfx::Point(new_x, new_y));
 276
 277   return TRUE;
 278 }
 279
 280 gboolean PanelDragGtk::OnButtonPressEvent(GtkWidget* widget,
 281                                           GdkEventButton* event) {
 282   DCHECK(drag_state_ != NOT_DRAGGING);
 283   return TRUE;
 284 }
 285
 286 gboolean PanelDragGtk::OnButtonReleaseEvent(GtkWidget* widget,
 287                                             GdkEventButton* event) {
 288   DCHECK(drag_state_ != NOT_DRAGGING);
 289
 290   if (event->button == 1) {
 291     // Treat release as a mouse click if drag was never started.
 292     if (drag_state_ == DRAG_CAN_START && click_handler_) {
 293       gtk_propagate_event(click_handler_,
 294                           reinterpret_cast<GdkEvent*>(event));
 295     }
 296     // Cleanup state regardless.
 297     EndDrag(false);
 298     ReleasePointerAndKeyboardGrab();
 299   }
 300
 301   return TRUE;
 302 }
 303
 304 gboolean PanelDragGtk::OnKeyPressEvent(GtkWidget* widget,
 305                                        GdkEventKey* event) {
 306   DCHECK(drag_state_ != NOT_DRAGGING);
 307   return TRUE;
 308 }
 309
 310 gboolean PanelDragGtk::OnKeyReleaseEvent(GtkWidget* widget,
 311                                          GdkEventKey* event) {
 312   DCHECK(drag_state_ != NOT_DRAGGING);
 313
 314   if (drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE) {
 315     DCHECK(!drag_delegate_);
 316     return TRUE;
 317   }
 318
 319   DCHECK(drag_delegate_);
 320
 321   switch (event->keyval) {
 322   case GDK_Escape:
 323     EndDrag(true);  // Cancel drag.
 324     break;
 325   case GDK_Return:
 326   case GDK_KP_Enter:
 327   case GDK_ISO_Enter:
 328   case GDK_space:
 329     EndDrag(false);  // Normal end.
 330     break;
 331   }
 332   return TRUE;
 333 }
 334
 335 gboolean PanelDragGtk::OnGrabBrokenEvent(GtkWidget* widget,
 336                                          GdkEventGrabBroken* event) {
 337   DCHECK(drag_state_ != NOT_DRAGGING);
 338   EndDrag(true);  // Cancel drag.
 339   ReleasePointerAndKeyboardGrab();
 340   return TRUE;
 341 }