#include <dali/public-api/animation/constraint-source.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/object/property.h>
#include <dali/public-api/object/property-input.h>
+#include <dali/public-api/object/property.h>
#include <dali/public-api/signals/callback.h>
namespace Dali
class ConstraintBase;
}
-typedef Vector< PropertyInput* > PropertyInputContainer;
+using PropertyInputContainer = Vector<PropertyInput*>;
/**
* @brief An abstract base class for Constraints.
class DALI_CORE_API Constraint : public BaseHandle
{
public:
-
/**
* @brief Template for the Function that is called by the Constraint system.
*
* @SINCE_1_0.0
* @tparam P The property type to constrain
*/
- template< typename P >
+ template<typename P>
class DALI_INTERNAL Function : public CallbackBase
{
public:
-
/**
* @brief Constructor which connects to the provided C function (or a static member function).
*
* @SINCE_1_0.0
* @param[in] function The function to call
*/
- Function( void( *function )( P&, const PropertyInputContainer& ) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) ),
- mCopyConstructorDispatcher( NULL )
+ Function(void (*function)(P&, const PropertyInputContainer&))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function)),
+ mCopyConstructorDispatcher(NULL)
{
}
* @param[in] object The object to copy
* @tparam T The type of the object
*/
- template< class T >
- Function( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcher2< T, P&, const PropertyInputContainer& >::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer< T >::Delete ) ),
- mCopyConstructorDispatcher( reinterpret_cast< CopyConstructorDispatcher >( &ObjectCopyConstructorDispatcher< T >::Copy ) )
+ template<class T>
+ Function(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ nullptr, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcher2<T, P&, const PropertyInputContainer&>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete)),
+ mCopyConstructorDispatcher(reinterpret_cast<CopyConstructorDispatcher>(&ObjectCopyConstructorDispatcher<T>::Copy))
{
}
* @param[in] memberFunction The member function to call. This has to be a member of the same class
* @tparam T The type of the object
*/
- template< class T >
- Function( const T& object, void ( T::*memberFunction ) ( P&, const PropertyInputContainer& ) )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &Dispatcher2< T, P&, const PropertyInputContainer& >::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer< T >::Delete ) ),
- mCopyConstructorDispatcher( reinterpret_cast< CopyConstructorDispatcher >( &ObjectCopyConstructorDispatcher< T >::Copy ) )
+ template<class T>
+ Function(const T& object, void (T::*memberFunction)(P&, const PropertyInputContainer&))
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&Dispatcher2<T, P&, const PropertyInputContainer&>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete)),
+ mCopyConstructorDispatcher(reinterpret_cast<CopyConstructorDispatcher>(&ObjectCopyConstructorDispatcher<T>::Copy))
{
}
*/
CallbackBase* Clone()
{
- CallbackBase* callback = NULL;
- if ( mImpl && mImpl->mObjectPointer && mCopyConstructorDispatcher )
+ CallbackBase* callback = nullptr;
+ if(mImpl.mObjectPointer && mCopyConstructorDispatcher)
{
- callback = new Function( mCopyConstructorDispatcher( reinterpret_cast< UndefinedClass* >( mImpl->mObjectPointer ) ) /* Copy the object */,
- mMemberFunction,
- mImpl->mMemberFunctionDispatcher,
- mImpl->mDestructorDispatcher,
- mCopyConstructorDispatcher );
+ callback = new Function(mCopyConstructorDispatcher(reinterpret_cast<UndefinedClass*>(mImpl.mObjectPointer)) /* Copy the object */,
+ mMemberFunction,
+ mImpl.mMemberFunctionDispatcher,
+ mImpl.mDestructorDispatcher,
+ mCopyConstructorDispatcher);
}
else
{
- callback = new Function( mFunction );
+ callback = new Function(mFunction);
}
return callback;
}
private:
-
/**
* @brief Must not be declared.
*
* @brief Used to call the function to copy the stored object.
* @SINCE_1_0.0
*/
- typedef UndefinedClass* (*CopyConstructorDispatcher) ( UndefinedClass* object );
+ using CopyConstructorDispatcher = UndefinedClass* (*)(UndefinedClass*);
/**
* @brief Copies the actual object in Constraint::Function.
* @SINCE_1_0.0
* @tparam T The type of the object
*/
- template< class T >
+ template<class T>
struct ObjectCopyConstructorDispatcher
{
/**
* @param[in] object The object to copy
* @return Newly allocated clone of the object
*/
- static UndefinedClass* Copy( const UndefinedClass* object )
+ static UndefinedClass* Copy(const UndefinedClass* object)
{
- T* copy = new T( *( reinterpret_cast< const T* >( object ) ) );
- return reinterpret_cast< UndefinedClass* >( copy );
+ T* copy = new T(*(reinterpret_cast<const T*>(object)));
+ return reinterpret_cast<UndefinedClass*>(copy);
}
};
- /**
- * @brief Undefined copy constructor.
- * @SINCE_1_0.0
- */
- Function( const Function& );
-
- /**
- * @brief Undefined assignment operator.
- * @SINCE_1_0.0
- */
- Function& operator=( const Function& );
+ Function(const Function&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ Function(Function&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ Function& operator=(const Function&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ Function& operator=(Function&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
/**
* @brief Constructor used when copying the stored object.
* @param[in] destructor Used to delete the owned object
* @param[in] copyConstructorDispatcher Used to create a copy of the owned object
*/
- Function( void* object,
- CallbackBase::MemberFunction memberFunction,
- CallbackBase::Dispatcher dispatcher,
- CallbackBase::Destructor destructor,
- CopyConstructorDispatcher copyConstructorDispatcher )
- : CallbackBase( object, memberFunction, dispatcher, destructor ),
- mCopyConstructorDispatcher( copyConstructorDispatcher )
+ Function(void* object,
+ CallbackBase::MemberFunction memberFunction,
+ CallbackBase::Dispatcher dispatcher,
+ CallbackBase::Destructor destructor,
+ CopyConstructorDispatcher copyConstructorDispatcher)
+ : CallbackBase(object, memberFunction, dispatcher, destructor),
+ mCopyConstructorDispatcher(copyConstructorDispatcher)
{
}
* @SINCE_1_0.0
* @param[in] function The function to call
*/
- Function( CallbackBase::Function function )
- : CallbackBase( function ),
- mCopyConstructorDispatcher( NULL )
+ Function(CallbackBase::Function function)
+ : CallbackBase(function),
+ mCopyConstructorDispatcher(nullptr)
{
}
*/
enum RemoveAction
{
- Bake, ///< When the constraint is fully-applied, the constrained value is saved. @SINCE_1_0.0
- Discard ///< When the constraint is removed, the constrained value is discarded. @SINCE_1_0.0
+ BAKE, ///< When the constraint is fully-applied, the constrained value is saved. @SINCE_1_9.28
+ DISCARD ///< When the constraint is removed, the constrained value is discarded. @SINCE_1_9.28
};
- static const RemoveAction DEFAULT_REMOVE_ACTION; ///< Bake
+ static const RemoveAction DEFAULT_REMOVE_ACTION; ///< BAKE
/**
* @brief Creates an uninitialized Constraint; this can be initialized with Constraint::New().
* @tparam P The type of the property to constrain
* @return The new constraint
*/
- template< class P >
- static Constraint New( Handle handle, Property::Index targetIndex, void( *function )( P&, const PropertyInputContainer& ) )
+ template<class P>
+ static Constraint New(Handle handle, Property::Index targetIndex, void (*function)(P&, const PropertyInputContainer&))
{
- CallbackBase* callback = new Constraint::Function< P >( function );
- return New( handle, targetIndex, PropertyTypes::Get< P >(), callback );
+ CallbackBase* callback = new Constraint::Function<P>(function);
+ return New(handle, targetIndex, PropertyTypes::Get<P>(), callback);
}
/**
* @tparam T The type of the object
* @return The new constraint
*/
- template< class P, class T >
- static Constraint New( Handle handle, Property::Index targetIndex, const T& object )
+ template<class P, class T>
+ static Constraint New(Handle handle, Property::Index targetIndex, const T& object)
{
- CallbackBase* function = new Constraint::Function< P >( object );
- return New( handle, targetIndex, PropertyTypes::Get< P >(), function );
+ CallbackBase* function = new Constraint::Function<P>(object);
+ return New(handle, targetIndex, PropertyTypes::Get<P>(), function);
}
/**
* @tparam P The type of the property to constrain
* @tparam T The type of the object
*/
- template< class P, class T >
- static Constraint New( Handle handle, Property::Index targetIndex, const T& object, void ( T::*memberFunction ) ( P&, const PropertyInputContainer& ) )
+ template<class P, class T>
+ static Constraint New(Handle handle, Property::Index targetIndex, const T& object, void (T::*memberFunction)(P&, const PropertyInputContainer&))
{
- CallbackBase* function = new Constraint::Function< P >( object, memberFunction );
- return New( handle, targetIndex, PropertyTypes::Get< P >(), function );
+ CallbackBase* function = new Constraint::Function<P>(object, memberFunction);
+ return New(handle, targetIndex, PropertyTypes::Get<P>(), function);
}
/**
* @param[in] handle The handle to the property-owning object this constraint is to be cloned for
* @return The new constraint
*/
- Constraint Clone( Handle handle );
+ Constraint Clone(Handle handle);
/**
* @brief Destructor.
* @SINCE_1_0.0
* @param[in] constraint A reference to the copied handle
*/
- Constraint( const Constraint& constraint );
+ Constraint(const Constraint& constraint);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- Constraint& operator=( const Constraint& rhs );
+ Constraint& operator=(const Constraint& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Constraint( Constraint&& rhs );
+ Constraint(Constraint&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Constraint& operator=( Constraint&& rhs );
+ Constraint& operator=(Constraint&& rhs) noexcept;
/**
* @brief Downcasts a handle to Constraint handle.
* @param[in] baseHandle BaseHandle to an object
* @return Handle to a Constraint object or an uninitialized handle
*/
- static Constraint DownCast( BaseHandle baseHandle );
+ static Constraint DownCast(BaseHandle baseHandle);
/**
* @brief Adds a constraint source to the constraint.
* @SINCE_1_0.0
* @param[in] source The constraint source input to add
*/
- void AddSource( ConstraintSource source );
+ void AddSource(ConstraintSource source);
/**
* @brief Applies this constraint.
Dali::Property::Index GetTargetProperty();
/**
- * @brief Sets the remove action. Constraint::Bake will "bake" a value when fully-applied.
+ * @brief Sets the remove action. Constraint::BAKE will "bake" a value when fully-applied.
*
- * In case of Constraint::Discard, the constrained value will be discarded, when the constraint is removed.
- * The default value is Constraint::Bake.
+ * In case of Constraint::DISCARD, the constrained value will be discarded, when the constraint is removed.
+ * The default value is Constraint::BAKE.
* @SINCE_1_0.0
* @param[in] action The remove-action
*/
- void SetRemoveAction( RemoveAction action );
+ void SetRemoveAction(RemoveAction action);
/**
* @brief Retrieves the remove action that will happen when the constraint is removed.
* @SINCE_1_0.0
* @param[in] tag An integer to identify the constraint
*/
- void SetTag( const uint32_t tag );
+ void SetTag(const uint32_t tag);
/**
* @brief Gets the tag.
uint32_t GetTag() const;
public: // Not intended for use by Application developers
-
/// @cond internal
/**
* @brief This constructor is used by Constraint::New() methods.
* @SINCE_1_0.0
* @param[in] constraint A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL Constraint( Internal::ConstraintBase* constraint );
+ explicit DALI_INTERNAL Constraint(Internal::ConstraintBase* constraint);
/// @endcond
private: // Not intended for use by Application developers
-
/// @cond internal
/**
* @brief Constructs a new constraint which targets a property.
* @param[in] function The constraint function
* @return The new constraint
*/
- static Constraint New( Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function );
+ static Constraint New(Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function);
/// @endcond
};
projects / platform / core / uifw / dali-core.git / blobdiff