d136c6cddcf137ece63c93a179431e345426f535
[platform/core/uifw/dali-core.git] / dali / internal / event / events / gesture-detector-impl.h
1 #ifndef __DALI_INTERNAL_GESTURE_DETECTOR_H__
2 #define __DALI_INTERNAL_GESTURE_DETECTOR_H__
3
4 /*
5  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  */
20
21 // INTERNAL INCLUDES
22 #include <dali/public-api/common/vector-wrapper.h>
23 #include <dali/public-api/common/dali-common.h>
24 #include <dali/public-api/events/gesture.h>
25 #include <dali/public-api/signals/slot-delegate.h>
26 #include <dali/public-api/events/gesture-detector.h>
27 #include <dali/internal/event/actors/actor-impl.h>
28
29 namespace Dali
30 {
31
32 namespace Integration
33 {
34 struct GestureEvent;
35 }
36
37 namespace Internal
38 {
39
40 class GestureDetector;
41 class GestureEventProcessor;
42
43 typedef IntrusivePtr<GestureDetector> GestureDetectorPtr;
44 typedef std::vector<GestureDetector*> GestureDetectorContainer;
45 typedef std::vector<Actor*> GestureDetectorActorContainer;
46
47 /**
48  * This is a type trait that should be used by deriving gesture detectors for their container type.
49  */
50 template< typename Detector >
51 struct DerivedGestureDetectorContainer
52 {
53   typedef std::vector<Detector*> type;
54 };
55
56 /**
57  * @copydoc Dali::GestureDetector
58  */
59 class GestureDetector : public Object, public Object::Observer
60 {
61 public:
62
63   /**
64    * @copydoc Dali::GestureDetector::Attach()
65    */
66   void Attach(Actor& actor);
67
68   /**
69    * @copydoc Dali::GestureDetector::Detach()
70    */
71   void Detach(Actor& actor);
72
73   /**
74    * @copydoc Dali::GestureDetector::DetachAll()
75    */
76   void DetachAll();
77
78   /**
79    * @copydoc Dali::GestureDetector::GetAttachedActorCount() const
80    */
81   size_t GetAttachedActorCount() const;
82
83   /**
84    * @copydoc Dali::GestureDetector::GetAttachedActor() const
85    */
86   Dali::Actor GetAttachedActor(size_t index) const;
87
88   /**
89    * Returns a const reference to the container of attached actor pointers.
90    * @return A const reference to the attached internal actors.
91    */
92   const GestureDetectorActorContainer& GetAttachedActorPointers() const
93   {
94     return mAttachedActors;
95   }
96
97   /**
98    * Retrieves the type of GestureDetector
99    * @return The GestureDetector Type
100    */
101   Gesture::Type GetType() const
102   {
103     return mType;
104   }
105
106   /**
107    * Checks if the specified actor is still attached.
108    * @param[in]  actor  The actor to check.
109    * @return true, if the actor is attached, false otherwise.
110    */
111   bool IsAttached(Actor& actor) const;
112
113 protected: // Creation & Destruction
114
115   /**
116    * Construct a new GestureDetector.
117    */
118   GestureDetector(Gesture::Type mType);
119
120   /**
121    * A reference counted object may only be deleted by calling Unreference()
122    */
123   virtual ~GestureDetector();
124
125 private:
126
127   // Undefined
128   GestureDetector(const GestureDetector&);
129
130   // Undefined
131   GestureDetector& operator=(const GestureDetector& rhs);
132
133   /**
134    * @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
135    */
136   virtual void SceneObjectAdded(Object& object) {}
137
138   /**
139    * @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
140    */
141   virtual void SceneObjectRemoved(Object& object) {}
142
143   /**
144    * @copydoc Dali::Internal::Object::Observer::ObjectDestroyed()
145    */
146   virtual void ObjectDestroyed(Object& object);
147
148   /**
149    * For use in derived classes, called after an actor is attached.
150    * @param[in]  actor  The actor that is being attached.
151    */
152   virtual void OnActorAttach(Actor& actor) = 0;
153
154   /**
155    * For use in derived classes, called after an actor is detached.
156    * @param[in] actor The actor that is being detached.
157    */
158   virtual void OnActorDetach(Actor& actor) = 0;
159
160   /**
161    * For use in derived classes, called when an attached actor is destroyed.
162    * @param[in] object The object (Actor's base class) that has been destroyed.
163    * @note Derived classes should not call any Actor specific APIs in this method as the Actor's
164    *       destructor would have already been called.
165    */
166   virtual void OnActorDestroyed(Object& object) = 0;
167
168 private: // Default property extensions from Object
169
170   /**
171    * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
172    */
173   virtual unsigned int GetDefaultPropertyCount() const;
174
175   /**
176    * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
177    */
178   virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
179
180   /**
181    * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
182    */
183   virtual const char* GetDefaultPropertyName(Property::Index index) const;
184
185   /**
186    * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
187    */
188   virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
189
190   /**
191    * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
192    */
193   virtual bool IsDefaultPropertyWritable(Property::Index index) const;
194
195   /**
196    * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
197    */
198   virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
199
200   /**
201    * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
202    */
203   virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
204
205   /**
206    * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
207    */
208   virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
209
210   /**
211    * @copydoc Dali::Internal::Object::SetDefaultProperty()
212    */
213   virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
214
215   /**
216    * @copydoc Dali::Internal::Object::GetDefaultProperty()
217    */
218   virtual Property::Value GetDefaultProperty( Property::Index index ) const;
219
220   /**
221    * @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
222    */
223   virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
224
225   /**
226    * @copydoc Dali::Internal::Object::GetSceneObject()
227    */
228   virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
229
230   /**
231    * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
232    */
233   virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
234
235   /**
236    * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
237    */
238   virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
239
240 protected:
241
242   Gesture::Type                 mType;                  ///< The gesture detector will detect this type of gesture.
243   GestureDetectorActorContainer mAttachedActors;        ///< Object::Observer is used to provide weak-pointer behaviour
244   GestureEventProcessor&        mGestureEventProcessor; ///< A reference to the gesture event processor.
245 };
246
247 } // namespace Internal
248
249 // Helpers for public-api forwarding methods
250
251 inline Internal::GestureDetector& GetImplementation(Dali::GestureDetector& detector)
252 {
253   DALI_ASSERT_ALWAYS( detector && "GestureDetector handle is empty" );
254
255   BaseObject& handle = detector.GetBaseObject();
256
257   return static_cast<Internal::GestureDetector&>(handle);
258 }
259
260 inline const Internal::GestureDetector& GetImplementation(const Dali::GestureDetector& detector)
261 {
262   DALI_ASSERT_ALWAYS( detector && "GestureDetector handle is empty" );
263
264   const BaseObject& handle = detector.GetBaseObject();
265
266   return static_cast<const Internal::GestureDetector&>(handle);
267 }
268
269 } // namespace Dali
270
271 #endif // __DALI_INTERNAL_GESTURE_DETECTOR_H__