Transform GdkEvents for simpler MouseEvent construction.

Handle MouseWheelEvent in Widget::OnMouseEvent.

BUG=72040
TEST=Mouse interaction on linux_views

Review URL: http://codereview.chromium.org/6720025

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@80420 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 52 insertions, 68 deletions

diff --git a/views/events/event_gtk.cc b/views/events/event_gtk.cc
index 7e2d1e0..aaa6723 100644
--- a/views/events/event_gtk.cc
+++ b/views/events/event_gtk.cc
@@ -16,6 +16,14 @@ namespace {
 ui::EventType EventTypeFromNative(NativeEvent native_event) {
   // Add new event types as necessary.
   switch (native_event->type) {
+    case GDK_2BUTTON_PRESS:
+    case GDK_3BUTTON_PRESS:
+    case GDK_BUTTON_PRESS:
+      return ui::ET_MOUSE_PRESSED;
+    case GDK_BUTTON_RELEASE:
+      return ui::ET_MOUSE_RELEASED;
+    case GDK_DRAG_MOTION:
+      return ui::ET_MOUSE_DRAGGED;
     case GDK_ENTER_NOTIFY:
       return ui::ET_MOUSE_ENTERED;
     case GDK_KEY_PRESS:
@@ -24,6 +32,15 @@ ui::EventType EventTypeFromNative(NativeEvent native_event) {
       return ui::ET_KEY_RELEASED;
     case GDK_LEAVE_NOTIFY:
       return ui::ET_MOUSE_EXITED;
+    case GDK_MOTION_NOTIFY:
+      if (native_event->motion.state & GDK_BUTTON1_MASK ||
+          native_event->motion.state & GDK_BUTTON2_MASK ||
+          native_event->motion.state & GDK_BUTTON3_MASK ||
+          native_event->motion.state & GDK_BUTTON4_MASK ||
+          native_event->motion.state & GDK_BUTTON5_MASK) {
+        return ui::ET_MOUSE_DRAGGED;
+      }
+      return ui::ET_MOUSE_MOVED;
     case GDK_SCROLL:
       return ui::ET_MOUSEWHEEL;
     default:
diff --git a/views/widget/widget.cc b/views/widget/widget.cc
index e707a2b..e8af806 100644
--- a/views/widget/widget.cc
+++ b/views/widget/widget.cc
@@ -353,6 +353,9 @@ bool Widget::OnMouseEvent(const MouseEvent& event) {
       last_mouse_event_was_move_ = false;
       GetRootView()->OnMouseExited(event);
       return false;
+    case ui::ET_MOUSEWHEEL:
+      return GetRootView()->OnMouseWheel(
+          reinterpret_cast<const MouseWheelEvent&>(event));
     default:
       return false;
   }
@@ -365,7 +368,6 @@ void Widget::OnMouseCaptureLost() {
   is_mouse_button_pressed_ = false;
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, FocusTraversable implementation:
 
diff --git a/views/widget/widget_gtk.cc b/views/widget/widget_gtk.cc
index 6253245..8807f10 100644
--- a/views/widget/widget_gtk.cc
+++ b/views/widget/widget_gtk.cc
@@ -1135,19 +1135,17 @@ gboolean WidgetGtk::OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
     // 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.
-    int x = 0, y = 0;
-    GetContainedWidgetEventCoordinates(event, &x, &y);
-    int flags = Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event));
+    GdkEventMotion motion = { GDK_MOTION_NOTIFY, event->window,
+        event->send_event, event->time, event->x, event->y, NULL, event->state,
+        0, NULL, event->x_root, event->y_root };
 
     // 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.
-    flags &= ~(ui::EF_LEFT_BUTTON_DOWN |
-               ui::EF_MIDDLE_BUTTON_DOWN |
-               ui::EF_RIGHT_BUTTON_DOWN);
+    motion.state &= ~(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK);
 
-    MouseEvent mouse_move(ui::ET_MOUSE_MOVED, x, y, flags);
-    delegate_->OnMouseEvent(mouse_move);
+    MouseEvent mouse_event(TransformEvent(&motion));
+    delegate_->OnMouseEvent(mouse_event);
   }
 
   return false;
@@ -1156,18 +1154,14 @@ gboolean WidgetGtk::OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
 gboolean WidgetGtk::OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event) {
   last_mouse_event_was_move_ = false;
   if (!HasMouseCapture() && !is_mouse_button_pressed_) {
-    MouseEvent mouse_event(reinterpret_cast<GdkEvent*>(event));
+    MouseEvent mouse_event(TransformEvent(event));
     delegate_->OnMouseEvent(mouse_event);
   }
   return false;
 }
 
 gboolean WidgetGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
-  int x = 0, y = 0;
-  GetContainedWidgetEventCoordinates(event, &x, &y);
-  int flags = Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event));
-  MouseEvent mouse_event((HasMouseCapture() && is_mouse_button_pressed_) ?
-      ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED, x, y, flags);
+  MouseEvent mouse_event(TransformEvent(event));
   delegate_->OnMouseEvent(mouse_event);
   return true;
 }
@@ -1185,43 +1179,23 @@ gboolean WidgetGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
     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);
-
+  MouseEvent mouse_event(TransformEvent(event));
   // Returns true to consume the event when widget is not transparent.
-  return delegate_->OnMouseEvent(mouse_pressed) || !transparent_;
+  return delegate_->OnMouseEvent(mouse_event) || !transparent_;
 }
 
 gboolean WidgetGtk::OnButtonRelease(GtkWidget* widget, GdkEventButton* 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);
