#define DALI_INTERNAL_GESTURE_DETECTOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/internal/event/actors/actor-impl.h>
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/events/gesture-detector.h>
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/signals/slot-delegate.h>
-#include <dali/public-api/events/gesture-detector.h>
-#include <dali/internal/event/actors/actor-impl.h>
namespace Dali
{
-
namespace Integration
{
struct GestureEvent;
namespace Internal
{
-
class GestureDetector;
class GestureEventProcessor;
-typedef IntrusivePtr<GestureDetector> GestureDetectorPtr;
-typedef std::vector<GestureDetector*> GestureDetectorContainer;
-typedef std::vector<Actor*> GestureDetectorActorContainer;
+using GestureDetectorPtr = IntrusivePtr<GestureDetector>;
+using GestureDetectorContainer = std::vector<GestureDetector*>;
+using GestureDetectorActorContainer = std::vector<Actor*>;
/**
* This is a type trait that should be used by deriving gesture detectors for their container type.
*/
-template< typename Detector >
+template<typename Detector>
struct DerivedGestureDetectorContainer
{
- typedef std::vector<Detector*> type;
+ using type = std::vector<Detector*>;
};
/**
class GestureDetector : public Object, public Object::Observer
{
public:
-
/**
* @copydoc Dali::GestureDetector::Attach()
*/
* Retrieves the type of GestureDetector
* @return The GestureDetector Type
*/
- Gesture::Type GetType() const
+ GestureType::Value GetType() const
{
return mType;
}
bool IsAttached(Actor& actor) const;
protected: // Creation & Destruction
-
/**
* Construct a new GestureDetector.
* @param type the type of gesture
* @param pointer to the scene object, nullptr if none
* by default GestureDetectors don't have our own scene object
*/
- GestureDetector(Gesture::Type type, const SceneGraph::PropertyOwner* sceneObject = nullptr );
+ GestureDetector(GestureType::Value type, const SceneGraph::PropertyOwner* sceneObject = nullptr);
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~GestureDetector();
+ ~GestureDetector() override;
private:
-
// Undefined
- GestureDetector() = delete;
+ GestureDetector() = delete;
GestureDetector(const GestureDetector&) = delete;
GestureDetector& operator=(const GestureDetector& rhs) = delete;
/**
* @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded(Object& object);
+ void SceneObjectAdded(Object& object) override;
/**
* @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectRemoved(Object& object) {}
+ void SceneObjectRemoved(Object& object) override
+ {
+ }
/**
* @copydoc Dali::Internal::Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed(Object& object);
+ void ObjectDestroyed(Object& object) override;
/**
* For use in derived classes, called after an actor is attached.
virtual void OnActorDestroyed(Object& object) = 0;
protected:
-
- Gesture::Type mType; ///< The gesture detector will detect this type of gesture.
+ GestureType::Value mType; ///< The gesture detector will detect this type of gesture.
GestureDetectorActorContainer mAttachedActors; ///< Object::Observer is used to provide weak-pointer behaviour
GestureDetectorActorContainer mPendingAttachActors; ///< Object::Observer is used to provide weak-pointer behaviour
GestureEventProcessor& mGestureEventProcessor; ///< A reference to the gesture event processor.
inline Internal::GestureDetector& GetImplementation(Dali::GestureDetector& detector)
{
- DALI_ASSERT_ALWAYS( detector && "GestureDetector handle is empty" );
+ DALI_ASSERT_ALWAYS(detector && "GestureDetector handle is empty");
BaseObject& handle = detector.GetBaseObject();
inline const Internal::GestureDetector& GetImplementation(const Dali::GestureDetector& detector)
{
- DALI_ASSERT_ALWAYS( detector && "GestureDetector handle is empty" );
+ DALI_ASSERT_ALWAYS(detector && "GestureDetector handle is empty");
const BaseObject& handle = detector.GetBaseObject();