Consolidate Widget Event code, other cleanup.

views/widget/widget_gtk.cc

 // Copyright (c) 2011 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 "views/widget/widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 
@@ skipping 247 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, public:
 
 WidgetGtk::WidgetGtk(Type type)
     : is_window_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
       type_(type),
       widget_(NULL),
       window_contents_(NULL),
-      is_mouse_down_(false),
-      last_mouse_event_was_move_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       delete_on_destroy_(true),
       transparent_(false),
       ignore_events_(false),
       ignore_drag_leave_(false),
       opacity_(255),
       drag_data_(NULL),
       is_active_(false),
       transient_to_parent_(false),
       got_initial_focus_in_(false),
@@ skipping 401 matching lines @@
     // Trigger VKEY_MENU when only this key is pressed and released, and both
     // press and release events are not handled by others.
     Accelerator accelerator(ui::VKEY_MENU, false, false, false);
     handled = GetFocusManager()->ProcessAccelerator(accelerator);
   }
 
   return handled;
 }
 
 // static
-int WidgetGtk::GetFlagsForEventButton(const GdkEventButton& event) {
-  int flags = Event::GetFlagsFromGdkState(event.state);
-  switch (event.button) {
-    case 1:
-      flags |= ui::EF_LEFT_BUTTON_DOWN;
-      break;
-    case 2:
-      flags |= ui::EF_MIDDLE_BUTTON_DOWN;
-      break;
-    case 3:
-      flags |= ui::EF_RIGHT_BUTTON_DOWN;
-      break;
-    default:
-      // We only deal with 1-3.
-      break;
-  }
-  if (event.type == GDK_2BUTTON_PRESS)
-    flags |= ui::EF_IS_DOUBLE_CLICK;
-  return flags;
-}
-
-// static
 void WidgetGtk::EnableDebugPaint() {
   debug_paint_enabled_ = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, NativeWidget implementation:
 
 Widget* WidgetGtk::GetWidget() {
   return this;
 }
 
 void WidgetGtk::SetNativeWindowProperty(const char* name, void* value) {
   g_object_set_data(G_OBJECT(widget_), name, value);
 }
 
 void* WidgetGtk::GetNativeWindowProperty(const char* name) {
   return g_object_get_data(G_OBJECT(widget_), name);
 }
 
 TooltipManager* WidgetGtk::GetTooltipManager() const {
   return tooltip_manager_.get();
 }
 
 bool WidgetGtk::IsScreenReaderActive() const {
   return false;
 }
 
-void WidgetGtk::SetNativeCapture() {
-  DCHECK(!HasNativeCapture());
+void WidgetGtk::SetMouseCapture() {
+  DCHECK(!HasMouseCapture());
   gtk_grab_add(window_contents_);
 }
 
-void WidgetGtk::ReleaseNativeCapture() {
-  if (HasNativeCapture())
+void WidgetGtk::ReleaseMouseCapture() {
+  if (HasMouseCapture())
     gtk_grab_remove(window_contents_);
 }
 
-bool WidgetGtk::HasNativeCapture() const {
+bool WidgetGtk::HasMouseCapture() const {
   // TODO(beng): Should be able to use gtk_widget_has_grab() here but the
   //             trybots don't have Gtk 2.18.
   return GTK_WIDGET_HAS_GRAB(window_contents_);
 }
 
+bool WidgetGtk::ShouldReleaseCaptureOnMouseReleased() const {
+  return true;
+}
+
 gfx::Rect WidgetGtk::GetWindowScreenBounds() const {
   // Client == Window bounds on Gtk.
   return GetClientAreaScreenBounds();
 }
 
 gfx::Rect WidgetGtk::GetClientAreaScreenBounds() const {
   // Due to timing we can get a request for bounds after Close().
   // TODO(beng): Figure out if this is bogus.
   if (!widget_)
     return gfx::Rect(size_);
@@ skipping 286 matching lines @@
                                  GdkDragContext* context,
                                  gint x,
                                  gint y,
                                  guint time) {
   if (!drop_target_.get())
     drop_target_.reset(new DropTargetGtk(GetRootView(), context));
   return drop_target_->OnDragMotion(context, x, y, time);
 }
 
 gboolean WidgetGtk::OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
-  if (last_mouse_event_was_move_ && last_mouse_move_x_ == event->x_root &&
-      last_mouse_move_y_ == event->y_root) {
-    // Don't generate a mouse event for the same location as the last.
-    return false;
-  }
-
-  if (HasNativeCapture() && event->mode == GDK_CROSSING_GRAB) {
+  if (HasMouseCapture() && event->mode == GDK_CROSSING_GRAB) {
     // Doing a grab results an async enter event, regardless of where the mouse
     // is. We don't want to generate a mouse move in this case.
     return false;
   }
 
   if (!last_mouse_event_was_move_ && !is_mouse_down_) {
     // When a mouse button is pressed gtk generates a leave, enter, press.
     // RootView expects to get a mouse move before a press, otherwise enter is
     // not set. So we generate a move here.
-    last_mouse_move_x_ = event->x_root;
-    last_mouse_move_y_ = event->y_root;
-    last_mouse_event_was_move_ = true;
-
     int x = 0, y = 0;
     GetContainedWidgetEventCoordinates(event, &x, &y);
+    int flags = Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event));
 
     // If this event is the result of pressing a button then one of the button
     // modifiers is set. Unset it as we're compensating for the leave generated
     // when you press a button.
-    int flags = (Event::GetFlagsFromGdkState(event->state) &
-                 ~(ui::EF_LEFT_BUTTON_DOWN |
-                   ui::EF_MIDDLE_BUTTON_DOWN |
-                   ui::EF_RIGHT_BUTTON_DOWN));
+    flags &= ~(ui::EF_LEFT_BUTTON_DOWN |
+               ui::EF_MIDDLE_BUTTON_DOWN |
+               ui::EF_RIGHT_BUTTON_DOWN);
+
     MouseEvent mouse_move(ui::ET_MOUSE_MOVED, x, y, flags);
-    GetRootView()->OnMouseMoved(mouse_move);
+    ProcessMouseMoved(mouse_move);
   }
 
   return false;
 }
 
 gboolean WidgetGtk::OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event) {
   last_mouse_event_was_move_ = false;
-  if (!HasNativeCapture() && !is_mouse_down_) {
+  if (!HasMouseCapture() && !is_mouse_down_) {
     MouseEvent mouse_event(reinterpret_cast<GdkEvent*>(event));
     GetRootView()->OnMouseExited(mouse_event);
   }
   return false;
 }
 
 gboolean WidgetGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
   int x = 0, y = 0;
   GetContainedWidgetEventCoordinates(event, &x, &y);
-
-  if (HasNativeCapture() && is_mouse_down_) {
-    last_mouse_event_was_move_ = false;
-    int flags = Event::GetFlagsFromGdkState(event->state);
-    MouseEvent mouse_drag(ui::ET_MOUSE_DRAGGED, x, y, flags);
-    GetRootView()->OnMouseDragged(mouse_drag);
-    return true;
-  }
-  gfx::Point screen_loc(event->x_root, event->y_root);
-  if (last_mouse_event_was_move_ && last_mouse_move_x_ == screen_loc.x() &&
-      last_mouse_move_y_ == screen_loc.y()) {
-    // Don't generate a mouse event for the same location as the last.
-    return true;
-  }
-  last_mouse_move_x_ = screen_loc.x();
-  last_mouse_move_y_ = screen_loc.y();
-  last_mouse_event_was_move_ = true;
-  int flags = Event::GetFlagsFromGdkState(event->state);
-  MouseEvent mouse_move(ui::ET_MOUSE_MOVED, x, y, flags);
-  GetRootView()->OnMouseMoved(mouse_move);
+  int flags = Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event));
+  MouseEvent mouse_event((HasMouseCapture() && is_mouse_down_) ?
+      ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED, x, y, flags);
+  ProcessMouseMoved(mouse_event);