-  delegate_->OnMouseEvent(mouse_up);
+  if (!drag_data_) {
+    MouseEvent mouse_event(TransformEvent(event));
+    delegate_->OnMouseEvent(mouse_event);
+  }
   return true;
 }
 
 gboolean WidgetGtk::OnScroll(GtkWidget* widget, 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);
+  MouseEvent mouse_event(TransformEvent(event));
+  return delegate_->OnMouseEvent(mouse_event);
 }
 
 gboolean WidgetGtk::OnFocusIn(GtkWidget* widget, GdkEventFocus* event) {
diff --git a/views/widget/widget_gtk.h b/views/widget/widget_gtk.h
index 33c00620..14eab68 100644
--- a/views/widget/widget_gtk.h
+++ b/views/widget/widget_gtk.h
@@ -221,24 +221,16 @@ class WidgetGtk : public Widget,
   virtual void SetCursor(gfx::NativeCursor cursor) OVERRIDE;
 
  protected:
-  // If widget contains another widget, translates event coordinates to the
-  // contained widget's coordinates, else returns original event coordinates.
-  template<class Event> bool GetContainedWidgetEventCoordinates(Event* event,
-                                                                int* x,
-                                                                int* y) {
-    if (event == NULL || x == NULL || y == NULL)
-      return false;
-    *x = event->x;
-    *y = event->y;
+  // Modifies event coordinates to the targeted widget contained by this widget.
+  template<class Event> GdkEvent* TransformEvent(Event* event) {
     GdkWindow* dest = GTK_WIDGET(window_contents_)->window;
-    if (event->window != dest) {
-      int dest_x, dest_y;
+    if (event && event->window != dest) {
+      gint dest_x, dest_y;
       gdk_window_get_root_origin(dest, &dest_x, &dest_y);
-      *x = event->x_root - dest_x;
-      *y = event->y_root - dest_y;
-      return true;
+      event->x = event->x_root - dest_x;
+      event->y = event->y_root - dest_y;
     }
-    return false;
+    return reinterpret_cast<GdkEvent*>(event);
   }
 
   // Event handlers:
diff --git a/views/widget/widget_win.cc b/views/widget/widget_win.cc
index f4de479..eb1c67b 100644
--- a/views/widget/widget_win.cc
+++ b/views/widget/widget_win.cc
@@ -864,7 +864,7 @@ LRESULT WidgetWin::OnMouseWheel(UINT message, WPARAM w_param, LPARAM l_param) {
 
   MSG msg = { hwnd(), message, w_param, l_param, 0,
               { GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param) } };
-  return GetRootView()->OnMouseWheel(MouseWheelEvent(msg)) ? 0 : 1;
+  return delegate_->OnMouseEvent(MouseWheelEvent(msg)) ? 0 : 1;
 }
 
 void WidgetWin::OnMove(const CPoint& point) {
diff --git a/views/window/window_gtk.cc b/views/window/window_gtk.cc
index 1e5f48a..2bd7f54e 100644
--- a/views/window/window_gtk.cc
+++ b/views/window/window_gtk.cc
@@ -116,22 +116,20 @@ const Window* WindowGtk::AsWindow() const {
 // WindowGtk, WidgetGtk overrides:
 
 gboolean WindowGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
-  int x = 0, y = 0;
-  GetContainedWidgetEventCoordinates(event, &x, &y);
+  GdkEventButton transformed_event = *event;
+  MouseEvent mouse_event(TransformEvent(&transformed_event));
 
   int hittest_code =
-      GetWindow()->non_client_view()->NonClientHitTest(gfx::Point(x, y));
+      GetWindow()->non_client_view()->NonClientHitTest(mouse_event.location());
   switch (hittest_code) {
     case HTCAPTION: {
-      MouseEvent mouse_pressed(ui::ET_MOUSE_PRESSED, event->x, event->y,
-          Event::GetFlagsFromGdkEvent(reinterpret_cast<GdkEvent*>(event)));
       // Start dragging if the mouse event is a single click and *not* a right
       // click. If it is a right click, then pass it through to
       // WidgetGtk::OnButtonPress so that View class can show ContextMenu upon a
       // mouse release event. We only start drag on single clicks as we get a
       // crash in Gtk on double/triple clicks.
       if (event->type == GDK_BUTTON_PRESS &&
-          !mouse_pressed.IsOnlyRightMouseButton()) {
+          !mouse_event.IsOnlyRightMouseButton()) {
         gfx::Point screen_point(event->x, event->y);
         View::ConvertPointToScreen(GetRootView(), &screen_point);
         gtk_window_begin_move_drag(GetNativeWindow(), event->button,
@@ -174,12 +172,13 @@ gboolean WindowGtk::OnConfigureEvent(GtkWidget* widget,
 }
 
 gboolean WindowGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
-  int x = 0, y = 0;
-  GetContainedWidgetEventCoordinates(event, &x, &y);
+  GdkEventMotion transformed_event = *event;
+  TransformEvent(&transformed_event);
+  gfx::Point translated_location(transformed_event.x, transformed_event.y);
 
   // Update the cursor for the screen edge.
   int hittest_code =
-      GetWindow()->non_client_view()->NonClientHitTest(gfx::Point(x, y));
+      GetWindow()->non_client_view()->NonClientHitTest(translated_location);
   if (hittest_code != HTCLIENT) {
     GdkCursorType cursor_type = HitTestCodeToGdkCursorType(hittest_code);
     gdk_window_set_cursor(widget->window, gfx::GetCursor(cursor_type));