src/ui/events/gestures/gesture_recognizer_impl.h

   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 #ifndef UI_EVENTS_GESTURES_GESTURE_RECOGNIZER_IMPL_H_
   6 #define UI_EVENTS_GESTURES_GESTURE_RECOGNIZER_IMPL_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/memory/linked_ptr.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "ui/events/event_constants.h"
  14 #include "ui/events/events_export.h"
  15 #include "ui/events/gestures/gesture_provider_aura.h"
  16 #include "ui/events/gestures/gesture_recognizer.h"
  17 #include "ui/events/gestures/gesture_sequence.h"
  18 #include "ui/gfx/point.h"
  19
  20 namespace ui {
  21 class GestureConsumer;
  22 class GestureEvent;
  23 class GestureEventHelper;
  24 class GestureSequence;
  25 class TouchEvent;
  26
  27 // TODO(tdresser): Once the unified gesture recognition process sticks
  28 // (crbug.com/332418), GestureRecognizerImpl can be cleaned up
  29 // significantly.
  30 class EVENTS_EXPORT GestureRecognizerImpl : public GestureRecognizer,
  31                                             public GestureSequenceDelegate,
  32                                             public GestureProviderAuraClient {
  33  public:
  34   typedef std::map<int, GestureConsumer*> TouchIdToConsumerMap;
  35
  36   GestureRecognizerImpl();
  37   virtual ~GestureRecognizerImpl();
  38
  39   std::vector<GestureEventHelper*>& helpers() { return helpers_; }
  40
  41   // Overridden from GestureRecognizer
  42   virtual GestureConsumer* GetTouchLockedTarget(
  43       const TouchEvent& event) OVERRIDE;
  44   virtual GestureConsumer* GetTargetForGestureEvent(
  45       const GestureEvent& event) OVERRIDE;
  46   virtual GestureConsumer* GetTargetForLocation(
  47       const gfx::PointF& location, int source_device_id) OVERRIDE;
  48   virtual void TransferEventsTo(GestureConsumer* current_consumer,
  49                                 GestureConsumer* new_consumer) OVERRIDE;
  50   virtual bool GetLastTouchPointForTarget(GestureConsumer* consumer,
  51                                           gfx::PointF* point) OVERRIDE;
  52   virtual bool CancelActiveTouches(GestureConsumer* consumer) OVERRIDE;
  53
  54  protected:
  55   virtual GestureSequence* GetGestureSequenceForConsumer(GestureConsumer* c);
  56   virtual GestureProviderAura* GetGestureProviderForConsumer(
  57       GestureConsumer* c);
  58   virtual GestureSequence* CreateSequence(
  59       ui::GestureSequenceDelegate* delegate);
  60
  61  private:
  62   // Sets up the target consumer for gestures based on the touch-event.
  63   void SetupTargets(const TouchEvent& event, GestureConsumer* consumer);
  64   void CancelTouches(std::vector<std::pair<int, GestureConsumer*> >* touches);
  65
  66   void DispatchGestureEvent(GestureEvent* event);
  67
  68   // Overridden from GestureRecognizer
  69   virtual bool ProcessTouchEventPreDispatch(const TouchEvent& event,
  70                                             GestureConsumer* consumer) OVERRIDE;
  71
  72   virtual Gestures* ProcessTouchEventPostDispatch(
  73       const TouchEvent& event,
  74       ui::EventResult result,
  75       GestureConsumer* consumer) OVERRIDE;
  76
  77   virtual Gestures* ProcessTouchEventOnAsyncAck(
  78       const TouchEvent& event,
  79       ui::EventResult result,
  80       GestureConsumer* consumer) OVERRIDE;
  81
  82   virtual bool CleanupStateForConsumer(GestureConsumer* consumer)
  83       OVERRIDE;
  84   virtual void AddGestureEventHelper(GestureEventHelper* helper) OVERRIDE;
  85   virtual void RemoveGestureEventHelper(GestureEventHelper* helper) OVERRIDE;
  86
  87   // Overridden from ui::GestureSequenceDelegate.
  88   virtual void DispatchPostponedGestureEvent(GestureEvent* event) OVERRIDE;
  89
  90   // Overridden from GestureProviderAuraClient
  91   virtual void OnGestureEvent(GestureEvent* event) OVERRIDE;
  92
  93   // Convenience method to find the GestureEventHelper that can dispatch events
  94   // to a specific |consumer|.
  95   GestureEventHelper* FindDispatchHelperForConsumer(GestureConsumer* consumer);
  96
  97   std::map<GestureConsumer*, GestureSequence*> consumer_sequence_;
  98   std::map<GestureConsumer*, GestureProviderAura*> consumer_gesture_provider_;
  99
 100   // Both |touch_id_target_| and |touch_id_target_for_gestures_| map a touch-id
 101   // to its target window.  touch-ids are removed from |touch_id_target_| on
 102   // ET_TOUCH_RELEASE and ET_TOUCH_CANCEL. |touch_id_target_for_gestures_| are
 103   // removed in ConsumerDestroyed().
 104   TouchIdToConsumerMap touch_id_target_;
 105   TouchIdToConsumerMap touch_id_target_for_gestures_;
 106
 107   std::vector<GestureEventHelper*> helpers_;
 108
 109   bool use_unified_gesture_detector_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(GestureRecognizerImpl);
 112 };
 113
 114 // Provided only for testing:
 115 EVENTS_EXPORT void SetGestureRecognizerForTesting(
 116     GestureRecognizer* gesture_recognizer);
 117
 118 }  // namespace ui
 119
 120 #endif  // UI_EVENTS_GESTURES_GESTURE_RECOGNIZER_IMPL_H_