Eager Gesture Recognizer (WIP)

ui/aura/root_window.h

 // 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.
 
 #ifndef UI_AURA_ROOT_WINDOW_H_
 #define UI_AURA_ROOT_WINDOW_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/aura/aura_export.h"
 #include "ui/aura/client/capture_delegate.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/aura/window_tree_host_delegate.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_targeter.h"
+#include "ui/events/gestures/gesture_event_queue.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/events/gestures/gesture_types.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 
 namespace gfx {
 class Size;
 class Transform;
 }
 
@@ skipping 13 matching lines @@
 class RootWindowHost;
 class RootWindowObserver;
 class TestScreen;
 class WindowTargeter;
 
 // RootWindow is responsible for hosting a set of windows.
 class AURA_EXPORT RootWindow : public ui::EventProcessor,
                                public ui::GestureEventHelper,
                                public ui::LayerAnimationObserver,
                                public aura::client::CaptureDelegate,
-                               public aura::RootWindowHostDelegate {
+                               public aura::RootWindowHostDelegate,
+                               public ui::GestureEventQueueDelegate {
  public:
   struct AURA_EXPORT CreateParams {
     // CreateParams with initial_bounds and default host in pixel.
     explicit CreateParams(const gfx::Rect& initial_bounds);
     ~CreateParams() {}
 
     gfx::Rect initial_bounds;
 
     // A host to use in place of the default one that RootWindow will create.
     // NULL by default.
@@ skipping 56 matching lines @@
 
   // Moves the cursor to the |host_location| given in host coordinates.
   void MoveCursorToHostLocation(const gfx::Point& host_location);
 
   // Returns a target window for the given gesture event.
   Window* GetGestureTarget(ui::GestureEvent* event);
 
   // Handles a gesture event. Returns true if handled. Unlike the other
   // event-dispatching function (e.g. for touch/mouse/keyboard events), gesture
   // events are dispatched from GestureRecognizer instead of RootWindowHost.
-  void DispatchGestureEvent(ui::GestureEvent* event);
+  virtual void DispatchGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // Invoked when |window| is being destroyed.
   void OnWindowDestroying(Window* window);
 
   // Invoked when |window|'s bounds have changed. |contained_mouse| indicates if
   // the bounds before change contained the |last_moust_location()|.
   void OnWindowBoundsChanged(Window* window, bool contained_mouse);
 
   // Dispatches OnMouseExited to the |window| which is hiding if nessessary.
   void DispatchMouseExitToHidingWindow(Window* window);
@@ skipping 41 matching lines @@
   //
   // More than one hold can be invoked and each hold must be cancelled by a
   // release before we resume normal operation.
   void HoldPointerMoves();
   void ReleasePointerMoves();
 
   // Gets the last location seen in a mouse event in this root window's
   // coordinates. This may return a point outside the root window's bounds.
   gfx::Point GetLastMouseLocationInRoot() const;
 
+  void OnTouchEventForGestures(
+      ui::TouchEvent* event,
+      ui::TouchPointState::RequiresAck requires_ack);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(RootWindowTest, KeepTranslatedEventInRoot);
 
   friend class Window;
   friend class TestScreen;
 
   // The parameter for OnWindowHidden() to specify why window is hidden.
   enum WindowHiddenReason {
     WINDOW_DESTROYED,  // Window is destroyed.
     WINDOW_HIDDEN,     // Window is hidden.
@@ skipping 46 matching lines @@
 
   // Overridden from ui::EventDispatcherDelegate.
   virtual bool CanDispatchToTarget(ui::EventTarget* target) OVERRIDE;
   virtual ui::EventDispatchDetails PreDispatchEvent(ui::EventTarget* target,
                                                     ui::Event* event) OVERRIDE;
   virtual ui::EventDispatchDetails PostDispatchEvent(
       ui::EventTarget* target, const ui::Event& event) OVERRIDE;
 
   // Overridden from ui::GestureEventHelper.
   virtual bool CanDispatchToConsumer(ui::GestureConsumer* consumer) OVERRIDE;
-  virtual void DispatchPostponedGestureEvent(ui::GestureEvent* event) OVERRIDE;
   virtual void DispatchCancelTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
   // Overridden from ui::LayerAnimationObserver:
   virtual void OnLayerAnimationEnded(
       ui::LayerAnimationSequence* animation) OVERRIDE;
   virtual void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* animation) OVERRIDE;
   virtual void OnLayerAnimationAborted(
       ui::LayerAnimationSequence* animation) OVERRIDE;
 
@@ skipping 22 matching lines @@
   // ReleaseMouseMoves()/ReleaseTouchMoves() is called.  NOTE: because these
   // methods dispatch events from RootWindowHost the coordinates are in terms of
   // the root.
   ui::EventDispatchDetails DispatchMouseEventImpl(ui::MouseEvent* event)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchMouseEventRepost(ui::MouseEvent* event)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchMouseEventToTarget(ui::MouseEvent* event,
                                                       Window* target)
       WARN_UNUSED_RESULT;
-  ui::EventDispatchDetails DispatchTouchEventImpl(ui::TouchEvent* event)
+  ui::EventDispatchDetails DispatchTouchEventImpl(ui::TouchEvent* event,
+                                                  Window* target)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchHeldEvents() WARN_UNUSED_RESULT;
   // Creates and dispatches synthesized mouse move event using the
   // current mouse location.
   ui::EventDispatchDetails SynthesizeMouseMoveEvent() WARN_UNUSED_RESULT;
 
   void SynthesizeMouseMoveEventAsync();
 
   // Posts a task to send synthesized mouse move event if there
   // is no a pending task.
   void PostMouseMoveEventAfterWindowChange();
 
   void PreDispatchLocatedEvent(Window* target, ui::LocatedEvent* event);
 
+  Window* GetTouchEventTarget(ui::TouchEvent* event);
+
   // TODO(beng): evaluate the ideal ownership model.
   scoped_ptr<Window> window_;
 
   scoped_ptr<RootWindowHost> host_;
 
   // Touch ids that are currently down.
   uint32 touch_ids_down_;
 
   // Last cursor set.  Used for testing.
   gfx::NativeCursor last_cursor_;
@@ skipping 19 matching lines @@
   bool dispatching_held_event_;
 
   scoped_ptr<ui::ViewProp> prop_;
 
   // Used to schedule reposting an event.
   base::WeakPtrFactory<RootWindow> repost_event_factory_;
 
   // Used to schedule DispatchHeldEvents() when |move_hold_count_| goes to 0.
   base::WeakPtrFactory<RootWindow> held_event_factory_;
 
+  std::map<Window*, ui::GestureEventQueue*> gesture_event_queues_;
+
   DISALLOW_COPY_AND_ASSIGN(RootWindow);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_ROOT_WINDOW_H_