[Ben Goodger (Google), 2011/03/30 23:22:55]

Now that you've renamed this method and moved it to NativeWidgetDelegate, this
call becomes:

delegate_->OnMouseMoved(mouse_event);

Also I assume in a future pass you're going to replace the event construction
like so:

delegate_->OnMouseMoved(MouseEvent(event));

?

[msw, 2011/03/31 14:01:18]

Done; I'll investigate and document our coordinate systems and translations
soon. At first glance, I'll need to mutate a GdkEvent argument in this widget's
context to support GetContainedWidgetEventCoordinates.

   return true;
 }
 
 gboolean WidgetGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
-  return ProcessMousePressed(event);
+  if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) {
+    // The sequence for double clicks is press, release, press, 2press, release.
+    // This means that at the time we get the second 'press' we don't know
+    // whether it corresponds to a double click or not. For now we're completely
+    // ignoring the 2press/3press events as they are duplicate. To make this
+    // work right we need to write our own code that detects if the press is a
+    // double/triple. For now we're completely punting, which means we always
+    // get single clicks.
+    // TODO: fix this.
+    return true;
+  }
+
+  // An event may come from a contained widget which has its own gdk window.
+  // Translate it to the widget's coordinates.
+  int x = 0, y = 0;
+  GetContainedWidgetEventCoordinates(event, &x, &y);
+  int flags = Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event));
+  MouseEvent mouse_pressed(ui::ET_MOUSE_PRESSED, x, y, flags);
+
+  // Returns true to consume the event when widget is not transparent.
+  return ProcessMousePressed(mouse_pressed) || !transparent_;
 }
 
 gboolean WidgetGtk::OnButtonRelease(GtkWidget* widget, GdkEventButton* event) {
-  ProcessMouseReleased(event);
+  // GTK generates a mouse release at the end of dnd. We need to ignore it.
+  if (drag_data_)
+    return true;
+
+  // An event may come from a contained widget which has its own gdk window.
+  // Translate it to the widget's coordinates.
+  int x = 0, y = 0;
+  GetContainedWidgetEventCoordinates(event, &x, &y);
+  int flags = Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event));
+  MouseEvent mouse_up(ui::ET_MOUSE_RELEASED, x, y, flags);
+  ProcessMouseReleased(mouse_up);
   return true;
 }
 
 gboolean WidgetGtk::OnScroll(GtkWidget* widget, GdkEventScroll* event) {
-  return ProcessScroll(event);
+  // An event may come from a contained widget which has its own gdk window.
+  // Translate it to the widget's coordinates.
+  int x = 0, y = 0;
+  GetContainedWidgetEventCoordinates(event, &x, &y);
+  GdkEventScroll translated_event = *event;
+  translated_event.x = x;
+  translated_event.y = y;
+
+  MouseWheelEvent wheel_event(reinterpret_cast<GdkEvent*>(&translated_event));
+  return GetRootView()->OnMouseWheel(wheel_event);
 }
 
 gboolean WidgetGtk::OnFocusIn(GtkWidget* widget, GdkEventFocus* event) {
   if (has_focus_)
     return false;  // This is the second focus-in event in a row, ignore it.
   has_focus_ = true;
 
   should_handle_menu_key_release_ = false;
 
   if (type_ == TYPE_CHILD)
@@ skipping 108 matching lines @@
   // SchedulePaintInRect calls for the widget will have happened before the
   // widget was drawable. This means that gtk_widget_queue_draw_area wasn't
   // called, and so the widget will not get any expose events. Consequently, the
   // widget won't paint itself until something else triggers a paint call.
   gdk_window_process_updates(widget_->window, true);
 }
 
 void WidgetGtk::OnHide(GtkWidget* widget) {
 }
 
