Deliver events and notifications to the RootView.

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


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

4 files changed, 132 insertions, 28 deletions

diff --git a/chrome/views/widget/root_view.cc b/chrome/views/widget/root_view.cc
index 5e6bcc8..e185b4a 100644
--- a/chrome/views/widget/root_view.cc
+++ b/chrome/views/widget/root_view.cc
@@ -403,7 +403,7 @@ void RootView::OnMouseReleased(const MouseEvent& e, bool canceled) {
 }
 
 void RootView::OnMouseMoved(const MouseEvent& e) {
-  View *v = GetViewForPoint(e.location());
+  View* v = GetViewForPoint(e.location());
   // Find the first enabled view.
   while (v && !v->IsEnabled())
     v = v->GetParent();
diff --git a/chrome/views/widget/root_view_gtk.cc b/chrome/views/widget/root_view_gtk.cc
index 115b37d..241e042 100644
--- a/chrome/views/widget/root_view_gtk.cc
+++ b/chrome/views/widget/root_view_gtk.cc
@@ -21,10 +21,6 @@ void RootView::OnPaint(GdkEventExpose* event) {
     SchedulePaint(gfx::Rect(canvas.rectangle()), false);
     if (NeedsPainting(false)) {
       ProcessPaint(&canvas);
-
-      canvas.FillRectInt(SK_ColorRED, 5, 5, 10, 10);
-      canvas.FillRectInt(SK_ColorGREEN, 25, 5, 10, 10);
-      canvas.FillRectInt(SK_ColorBLUE, 45, 5, 10, 10);
     }
   }
 }
diff --git a/chrome/views/widget/widget_gtk.cc b/chrome/views/widget/widget_gtk.cc
index a2a7b35..9356c85 100644
--- a/chrome/views/widget/widget_gtk.cc
+++ b/chrome/views/widget/widget_gtk.cc
@@ -10,7 +10,9 @@
 namespace views {
 
 WidgetGtk::WidgetGtk()
-    : widget_(NULL) {
+    : widget_(NULL),
+      is_mouse_down_(false),
+      last_mouse_event_was_move_(false) {
 }
 
 WidgetGtk::~WidgetGtk() {
@@ -30,6 +32,17 @@ void WidgetGtk::Init(const gfx::Rect& bounds,
   gtk_drawing_area_size(GTK_DRAWING_AREA(widget_), 100, 100);
   gtk_widget_show(widget_);
 
+  // Make sure we receive our motion events.
+  gtk_widget_set_events(widget_,
+                        gtk_widget_get_events(widget_) |
+                        GDK_ENTER_NOTIFY_MASK |
+                        GDK_LEAVE_NOTIFY_MASK |
+                        GDK_BUTTON_PRESS_MASK |
+                        GDK_BUTTON_RELEASE_MASK |
+                        GDK_POINTER_MOTION_MASK |
+                        GDK_KEY_PRESS_MASK |
+                        GDK_KEY_RELEASE_MASK);
+
   root_view_->OnWidgetCreated();
 
   // TODO(port): if(has_own_focus_manager) block
@@ -111,6 +124,7 @@ void WidgetGtk::GetBounds(gfx::Rect* out, bool including_frame) const {
 
 void WidgetGtk::MoveToFront(bool should_activate) {
   // TODO(erg): I'm not sure about how to do z-ordering on GTK widgets...
+  NOTIMPLEMENTED();
 }
 
 gfx::NativeView WidgetGtk::GetNativeView() const {
@@ -118,7 +132,9 @@ gfx::NativeView WidgetGtk::GetNativeView() const {
 }
 
 void WidgetGtk::PaintNow(const gfx::Rect& update_rect) {
-
+  // TODO(erg): This is woefully incomplete and is a straw man implementation.
+  gtk_widget_queue_draw_area(widget_, update_rect.x(), update_rect.y(),
+                             update_rect.width(), update_rect.height());
 }
 
 RootView* WidgetGtk::GetRootView() {
@@ -144,18 +160,106 @@ TooltipManager* WidgetGtk::GetTooltipManager() {
 }
 
 bool WidgetGtk::GetAccelerator(int cmd_id, Accelerator* accelerator) {
+  NOTIMPLEMENTED();
   return false;
 }
 
+gboolean WidgetGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
+  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 false;
+  }
+  last_mouse_move_x_ = screen_loc.x();
+  last_mouse_move_y_ = screen_loc.y();
+  last_mouse_event_was_move_ = true;
+  MouseEvent mouse_move(Event::ET_MOUSE_MOVED,
+                        event->x,
+                        event->y,
+                        Event::GetFlagsFromGdkState(event->state));
+  root_view_->OnMouseMoved(mouse_move);
+  return true;
+}
+
+gboolean WidgetGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
+  return ProcessMousePressed(event);
+}
+
+gboolean WidgetGtk::OnButtonRelease(GtkWidget* widget, GdkEventButton* event) {
+  ProcessMouseReleased(event);
+  return true;
+}
+
 gboolean WidgetGtk::OnPaint(GtkWidget* widget, GdkEventExpose* event) {
   root_view_->OnPaint(event);
   return true;
 }
 
+gboolean WidgetGtk::OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
+  // TODO(port): We may not actually need this message; it looks like
+  // OnNotificationNotify() takes care of this case...
+  return false;
+}
+
+gboolean WidgetGtk::OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event) {
+  last_mouse_event_was_move_ = false;
+  root_view_->ProcessOnMouseExited();
+  return true;
+}
+
+gboolean WidgetGtk::OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
+  KeyEvent key_event(event);
+  return root_view_->ProcessKeyEvent(key_event);
+}
+
+gboolean WidgetGtk::OnKeyRelease(GtkWidget* widget, GdkEventKey* event) {
+  KeyEvent key_event(event);
+  return root_view_->ProcessKeyEvent(key_event);
+}
+
 RootView* WidgetGtk::CreateRootView() {
   return new RootView(this);
 }
 
+bool WidgetGtk::ProcessMousePressed(GdkEventButton* event) {
+  last_mouse_event_was_move_ = false;
+  MouseEvent mouse_pressed(Event::ET_MOUSE_PRESSED,
+                           event->x, event->y,
+//                         (dbl_click ? MouseEvent::EF_IS_DOUBLE_CLICK : 0) |
+                           Event::GetFlagsFromGdkState(event->state));
+  if (root_view_->OnMousePressed(mouse_pressed)) {
+    is_mouse_down_ = true;
+    // TODO(port): Enable this once I figure out what capture is.
+    // if (!has_capture_) {
+    //   SetCapture();
+    //   has_capture_ = true;
+    //   current_action_ = FA_FORWARDING;
+    // }
+    return true;
+  }
+
+  return false;
+}
+
+void WidgetGtk::ProcessMouseReleased(GdkEventButton* event) {
+  last_mouse_event_was_move_ = false;
+  MouseEvent mouse_up(Event::ET_MOUSE_RELEASED,
+                      event->x, event->y,
+                      Event::GetFlagsFromGdkState(event->state));
+  // Release the capture first, that way we don't get confused if
+  // OnMouseReleased blocks.
+  //
+  // TODO(port): Enable this once I figure out what capture is.
+  // if (has_capture_ && ReleaseCaptureOnMouseReleased()) {
+  //   has_capture_ = false;
+  //   current_action_ = FA_NONE;
+  //   ReleaseCapture();
+  // }
+  is_mouse_down_ = false;
+  root_view_->OnMouseReleased(mouse_up, false);
+}
+
 // static
 WidgetGtk* WidgetGtk::GetViewForNative(GtkWidget* widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget), "chrome-views");
diff --git a/chrome/views/widget/widget_gtk.h b/chrome/views/widget/widget_gtk.h
index 9669ba3..9f3c813 100644
--- a/chrome/views/widget/widget_gtk.h
+++ b/chrome/views/widget/widget_gtk.h
@@ -49,33 +49,19 @@ class WidgetGtk : public Widget {
  protected:
   virtual void OnSizeAllocate(GtkWidget* widget, GtkAllocation* allocation) {}
   virtual gboolean OnPaint(GtkWidget* widget, GdkEventExpose* event);
-  virtual gboolean OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
-    return false;
-  }
-  virtual gboolean OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event) {
-    return false;
-  }
-  virtual gboolean OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
-    return false;
-  }
-  virtual gboolean OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
-    return false;
-  }
-  virtual gboolean OnButtonRelease(GtkWidget* widget, GdkEventButton* event) {
-    return false;
-  }
+  virtual gboolean OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event);
+  virtual gboolean OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event);
+  virtual gboolean OnMotionNotify(GtkWidget* widget, GdkEventMotion* event);
+  virtual gboolean OnButtonPress(GtkWidget* widget, GdkEventButton* event);
+  virtual gboolean OnButtonRelease(GtkWidget* widget, GdkEventButton* event);
   virtual gboolean OnFocusIn(GtkWidget* widget, GdkEventFocus* event) {
     return false;
   }
   virtual gboolean OnFocusOut(GtkWidget* widget, GdkEventFocus* event) {
     return false;
   }
-  virtual gboolean OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
-    return false;
-  }
-  virtual gboolean OnKeyRelease(GtkWidget* widget, GdkEventKey* event) {
-    return false;
-  }
+  virtual gboolean OnKeyPress(GtkWidget* widget, GdkEventKey* event);
+  virtual gboolean OnKeyRelease(GtkWidget* widget, GdkEventKey* event);
   virtual gboolean OnScroll(GtkWidget* widget, GdkEventScroll* event) {
     return false;
   }
@@ -87,6 +73,10 @@ class WidgetGtk : public Widget {
  private:
   virtual RootView* CreateRootView();
 
+  // Process a mouse click
+  bool ProcessMousePressed(GdkEventButton* event);
+  void ProcessMouseReleased(GdkEventButton* event);
+
   // Sets and retrieves the WidgetGtk in the userdata section of the widget.
   static WidgetGtk* GetViewForNative(GtkWidget* widget);
   static void SetViewForNative(GtkWidget* widget, WidgetGtk* view);
@@ -115,6 +105,20 @@ class WidgetGtk : public Widget {
 
   // The root of the View hierarchy attached to this window.
   scoped_ptr<RootView> root_view_;
+
+  // If true, the mouse is currently down.
+  bool is_mouse_down_;
+
+  // The following are used to detect duplicate mouse move events and not
+  // deliver them. Displaying a window may result in the system generating
+  // duplicate move events even though the mouse hasn't moved.
+
+  // If true, the last event was a mouse move event.
+  bool last_mouse_event_was_move_;
+
+  // Coordinates of the last mouse move event, in screen coordinates.
+  int last_mouse_move_x_;
+  int last_mouse_move_y_;
 };
 
 }  // namespace views