-bool WidgetGtk::ReleaseCaptureOnMouseReleased() {
-  return true;
-}
-
 void WidgetGtk::HandleXGrabBroke() {
 }
 
 void WidgetGtk::HandleGtkGrabBroke() {
-  if (is_mouse_down_)
-    GetRootView()->OnMouseCaptureLost();
-  is_mouse_down_ = false;
+  ProcessMouseCaptureLost();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, private:
 
 RootView* WidgetGtk::CreateRootView() {
   return new RootView(this);
 }
 
 gfx::AcceleratedWidget WidgetGtk::GetAcceleratedWidget() {
   DCHECK(window_contents_ && window_contents_->window);
   return GDK_WINDOW_XID(window_contents_->window);
 }
 
 gboolean WidgetGtk::OnWindowPaint(GtkWidget* widget, GdkEventExpose* event) {
   // Clear the background to be totally transparent. We don't need to
   // paint the root view here as that is done by OnPaint.
   DCHECK(transparent_);
   DrawTransparentBackground(widget, event);
   return false;
 }
 
-bool WidgetGtk::ProcessMousePressed(GdkEventButton* event) {
-  if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) {
-    // The sequence for double clicks is press, release, press, 2press, release.
-    // This means that at the time we get the second 'press' we don't know
-    // whether it corresponds to a double click or not. For now we're completely
-    // ignoring the 2press/3press events as they are duplicate. To make this
-    // work right we need to write our own code that detects if the press is a
-    // double/triple. For now we're completely punting, which means we always
-    // get single clicks.
-    // TODO: fix this.
-    return true;
-  }
-
-  // An event may come from a contained widget which has its own gdk window.
-  // Translate it to the widget's coordinates.
-  int x = 0;
-  int y = 0;
-  GetContainedWidgetEventCoordinates(event, &x, &y);
-  last_mouse_event_was_move_ = false;
-  MouseEvent mouse_pressed(ui::ET_MOUSE_PRESSED, x, y,
-                           GetFlagsForEventButton(*event));
-
-  if (GetRootView()->OnMousePressed(mouse_pressed)) {
-    is_mouse_down_ = true;
-    if (!HasNativeCapture())
-      SetNativeCapture();
-    return true;
-  }
-
-  // Returns true to consume the event when widget is not transparent.
-  return !transparent_;
-}
-
-void WidgetGtk::ProcessMouseReleased(GdkEventButton* event) {
-  int x = 0, y = 0;
-  GetContainedWidgetEventCoordinates(event, &x, &y);
-
-  last_mouse_event_was_move_ = false;
-  MouseEvent mouse_up(ui::ET_MOUSE_RELEASED, x, y,
-                      GetFlagsForEventButton(*event));
-  // Release the capture first, that way we don't get confused if
-  // OnMouseReleased blocks.
-  if (HasNativeCapture() && ReleaseCaptureOnMouseReleased())
-    ReleaseNativeCapture();
-  is_mouse_down_ = false;
-  // GTK generates a mouse release at the end of dnd. We need to ignore it.
-  if (!drag_data_)
-    GetRootView()->OnMouseReleased(mouse_up);
-}
-
-bool WidgetGtk::ProcessScroll(GdkEventScroll* event) {
-  // An event may come from a contained widget which has its own gdk window.
-  // Translate it to the widget's coordinates.
-  int x = 0, y = 0;
-  GetContainedWidgetEventCoordinates(event, &x, &y);
-  GdkEventScroll translated_event = *event;
-  translated_event.x = x;
-  translated_event.y = y;
-
-  MouseWheelEvent wheel_event(reinterpret_cast<GdkEvent*>(&translated_event));
-  return GetRootView()->OnMouseWheel(wheel_event);
-}
-
 // static
 Window* WidgetGtk::GetWindowImpl(GtkWidget* widget) {
   GtkWidget* parent = widget;
   while (parent) {
     WidgetGtk* widget_gtk = static_cast<WidgetGtk*>(
         NativeWidget::GetNativeWidgetForNativeView(parent));
     if (widget_gtk && widget_gtk->is_window_)
       return static_cast<WindowGtk*>(widget_gtk);
     parent = gtk_widget_get_parent(parent);
   }
@@ skipping 255 matching lines @@
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   gtk_container_foreach(GTK_CONTAINER(native_view),
                         EnumerateChildWidgetsForNativeWidgets,
                         reinterpret_cast<gpointer>(children));
 }
 
 }  // namespace views