} // namespace VisibilityChange
-typedef Signal< void ( Actor, bool, VisibilityChange::Type ) > VisibilityChangedSignalType; ///< Signal type of VisibilityChangedSignalType
+using VisibilityChangedSignalType = Signal<void( Actor, bool, VisibilityChange::Type )>; ///< Signal type of VisibilityChangedSignalType
/**
* @brief This signal is emitted when the visible property of this or a parent actor is changed.
*/
DALI_CORE_API Rect<> CalculateScreenExtents( Actor actor );
-
-
-typedef Signal< void (Actor) > ChildChangedSignalType; ///< Called when the actor has a child added or removed
+using ChildChangedSignalType = Signal<void( Actor )>; ///< Called when the actor has a child added or removed
/**
* @brief This signal is emitted when a child is added to this actor.
*/
DALI_CORE_API ChildChangedSignalType& ChildRemovedSignal( Actor actor );
-
-typedef Signal< void (Actor) > ChildOrderChangedSignalType; ///< Used when the actor's children have changed order
+using ChildOrderChangedSignalType = Signal<void( Actor )>; ///< Used when the actor's children have changed order
/**
* @brief This signal is emitted when an actor's children change their sibling order
* @brief AnimationData holds the required data required to define an
* animation to be performed on an actor or actors.
*/
- typedef Dali::Vector< AnimationDataElement* > AnimationDataList;
-
+ using AnimationDataList = Dali::Vector<AnimationDataElement*>;
/**
* @brief Adds one AnimationDataElement to the list to describe one animation.
class OwnerContainer : public Dali::Vector< T >
{
public:
-
- typedef typename Dali::Vector< T >::SizeType SizeType;
- typedef typename Vector< T >::Iterator Iterator;
- typedef typename Vector< T >::ConstIterator ConstIterator;
+ using SizeType = typename Dali::Vector<T>::SizeType;
+ using Iterator = typename Vector<T>::Iterator;
+ using ConstIterator = typename Vector<T>::ConstIterator;
/**
* Create a pointer-container.
CONTINUOUSLY, ///< Will render continuously.
};
-typedef Signal< bool (const KeyEvent&) > KeyEventGeneratedSignalType; ///< Stage key event generated signal type
+using KeyEventGeneratedSignalType = Signal<bool( const KeyEvent& )>; ///< Stage key event generated signal type
/**
* @brief The user would connect to this signal to get a KeyEvent when KeyEvent is generated.
class DALI_CORE_API Stage : public BaseHandle
{
public:
-
- typedef Signal< void (const KeyEvent&) > KeyEventSignalType; ///< Key event signal type
- typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type
- typedef Signal< void (const TouchEvent&) > TouchEventSignalType; ///< Touch signal type
- typedef Signal< void (const WheelEvent&) > WheelEventSignalType; ///< Wheel signal type
- typedef Signal< void () > ContextStatusSignal; ///< Context status signal type
- typedef Signal< void () > SceneCreatedSignalType; ///< Scene created signal type
+ using KeyEventSignalType = Signal<void( const KeyEvent& )>; ///< Key event signal type
+ using EventProcessingFinishedSignalType = Signal<void()>; ///< Event Processing finished signal type
+ using TouchEventSignalType = Signal<void( const TouchEvent& )>; ///< Touch signal type
+ using WheelEventSignalType = Signal<void( const WheelEvent& )>; ///< Wheel signal type
+ using ContextStatusSignal = Signal<void()>; ///< Context status signal type
+ using SceneCreatedSignalType = Signal<void()>; ///< Scene created signal type
/**
* @brief Allows the creation of an empty stage handle.
*
* @return true, if the actor is hittable, false otherwise.
*/
-typedef bool (*HitTestFunction)(Actor actor, TraverseType type);
+using HitTestFunction = bool ( * )( Actor, TraverseType );
/**
* @brief Given screen coordinates, this method returns the hit actor & the local coordinates relative to
Vector2 screen;
};
-typedef std::vector<TouchPoint> TouchPointContainer; ///< Container of touch points. @SINCE_1_0.0
-typedef TouchPointContainer::iterator TouchPointContainerIterator; ///< Iterator for Dali::TouchPointContainer @SINCE_1_0.0
-typedef TouchPointContainer::const_iterator TouchPointContainerConstIterator; ///< Const iterator for Dali::TouchPointContainer @SINCE_1_0.0
+using TouchPointContainer = std::vector<TouchPoint>; ///< Container of touch points. @SINCE_1_0.0
+using TouchPointContainerIterator = TouchPointContainer::iterator; ///< Iterator for Dali::TouchPointContainer @SINCE_1_0.0
+using TouchPointContainerConstIterator = TouchPointContainer::const_iterator; ///< Const iterator for Dali::TouchPointContainer @SINCE_1_0.0
/**
* @}
* @param[in] typeName The type name of the object to be created.
* @return Pointer to a BaseHandle
*/
- typedef BaseHandle* (*CreateFunction)(const char* const typeName);
+using CreateFunction = BaseHandle *(*)( const char *const );
- /**
+/**
* @brief Callback to set an event-thread only property.
*
* @param[in] object The object whose property should be set.
* @param[in] value The new value of the property for the object specified.
* @see PropertyRegistration.
*/
- typedef void (*SetPropertyFunction)( BaseObject* object, const char* const propertyName , Property::Value* value );
-
+using SetPropertyFunction = void ( * )( BaseObject *, const char *const, Property::Value * );
- /**
+/**
* @brief Callback to get the value of an event-thread only property.
*
* @param[in] object The object whose property value is required.
* @return The current value of the property for the object specified.
* @see PropertyRegistration.
*/
- typedef Property::Value* (*GetPropertyFunction)( BaseObject* object, const char* const propertyName );
+using GetPropertyFunction = Property::Value *(*)( BaseObject *, const char *const );
}
DALI_CORE_API void ConvertToGlFormat(Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat);
class Bitmap;
-typedef IntrusivePtr<Bitmap> BitmapPtr;
-typedef uint8_t PixelBuffer; ///< Pixel data buffers are composed of these
+using BitmapPtr = IntrusivePtr<Bitmap>;
+using PixelBuffer = uint8_t; ///< Pixel data buffers are composed of these
/**
* Bitmap class.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Bitmap();
+ ~Bitmap() override;
protected:
// Less opaque types for debugger
typedef std::vector<Dali::Property::Value> DebugPropertyValueArray;
-typedef std::pair< Property::Index, Property::Value > DebugIndexValuePair;
-typedef std::vector<Dali::StringValuePair> DebugStringValueContainer;
-typedef std::vector< DebugIndexValuePair > DebugIndexValueContainer;
+using DebugIndexValuePair = std::pair<Property::Index, Property::Value>;
+using DebugStringValueContainer = std::vector<Dali::StringValuePair>;
+using DebugIndexValueContainer = std::vector<DebugIndexValuePair>;
struct DebugPropertyValueMap
{
/**
* typedef for the logging function.
*/
-typedef void (*LogFunction)(DebugPriority priority, std::string& message);
+using LogFunction = void ( * )( DebugPriority, std::string & );
/**
* A log function has to be installed for every thread that wants to use logging.
class DALI_CORE_API Filter
{
public:
- typedef std::list<Filter*> FilterList;
- typedef std::list<Filter*>::iterator FilterIter;
+ using FilterList = std::list<Filter *>;
+ using FilterIter = std::list<Filter *>::iterator;
public:
/**
* Virtual destructor
*/
- virtual ~HoverEvent();
+ ~HoverEvent() override;
};
} // namespace Integration
/**
* Virtual destructor
*/
- virtual ~KeyEvent();
+ ~KeyEvent() override;
// Data
namespace Integration
{
-
-typedef std::vector< Point > PointContainer; ///< Container of points
-typedef PointContainer::iterator PointContainerIterator; ///< Iterator for Dali::Integration::PointContainer
-typedef PointContainer::const_iterator PointContainerConstIterator; ///< Const iterator for Dali::Integration::PointContainer
+using PointContainer = std::vector<Point>; ///< Container of points
+using PointContainerIterator = PointContainer::iterator; ///< Iterator for Dali::Integration::PointContainer
+using PointContainerConstIterator = PointContainer::const_iterator; ///< Const iterator for Dali::Integration::PointContainer
/**
* An instance of this structure should be used by the adaptor to send a multi-point event to Dali core.
/**
* Virtual destructor
*/
- virtual ~MultiPointEvent();
+ ~MultiPointEvent() override;
protected:
/**
/**
* Virtual destructor
*/
- virtual ~TouchEvent();
+ ~TouchEvent() override;
};
} // namespace Integration
/**
* Virtual destructor
*/
- virtual ~WheelEvent();
+ ~WheelEvent() override;
// Data
/* OpenGL ES 2.0 */
-typedef void GLvoid;
-typedef char GLchar;
-typedef unsigned int GLenum;
-typedef unsigned char GLboolean;
-typedef unsigned int GLbitfield;
-typedef int8_t GLbyte;
-typedef short GLshort;
-typedef int GLint;
-typedef int GLsizei;
-typedef uint8_t GLubyte;
-typedef unsigned short GLushort;
-typedef unsigned int GLuint;
-typedef float GLfloat;
-typedef float GLclampf;
-typedef int GLfixed;
-typedef signed long int GLintptr;
-typedef signed long int GLsizeiptr;
+using GLvoid = void;
+using GLchar = char;
+using GLenum = unsigned int;
+using GLboolean = unsigned char;
+using GLbitfield = unsigned int;
+using GLbyte = int8_t;
+using GLshort = short;
+using GLint = int;
+using GLsizei = int;
+using GLubyte = uint8_t;
+using GLushort = unsigned short;
+using GLuint = unsigned int;
+using GLfloat = float;
+using GLclampf = float;
+using GLfixed = int;
+using GLintptr = long;
+using GLsizeiptr = long;
/* OpenGL ES 3.0 */
-typedef unsigned short GLhalf;
-typedef int64_t GLint64;
-typedef uint64_t GLuint64;
-typedef __GLsync* GLsync;
+using GLhalf = unsigned short;
+using GLint64 = int64_t;
+using GLuint64 = uint64_t;
+using GLsync = __GLsync*;
namespace Integration
{
namespace Integration
{
-typedef uint32_t ResourceId;
-typedef IntrusivePtr<Dali::RefObject> ResourcePointer;
+using ResourceId = uint32_t;
+using ResourcePointer = IntrusivePtr<Dali::RefObject>;
/**
* PlatformAbstraction is an abstract interface, used by Dali to access platform specific services.
namespace Dali
{
-
-typedef Uint16Pair ImageDimensions;
+using ImageDimensions = Uint16Pair;
namespace Integration
{
class DALI_CORE_API Scene : public BaseHandle
{
public:
- typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type
- typedef Signal< void (const Dali::KeyEvent&) > KeyEventSignalType; ///< Key event signal type
- typedef Signal< bool (const Dali::KeyEvent&) > KeyEventGeneratedSignalType; ///< key event generated signal type
- typedef Signal< void (const Dali::TouchEvent&) > TouchEventSignalType; ///< Touch signal type
- typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< WheelEvent signal type
+ using EventProcessingFinishedSignalType = Signal<void()>; ///< Event Processing finished signal type
+ using KeyEventSignalType = Signal<void( const Dali::KeyEvent& )>; ///< Key event signal type
+ using KeyEventGeneratedSignalType = Signal<bool( const Dali::KeyEvent& )>; ///< key event generated signal type
+ using TouchEventSignalType = Signal<void( const Dali::TouchEvent& )>; ///< Touch signal type
+ using WheelEventSignalType = Signal<void( const Dali::WheelEvent& )>; ///< WheelEvent signal type
using FrameCallbackContainer = std::vector< std::pair< std::unique_ptr< CallbackBase >, int32_t > >;
/**
* typedef for the LogContextFunction function.
*/
-typedef void ( *LogContextFunction )( bool start, const char* tag );
+using LogContextFunction = void ( * )( bool, const char* );
/**
* A LogContextFunction function has to be installed for every thread that wants to use tracing.
namespace Internal
{
-
-typedef uint32_t BufferIndex;
+using BufferIndex = uint32_t;
} // namespace Internal
/**
* Destructor
*/
- ~Core();
+ ~Core() override;
/**
* @copydoc Dali::Integration::Core::Initialize()
class FixedSizeMemoryPool
{
public:
-
- typedef uint32_t SizeType;
+ using SizeType = uint32_t;
public:
* ScalingMode, but all other filter modes do if the desired dimensions are
* `<=` the raw dimensions of the image file.
*/
- typedef Dali::SamplingMode::Type FilterMode;
+ using FilterMode = Dali::SamplingMode::Type;
static const ImageAttributes DEFAULT_ATTRIBUTES; ///< Default attributes have no size
class MessageBuffer
{
public:
- typedef std::ptrdiff_t WordType;
+ using WordType = std::ptrdiff_t;
/**
* Create a new MessageBuffer
class Message : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)();
+ using MemberFunction = void ( T::* )();
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~Message()
+ ~Message() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)();
}
class MessageValue1 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)( typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue1()
+ ~MessageValue1() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1 );
}
class MessageValue2 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue2()
+ ~MessageValue2() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2 );
}
class MessageValue3 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue3()
+ ~MessageValue3() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3 );
}
class MessageValue4 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue4()
+ ~MessageValue4() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4 );
}
class MessageValue5 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType,
- typename ParameterType< P5 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue5()
+ ~MessageValue5() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4, param5 );
}
class MessageValue6 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType,
- typename ParameterType< P5 >::PassingType,
- typename ParameterType< P6 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType, typename ParameterType<P6>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue6()
+ ~MessageValue6() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4, param5, param6 );
}
class MessageDoubleBuffered0 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)( BufferIndex );
+ using MemberFunction = void ( T::* )( BufferIndex );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered0()
+ ~MessageDoubleBuffered0() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex );
}
class MessageDoubleBuffered1 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered1()
+ ~MessageDoubleBuffered1() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param );
}
class MessageDoubleBuffered2 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered2()
+ ~MessageDoubleBuffered2() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3 );
}
class MessageDoubleBuffered3 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered3()
+ ~MessageDoubleBuffered3() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3, param4 );
}
class MessageDoubleBuffered4 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType,
- typename ParameterType< P5 >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered4()
+ ~MessageDoubleBuffered4() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3, param4, param5 );
}
/**
* Pointer-to-member type. Objects can be implicitly converted to this for validity checks.
*/
- typedef void (OwnerPointer::*BooleanType)() const;
+ using BooleanType = void ( OwnerPointer<T>::* )() const;
/**
* Converts an object handle to a BooleanType.
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* ShaderData class.
* Protected Destructor
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~ShaderData()
+ ~ShaderData() override
{
// vector releases its data
}
namespace Internal
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* Abstract interface for passing a ShaderData object towards being saved.
template <typename Type>
struct BasicType
{
- typedef Type HolderType;
- typedef Type PassingType;
+ using HolderType = Type;
+ using PassingType = Type;
};
// For complex types that are copied into the message,
template <typename Type>
struct ComplexType
{
- typedef Type HolderType;
- typedef const Type& PassingType;
+ using HolderType = Type;
+ using PassingType = const Type&;
};
// For complex types that are owned by the message,
template <typename Type>
struct OwnedType
{
- typedef OwnerPointer<Type> HolderType;
- typedef OwnerPointer<Type>& PassingType;
+ using HolderType = OwnerPointer<Type>;
+ using PassingType = OwnerPointer<Type>&;
};
class CustomActor;
class Layer;
-typedef IntrusivePtr<Actor> ActorPtr;
-typedef IntrusivePtr<CameraActor> CameraActorPtr;
-typedef IntrusivePtr<CustomActor> CustomActorPtr;
-typedef IntrusivePtr<Layer> LayerPtr;
+using ActorPtr = IntrusivePtr<Actor>;
+using CameraActorPtr = IntrusivePtr<CameraActor>;
+using CustomActorPtr = IntrusivePtr<CustomActor>;
+using LayerPtr = IntrusivePtr<Layer>;
} // namespace Internal
class Renderer;
class Scene;
-typedef std::vector< ActorPtr > ActorContainer;
-typedef ActorContainer::iterator ActorIter;
-typedef ActorContainer::const_iterator ActorConstIter;
+using ActorContainer = std::vector<ActorPtr>;
+using ActorIter = ActorContainer::iterator;
+using ActorConstIter = ActorContainer::const_iterator;
-typedef std::vector< RendererPtr > RendererContainer;
-typedef RendererContainer::iterator RendererIter;
+using RendererContainer = std::vector<RendererPtr>;
+using RendererIter = RendererContainer::iterator;
class ActorDepthTreeNode;
-typedef Dali::Internal::MemoryPoolObjectAllocator< ActorDepthTreeNode > DepthNodeMemoryPool;
+using DepthNodeMemoryPool = Dali::Internal::MemoryPoolObjectAllocator<ActorDepthTreeNode>;
/**
* Actor is the primary object which Dali applications interact with.
Dimension::Type dimension; ///< The dimension to hold
};
- typedef std::vector< ActorDimensionPair > ActorDimensionStack;
+ using ActorDimensionStack = std::vector<ActorDimensionPair>;
public:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Actor();
+ ~Actor() override;
/**
* Called on a child during Add() when the parent actor is connected to the Scene.
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* @copydoc Dali::Internal::Object::SetSceneGraphProperty()
*/
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
+ void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
*/
- virtual int32_t GetPropertyComponentIndex( Property::Index index ) const;
+ int32_t GetPropertyComponentIndex( Property::Index index ) const override;
/**
* Retrieve the actor's node.
* Retrieve the parent object of an Actor.
* @return The parent object, or NULL if the Actor does not have a parent.
*/
- virtual Object* GetParentObject() const;
+ Object* GetParentObject() const override;
/**
* Set Sibling order
/**
* copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~CameraActor();
+ ~CameraActor() override;
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~CustomActor();
+ ~CustomActor() override;
private:
/**
* @copydoc Internal::Actor::OnSceneConnectionExternal
*/
- virtual void OnSceneConnectionExternal( int32_t depth )
+ void OnSceneConnectionExternal( int32_t depth ) override
{
mImpl->OnSceneConnection( depth );
}
/**
* @copydoc Internal::Actor::OnSceneDisconnectionExternal
*/
- virtual void OnSceneDisconnectionExternal()
+ void OnSceneDisconnectionExternal() override
{
mImpl->OnSceneDisconnection();
}
/**
* @copydoc Internal::Actor::OnChildAdd
*/
- virtual void OnChildAdd(Actor& child)
+ void OnChildAdd(Actor& child) override
{
Dali::Actor handle(&child);
mImpl->OnChildAdd(handle);
/**
* @copydoc Internal::Actor::OnChildRemove
*/
- virtual void OnChildRemove(Actor& child)
+ void OnChildRemove(Actor& child) override
{
Dali::Actor handle(&child);
mImpl->OnChildRemove(handle);
/**
* @copydoc Internal::Actor::OnPropertySet
*/
- virtual void OnPropertySet( Property::Index index, const Property::Value& propertyValue )
+ void OnPropertySet( Property::Index index, const Property::Value& propertyValue ) override
{
mImpl->OnPropertySet(index, propertyValue);
}
/**
* @copydoc Internal::Actor::OnSizeSet
*/
- virtual void OnSizeSet(const Vector3& targetSize)
+ void OnSizeSet(const Vector3& targetSize) override
{
mImpl->OnSizeSet(targetSize);
}
/**
* @copydoc Internal::Actor::OnSizeAnimation
*/
- virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize)
+ void OnSizeAnimation(Animation& animation, const Vector3& targetSize) override
{
Dali::Animation animationHandle(&animation);
mImpl->OnSizeAnimation(animationHandle, targetSize);
/**
* @copydoc Internal::Actor::OnRelayout
*/
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
+ void OnRelayout( const Vector2& size, RelayoutContainer& container ) override
{
mImpl->OnRelayout( size, container );
}
/**
* @copydoc Internal::Actor::OnSetResizePolicy
*/
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+ void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) override
{
mImpl->OnSetResizePolicy( policy, dimension );
}
/**
* @copydoc Internal::Actor::GetNaturalSize
*/
- virtual Vector3 GetNaturalSize() const
+ Vector3 GetNaturalSize() const override
{
return mImpl->GetNaturalSize();
}
/**
* @copydoc Internal::Actor::CalculateChildSize
*/
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+ float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) override
{
return mImpl->CalculateChildSize( child, dimension );
}
/**
* @copydoc Internal::Actor::GetHeightForWidth
*/
- virtual float GetHeightForWidth( float width )
+ float GetHeightForWidth( float width ) override
{
return mImpl->GetHeightForWidth( width );
}
/**
* @copydoc Internal::Actor::GetWidthForHeight
*/
- virtual float GetWidthForHeight( float height )
+ float GetWidthForHeight( float height ) override
{
return mImpl->GetWidthForHeight( height );
}
/**
* @copydoc Internal::Actor::RelayoutDependentOnChildren
*/
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
+ bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) override
{
return mImpl->RelayoutDependentOnChildren( dimension );
}
/**
* @copydoc Internal::Actor::OnCalculateRelayoutSize
*/
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
+ void OnCalculateRelayoutSize( Dimension::Type dimension ) override
{
return mImpl->OnCalculateRelayoutSize( dimension );
}
/**
* @copydoc Internal::Actor::OnLayoutNegotiated
*/
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
+ void OnLayoutNegotiated( float size, Dimension::Type dimension ) override
{
return mImpl->OnLayoutNegotiated( size, dimension );
}
class Layer;
}
-typedef Dali::ClippingBox ClippingBox;
+using ClippingBox = Dali::ClippingBox;
class Layer : public Actor
{
/**
* @copydoc Dali::Internal::Actor::OnInitialize
*/
- void OnInitialize();
+ void OnInitialize() override;
/**
* Query the current depth of the layer
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Layer();
+ ~Layer() override;
private: // From Actor
/**
* From Actor.
*/
- virtual void OnSceneConnectionInternal();
+ void OnSceneConnectionInternal() override;
/**
* From Actor.
*/
- virtual void OnSceneDisconnectionInternal();
+ void OnSceneDisconnectionInternal() override;
private:
{
typedef std::vector<Layer*> LayerContainer;
-typedef LayerContainer::iterator LayerIter;
-typedef LayerContainer::reverse_iterator ReverseLayerIter;
+using LayerIter = LayerContainer::iterator;
+using ReverseLayerIter = LayerContainer::reverse_iterator;
/**
* A private helper template to return an iterator to the layer passed in.
Layer* mRoot; ///< The root layer that this ordered list of layers belong to
- typedef std::vector<Layer*> LayerContainer;
+ using LayerContainer = std::vector<Layer*>;
// Layers are not owned by the LayerList.
// Each layer is responsible for registering & unregistering before the end of its life-time.
class Object;
class Path;
-typedef IntrusivePtr<Animation> AnimationPtr;
-typedef std::vector<AnimationPtr> AnimationContainer;
+using AnimationPtr = IntrusivePtr<Animation>;
+using AnimationContainer = std::vector<AnimationPtr>;
-typedef AnimationContainer::iterator AnimationIter;
-typedef AnimationContainer::const_iterator AnimationConstIter;
+using AnimationIter = AnimationContainer::iterator;
+using AnimationConstIter = AnimationContainer::const_iterator;
/**
* Animation is a proxy for a SceneGraph::Animation object.
BETWEEN ///< Animating BETWEEN key-frames
};
- typedef Dali::Animation::EndAction EndAction;
- typedef Dali::Animation::Interpolation Interpolation;
+ using EndAction = Dali::Animation::EndAction;
+ using Interpolation = Dali::Animation::Interpolation;
/**
* Create a new Animation object.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Animation();
+ ~Animation() override;
private:
Dali::Animation::AnimationSignalType mProgressReachedSignal;
- typedef OwnerContainer< AnimatorConnectorBase* > AnimatorConnectorContainer;
+ using AnimatorConnectorContainer = OwnerContainer<AnimatorConnectorBase*>;
AnimatorConnectorContainer mConnectors; ///< Owned by the Animation
- typedef std::vector< ConnectorTargetValues > ConnectorTargetValuesContainer;
+ using ConnectorTargetValuesContainer = std::vector<ConnectorTargetValues>;
ConnectorTargetValuesContainer mConnectorTargetValues; //< Used to store animating property target value information
Vector2 mPlayRange;
class AnimationPlaylist;
-typedef OwnerPointer<AnimationPlaylist> AnimationPlaylistOwner;
+using AnimationPlaylistOwner = OwnerPointer<AnimationPlaylist>;
} // namespace Internal
/**
* Virtual destructor.
*/
- virtual ~AnimationPlaylist();
+ ~AnimationPlaylist() override;
/**
* Called when an animation is constructed.
/**
* @copydoc CompleteNotificationInterface::NotifyCompleted()
*/
- virtual void NotifyCompleted();
+ void NotifyCompleted() override;
private:
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnectorBase()
+ ~AnimatorConnectorBase() override
{
if( mObject )
{
/**
* From Object::Observer
*/
- virtual void SceneObjectAdded( Object& object ) override final
+ void SceneObjectAdded( Object& object ) final
{
// If the animator has not been created yet, create it now.
if( !mAnimator && mObject )
/**
* From Object::Observer
*/
- virtual void SceneObjectRemoved( Object& object ) override final
+ void SceneObjectRemoved( Object& object ) final
{
}
/**
* From Object::Observer
*/
- virtual void ObjectDestroyed( Object& object )
+ void ObjectDestroyed( Object& object ) override
{
mObject = nullptr;
}
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnector()
+ ~AnimatorConnector() override
{
}
/**
* @copydoc AnimatorConnectorBase::DoCreateAnimator()
*/
- bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) override final
+ bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) final
{
bool resetterRequired = false;
// components only supported for float property type
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnector()
+ ~AnimatorConnector() override
{
}
/**
* @copydoc AnimatorConnectorBase::DoCreateAnimator()
*/
- bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) override final
+ bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) final
{
bool resetterRequired = false;
if( mComponentIndex == Property::INVALID_COMPONENT_INDEX )
{
typedef Dali::Vector<Object*> ObjectContainer;
-typedef ObjectContainer::Iterator ObjectIter;
+using ObjectIter = ObjectContainer::Iterator;
/**
* An abstract base class for constrainers.
/**
* Virtual destructor.
*/
- virtual ~Constrainer();
+ ~Constrainer() override;
public: // Object::Observer methods
/**
* @copydoc Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object ){}
+ void SceneObjectAdded( Object& object ) override{}
/**
* @copydoc Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object ){}
+ void SceneObjectRemoved( Object& object ) override{}
/**
* @copydoc Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
public:
class EventThreadServices;
class Object;
-typedef Dali::Vector<Object*> ObjectContainer;
-typedef ObjectContainer::Iterator ObjectIter;
+using ObjectContainer = Dali::Vector<Object*>;
+using ObjectIter = ObjectContainer::Iterator;
namespace SceneGraph
{
class ConstraintBase : public BaseObject, public Object::Observer
{
public:
-
- typedef Dali::Constraint::RemoveAction RemoveAction;
+ using RemoveAction = Dali::Constraint::RemoveAction;
/**
* Constructor.
/**
* Virtual destructor.
*/
- virtual ~ConstraintBase();
+ ~ConstraintBase() override;
/**
* Adds a constraint source to the constraint
/**
* @copydoc Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object );
+ void SceneObjectAdded( Object& object ) override;
/**
* @copydoc Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object );
+ void SceneObjectRemoved( Object& object ) override;
/**
* @copydoc Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
// This is not responsible for removing constraints.
}
/**
* @copydoc ConstraintBase::DoClone()
*/
- ConstraintBase* DoClone( Object& object ) override final
+ ConstraintBase* DoClone( Object& object ) final
{
ConstraintFunctionPtr funcPtr( mUserFunction->Clone() );
return new Constraint( object,
/**
* @copydoc ConstraintBase::ConnectConstraint()
*/
- void ConnectConstraint() override final
+ void ConnectConstraint() final
{
// Should not come here if target object has been destroyed
DALI_ASSERT_DEBUG( nullptr != mTargetObject );
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
// This is not responsible for removing constraints.
}
/**
* @copydoc ConstraintBase::DoClone()
*/
- virtual ConstraintBase* DoClone( Object& object ) override final
+ ConstraintBase* DoClone( Object& object ) final
{
ConstraintFunctionPtr funcPtr( mUserFunction->Clone() );
return new Constraint( object,
/**
* @copydoc ConstraintBase::ConnectConstraint()
*/
- void ConnectConstraint() override final
+ void ConnectConstraint() final
{
// Should not come here if target object has been destroyed
DALI_ASSERT_DEBUG( nullptr != mTargetObject );
{
struct Source;
-typedef std::vector<Source> SourceContainer;
-typedef SourceContainer::iterator SourceIter;
+using SourceContainer = std::vector<Source>;
+using SourceIter = SourceContainer::iterator;
/**
* The source of an input property for a constraint.
class KeyFrameChannel : public KeyFrameChannelBase
{
public:
- typedef std::vector<ProgressValue<V> > ProgressValues;
+ using ProgressValues = std::vector<ProgressValue<V> >;
KeyFrameChannel(KeyFrameChannelId channel_id, ProgressValues& values )
: KeyFrameChannelBase(channel_id),
}
- virtual ~KeyFrameChannel()
+ ~KeyFrameChannel() override
{
}
- bool IsActive (float progress);
+ bool IsActive (float progress) override;
V GetValue(float progress, Dali::Animation::Interpolation interpolation) const;
return interpolatedV;
}
-typedef KeyFrameChannel<float> KeyFrameChannelNumber;
-typedef KeyFrameChannel<Vector2> KeyFrameChannelVector2;
-typedef KeyFrameChannel<Vector3> KeyFrameChannelVector3;
-typedef KeyFrameChannel<Vector4> KeyFrameChannelVector4;
-typedef KeyFrameChannel<Quaternion> KeyFrameChannelQuaternion;
-typedef KeyFrameChannel<AngleAxis> KeyFrameChannelAngleAxis;
-
+using KeyFrameChannelNumber = KeyFrameChannel<float>;
+using KeyFrameChannelVector2 = KeyFrameChannel<Vector2>;
+using KeyFrameChannelVector3 = KeyFrameChannel<Vector3>;
+using KeyFrameChannelVector4 = KeyFrameChannel<Vector4>;
+using KeyFrameChannelQuaternion = KeyFrameChannel<Quaternion>;
+using KeyFrameChannelAngleAxis = KeyFrameChannel<AngleAxis>;
} // Internal
} // namespace Dali
{
class KeyFrameSpec;
class KeyFrames;
-typedef IntrusivePtr<KeyFrames> KeyFramesPtr;
-
+using KeyFramesPtr = IntrusivePtr<KeyFrames>;
/**
* KeyFrames class is responsible for creating and building a specialized KeyFrame class
KeyFrames();
protected:
- virtual ~KeyFrames();
+ ~KeyFrames() override;
private:
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~KeyFrameSpec() {}
+ ~KeyFrameSpec() override {}
};
class KeyFrameBaseSpec : public KeyFrameSpec
{
private:
- typedef ProgressValue<V> PV;
- typedef std::vector<PV> PVContainer;
+ using PV = ProgressValue<V>;
+ using PVContainer = std::vector<PV>;
PVContainer mPVs; // The ProgressValue pairs
KeyFrameChannel<V>* mKeyFrames; // The key frame interpolator
/**
* Destructor. Ensure progress value pairs are cleared down
*/
- virtual ~KeyFrameBaseSpec<V>()
+ ~KeyFrameBaseSpec<V>() override
{
delete mKeyFrames;
mPVs.clear();
* Get the number of key frames
* @return The size of the progress value vector
*/
- virtual std::size_t GetNumberOfKeyFrames() const
+ std::size_t GetNumberOfKeyFrames() const override
{
return mPVs.size();
}
/**
* @copydoc KeyFrameSpec::GetKeyFrameAsValue()
*/
- virtual void GetKeyFrameAsValue( std::size_t index, Property::Value& value )
+ void GetKeyFrameAsValue( std::size_t index, Property::Value& value ) override
{
value = mPVs[index].mValue;
}
}
};
-typedef KeyFrameBaseSpec<float> KeyFrameNumber;
-typedef KeyFrameBaseSpec<bool> KeyFrameBoolean;
-typedef KeyFrameBaseSpec<int> KeyFrameInteger;
-typedef KeyFrameBaseSpec<Vector2> KeyFrameVector2;
-typedef KeyFrameBaseSpec<Vector3> KeyFrameVector3;
-typedef KeyFrameBaseSpec<Vector4> KeyFrameVector4;
-typedef KeyFrameBaseSpec<Quaternion> KeyFrameQuaternion;
-
-typedef IntrusivePtr<KeyFrameBoolean> KeyFrameBooleanPtr;
-typedef IntrusivePtr<KeyFrameNumber> KeyFrameNumberPtr;
-typedef IntrusivePtr<KeyFrameInteger> KeyFrameIntegerPtr;
-typedef IntrusivePtr<KeyFrameVector2> KeyFrameVector2Ptr;
-typedef IntrusivePtr<KeyFrameVector3> KeyFrameVector3Ptr;
-typedef IntrusivePtr<KeyFrameVector4> KeyFrameVector4Ptr;
-typedef IntrusivePtr<KeyFrameQuaternion> KeyFrameQuaternionPtr;
-
+using KeyFrameNumber = KeyFrameBaseSpec<float>;
+using KeyFrameBoolean = KeyFrameBaseSpec<bool>;
+using KeyFrameInteger = KeyFrameBaseSpec<int>;
+using KeyFrameVector2 = KeyFrameBaseSpec<Vector2>;
+using KeyFrameVector3 = KeyFrameBaseSpec<Vector3>;
+using KeyFrameVector4 = KeyFrameBaseSpec<Vector4>;
+using KeyFrameQuaternion = KeyFrameBaseSpec<Quaternion>;
+
+using KeyFrameBooleanPtr = IntrusivePtr<KeyFrameBoolean>;
+using KeyFrameNumberPtr = IntrusivePtr<KeyFrameNumber>;
+using KeyFrameIntegerPtr = IntrusivePtr<KeyFrameInteger>;
+using KeyFrameVector2Ptr = IntrusivePtr<KeyFrameVector2>;
+using KeyFrameVector3Ptr = IntrusivePtr<KeyFrameVector3>;
+using KeyFrameVector4Ptr = IntrusivePtr<KeyFrameVector4>;
+using KeyFrameQuaternionPtr = IntrusivePtr<KeyFrameQuaternion>;
inline void GetSpecialization(Internal::KeyFrames& keyFrames, Internal::KeyFrameBoolean*& keyFrameSpec)
{
/**
* virtual destructor
*/
- virtual ~LinearConstrainer();
+ ~LinearConstrainer() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
public:
/**
* @copydoc Dali::PathConstrainer::Apply
*/
- void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap );
+ void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap ) override;
private:
/**
* virtual destructor
*/
- virtual ~PathConstrainer();
+ ~PathConstrainer() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
public:
/**
* @copydoc Dali::PathConstrainer::Apply
*/
- void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap );
+ void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap ) override;
private:
namespace Internal
{
-typedef IntrusivePtr<Path> PathPtr;
+using PathPtr = IntrusivePtr<Path>;
/**
* A 3D path
/**
* virtual destructor
*/
- virtual ~Path();
+ ~Path() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
public:
template <class P>
struct PropertyConstraintPtr
{
- typedef OwnerPointer< PropertyConstraint<P> > Type;
+ using Type = OwnerPointer<PropertyConstraint<P> >;
};
} // namespace Internal
/**
* Virtual Destructor
*/
- virtual ~PropertyInputIndexer()
+ ~PropertyInputIndexer() override
{
}
/**
* @copydoc Dali::Internal::PropertyInput::GetType()
*/
- virtual Property::Type GetType() const
+ Property::Type GetType() const override
{
return mInput->GetType();
}
/**
* @copydoc Dali::Internal::PropertyInput::GetBoolean()
*/
- virtual const bool& GetBoolean() const
+ const bool& GetBoolean() const override
{
return mInput->GetConstraintInputBoolean( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetInteger()
*/
- virtual const int& GetInteger() const
+ const int& GetInteger() const override
{
return mInput->GetConstraintInputInteger( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetFloat()
*/
- virtual const float& GetFloat() const
+ const float& GetFloat() const override
{
return mInput->GetConstraintInputFloat( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2() const
+ const Vector2& GetVector2() const override
{
return mInput->GetConstraintInputVector2( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3() const
+ const Vector3& GetVector3() const override
{
return mInput->GetConstraintInputVector3( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4() const
+ const Vector4& GetVector4() const override
{
return mInput->GetConstraintInputVector4( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetMatrix3()
*/
- virtual const Matrix3& GetMatrix3() const
+ const Matrix3& GetMatrix3() const override
{
return mInput->GetConstraintInputMatrix3( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetMatrix()
*/
- virtual const Matrix& GetMatrix() const
+ const Matrix& GetMatrix() const override
{
return mInput->GetConstraintInputMatrix( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::Quaternion()
*/
- virtual const Quaternion& GetQuaternion() const
+ const Quaternion& GetQuaternion() const override
{
return mInput->GetConstraintInputQuaternion( mBufferIndex );
}
}
}
-typedef Dali::Mutex MessageQueueMutex;
-typedef OwnerContainer< MessageBase* > MessageContainer;
+using MessageQueueMutex = Dali::Mutex;
+using MessageContainer = OwnerContainer<MessageBase*>;
struct NotificationManager::Impl
{
class ObjectConnector
{
public:
- typedef IntrusivePtr<Object> ObjectPtr;
+ using ObjectPtr = IntrusivePtr<Object>;
/**
* @brief Default constructor.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Object();
+ ~Object() override;
/**
* Called immediately by derived classes, after the scene-object has been created & passed to the scene-graph.
class ObjectRegistry;
-typedef IntrusivePtr<ObjectRegistry> ObjectRegistryPtr;
+using ObjectRegistryPtr = IntrusivePtr<ObjectRegistry>;
/**
* The ObjectRegistry notifies it's observers when an object is created.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- ~ObjectRegistry();
+ ~ObjectRegistry() override;
private:
/**
* Virtual destructor
*/
- virtual ~PropertyCondition();
+ ~PropertyCondition() override;
private:
/**
* @brief Destructor.
*/
- virtual ~AnimatablePropertyMetadata()
+ ~AnimatablePropertyMetadata() override
{
}
/**
* @brief Destructor.
*/
- virtual ~CustomPropertyMetadata()
+ ~CustomPropertyMetadata() override
{
}
class Object;
class PropertyNotificationManager;
-typedef IntrusivePtr<PropertyNotification> PropertyNotificationPtr;
+using PropertyNotificationPtr = IntrusivePtr<PropertyNotification>;
/**
* PropertyNotification is a proxy for a SceneGraph::PropertyNotification object.
class PropertyNotification : public BaseObject
{
public:
-
- typedef Dali::PropertyNotification::NotifyMode NotifyMode;
- typedef PropertyCondition::Type ConditionType;
+ using NotifyMode = Dali::PropertyNotification::NotifyMode;
+ using ConditionType = PropertyCondition::Type;
/**
* RawArgumentContainer provides fast direct access to arguments for condition evaluation.
*/
- typedef Dali::Vector<float> RawArgumentContainer;
+ using RawArgumentContainer = Dali::Vector<float>;
/**
* Create a new PropertyNotification object.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PropertyNotification();
+ ~PropertyNotification() override;
private:
/**
* Virtual destructor.
*/
- virtual ~PropertyNotificationManager();
+ ~PropertyNotificationManager() override;
/**
* Called when a PropertyNotification is constructed.
/**
* @copydoc PropertyNotifier::NotifyProperty
*/
- virtual void NotifyProperty( SceneGraph::PropertyNotification* propertyNotification, bool validity );
+ void NotifyProperty( SceneGraph::PropertyNotification* propertyNotification, bool validity ) override;
private:
/**
* virtual destructor
*/
- virtual ~Scene();
+ ~Scene() override;
/**
* @copydoc Dali::Integration::Scene::Add
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() override;
private:
class Stage;
-typedef Stage* StagePtr;
+using StagePtr = Stage *;
} // Internal
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() override;
// Layers
/**
* @copydoc Dali::Integration::NotifyContextLost();
*/
- virtual void NotifyContextLost();
+ void NotifyContextLost() override;
/**
* @copydoc Dali::Integration::NotifyContextRegained();
*/
- virtual void NotifyContextRegained();
+ void NotifyContextRegained() override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Stage();
+ ~Stage() override;
private:
/**
* Virtual Destructor
*/
- virtual ~ThreadLocalStorage();
+ ~ThreadLocalStorage() override;
// Undefined
ThreadLocalStorage( const ThreadLocalStorage& );
// using the address of the type name string as compiler will allocate these once per library
// and we don't support un/re-loading of dali libraries while singleton service is alive
- typedef std::pair< const char*, BaseHandle> SingletonPair;
- typedef std::vector< SingletonPair > SingletonContainer;
- typedef SingletonContainer::const_iterator SingletonConstIter;
+ using SingletonPair = std::pair<const char*, BaseHandle>;
+ using SingletonContainer = std::vector<SingletonPair>;
+ using SingletonConstIter = SingletonContainer::const_iterator;
SingletonContainer mSingletonContainer; ///< The container to look up singleton by its type name
/**
* Destructor
*/
- virtual ~TypeInfo();
+ ~TypeInfo() override;
/**
* @copydoc Dali::TypeInfo::GetName
int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;
};
- typedef std::pair<std::string, Dali::TypeInfo::SignalConnectorFunction > ConnectionPair;
- typedef std::pair<std::string, Dali::TypeInfo::ActionFunction > ActionPair;
- typedef std::pair<Property::Index, RegisteredProperty> RegisteredPropertyPair;
- typedef std::pair<Property::Index, Property::Value> PropertyDefaultValuePair;
+ using ConnectionPair = std::pair<std::string, Dali::TypeInfo::SignalConnectorFunction>;
+ using ActionPair = std::pair<std::string, Dali::TypeInfo::ActionFunction>;
+ using RegisteredPropertyPair = std::pair<Property::Index, RegisteredProperty>;
+ using PropertyDefaultValuePair = std::pair<Property::Index, Property::Value>;
- typedef std::vector< ActionPair > ActionContainer;
- typedef std::vector< ConnectionPair > ConnectorContainer;
- typedef std::vector< RegisteredPropertyPair > RegisteredPropertyContainer;
- typedef std::vector< PropertyDefaultValuePair > PropertyDefaultValueContainer;
+ using ActionContainer = std::vector<ActionPair>;
+ using ConnectorContainer = std::vector<ConnectionPair>;
+ using RegisteredPropertyContainer = std::vector<RegisteredPropertyPair>;
+ using PropertyDefaultValueContainer = std::vector<PropertyDefaultValuePair>;
/**
* Append properties from registeredProperties onto indices.
private:
TypeRegistry();
- ~TypeRegistry();
+ ~TypeRegistry() override;
/**
* @brief Undefined Copy Constructor
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* @brief ShaderFactory loads and saves shader binaries synchronously.
/**
* Destructor
*/
- virtual ~ShaderFactory();
+ ~ShaderFactory() override;
/**
* @brief Looks for precompiled binary version of shader program in memory and file caches.
* @param[in] shader The data to be saved.
* @sa Load
*/
- virtual void SaveBinary( Internal::ShaderDataPtr shader );
+ void SaveBinary( Internal::ShaderDataPtr shader ) override;
private:
/**
* Non virtual destructor
*/
- ~ActorObserver();
+ ~ActorObserver() override;
// Movable
* @param[in] object The object object.
* @see Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object );
+ void SceneObjectAdded( Object& object ) override;
/**
* This will be called when the actor is removed from the scene.
* @param[in] object The object object.
* @see Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object );
+ void SceneObjectRemoved( Object& object ) override;
/**
* This will be called when the actor is destroyed. We should clear the actor.
* No need to stop observing as the object is being destroyed anyway.
* @see Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
private:
Actor* mActor; ///< Raw pointer to an Actor.
case Event::Hover:
{
- typedef Integration::HoverEvent DerivedType;
+ using DerivedType = Integration::HoverEvent;
// Reserve some memory inside the message queue
uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
case Event::Key:
{
- typedef Integration::KeyEvent DerivedType;
+ using DerivedType = Integration::KeyEvent;
// Reserve some memory inside the message queue
uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
case Event::Wheel:
{
- typedef Integration::WheelEvent DerivedType;
+ using DerivedType = Integration::WheelEvent;
// Reserve some memory inside the message queue
uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
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 >
struct DerivedGestureDetectorContainer
{
- typedef std::vector<Detector*> type;
+ using type = std::vector<Detector*>;
};
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~GestureDetector();
+ ~GestureDetector() override;
private:
/**
* @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.
{
class Gesture;
-typedef IntrusivePtr<Gesture> GesturePtr;
+using GesturePtr = IntrusivePtr<Gesture>;
/**
* This is the abstract base structure for any gestures that the adaptor detects and wishes to send
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Gesture() = default;
+ ~Gesture() override = default;
private:
GestureType::Value mGestureType;
{
}
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->IsGestureRequired( mType ) && // Does the Application or derived actor type require the gesture?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsTouchConsumed();
}
/**
* Virtual protected destructor.
*/
- virtual ~GestureProcessor();
+ ~GestureProcessor() override;
// Methods to be used by deriving classes
* @param[in] object The object object.
* @see Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded(Object& object) { }
+ void SceneObjectAdded(Object& object) override { }
/**
* This will be called when the actor is removed from the stage, we should clear and stop
* @param[in] object The object object.
* @see Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved(Object& object);
+ void SceneObjectRemoved(Object& object) override;
/**
* This will be called when the actor is destroyed. We should clear the actor.
* No need to stop observing as the object is being destroyed anyway.
* @see Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed(Object& object);
+ void ObjectDestroyed(Object& object) override;
protected: //Data
/**
* Virtual destructor.
*/
- virtual ~GestureRecognizer() {}
+ ~GestureRecognizer() override {}
protected:
Vector2 mScreenSize;
Scene* mScene;
};
-typedef IntrusivePtr<GestureRecognizer> GestureRecognizerPtr;
+using GestureRecognizerPtr = IntrusivePtr<GestureRecognizer>;
} // namespace Internal
/**
* Virtual destructor
*/
- virtual ~PanGestureRequest()
+ ~PanGestureRequest() override
{
}
/**
* Virtual destructor
*/
- virtual ~TapGestureRequest()
+ ~TapGestureRequest() override
{
}
/**
* Virtual destructor
*/
- virtual ~LongPressGestureRequest()
+ ~LongPressGestureRequest() override
{
}
{
}
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::CHECK_ACTOR );
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE );
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
// Layer::IsTouchConsumed() focuses on touch only. Here we are a wrapper for the public-api
// where the caller may want to check for something completely different.
*/
struct ActorTouchableCheck : public HitTestInterface
{
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->GetTouchRequired() && // Does the Application or derived actor type require a touch event?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsTouchConsumed();
}
{
class HoverEvent;
-typedef IntrusivePtr< HoverEvent > HoverEventPtr;
+using HoverEventPtr = IntrusivePtr<HoverEvent>;
/**
* @copydoc Dali::HoverEvent
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~HoverEvent() = default;
+ ~HoverEvent() override = default;
// Not copyable or movable
*/
struct ActorHoverableCheck : public HitTestAlgorithm::HitTestInterface
{
- bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->GetHoverRequired() && // Does the Application or derived actor type require a hover event?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsHoverConsumed();
}
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~KeyEvent() = default;
+ ~KeyEvent() override = default;
// Not copyable or movable
class LongPressGestureDetector;
-typedef IntrusivePtr<LongPressGestureDetector> LongPressGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<LongPressGestureDetector>::type LongPressGestureDetectorContainer;
+using LongPressGestureDetectorPtr = IntrusivePtr<LongPressGestureDetector>;
+using LongPressGestureDetectorContainer = DerivedGestureDetectorContainer<LongPressGestureDetector>::type;
/**
* @copydoc Dali::LongPressGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~LongPressGestureDetector();
+ ~LongPressGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~LongPressGestureEvent();
+ ~LongPressGestureEvent() override;
// Data
{
class LongPressGesture;
-typedef IntrusivePtr< LongPressGesture > LongPressGesturePtr;
+using LongPressGesturePtr = IntrusivePtr<LongPressGesture>;
/**
* @copydoc Dali::LongPressGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~LongPressGesture() = default;
+ ~LongPressGesture() override = default;
private:
Vector2 mScreenPoint;
/**
* Non-virtual destructor; LongPressGestureProcessor is not a base class
*/
- ~LongPressGestureProcessor();
+ ~LongPressGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the long press gesture event occurs in.
* @param[in] longPressEvent The event that has occurred.
*/
- void Process( Scene& scene, const LongPressGestureEvent& longPressEvent );
+ void Process( Scene& scene, const LongPressGestureEvent& longPressEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~LongPressGestureRecognizer();
+ ~LongPressGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
/**
* @brief This method sets the minimum holding time required to be recognized as a long press gesture
{
class PanGestureDetector;
-typedef IntrusivePtr<PanGestureDetector> PanGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<PanGestureDetector>::type PanGestureDetectorContainer;
+using PanGestureDetectorPtr = IntrusivePtr<PanGestureDetector>;
+using PanGestureDetectorContainer = DerivedGestureDetectorContainer<PanGestureDetector>::type;
namespace SceneGraph
{
class PanGestureDetector : public GestureDetector
{
public: // Typedefs
-
- typedef Dali::PanGestureDetector::AngleThresholdPair AngleThresholdPair;
- typedef std::vector<AngleThresholdPair> AngleContainer;
+ using AngleThresholdPair = Dali::PanGestureDetector::AngleThresholdPair;
+ using AngleContainer = std::vector<AngleThresholdPair>;
public: // Creation
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PanGestureDetector();
+ ~PanGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
// Default property extensions from Object
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
private:
/**
* Virtual destructor
*/
- virtual ~PanGestureEvent();
+ ~PanGestureEvent() override;
// Data
{
class PanGesture;
-typedef IntrusivePtr< PanGesture > PanGesturePtr;
+using PanGesturePtr = IntrusivePtr<PanGesture>;
/**
* @copydoc Dali::PanGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PanGesture() = default;
+ ~PanGesture() override = default;
private:
Vector2 mVelocity;
/**
* Destructor
*/
- virtual ~PanGestureProcessor();
+ ~PanGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the pan gesture event occurs in.
* @param[in] panEvent The event that has occurred.
*/
- void Process( Scene& scene, const PanGestureEvent& panEvent );
+ void Process( Scene& scene, const PanGestureEvent& panEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~PanGestureRecognizer();
+ ~PanGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
class PinchGestureDetector;
-typedef IntrusivePtr<PinchGestureDetector> PinchGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<PinchGestureDetector>::type PinchGestureDetectorContainer;
+using PinchGestureDetectorPtr = IntrusivePtr<PinchGestureDetector>;
+using PinchGestureDetectorContainer = DerivedGestureDetectorContainer<PinchGestureDetector>::type;
/**
* @copydoc Dali::PinchGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PinchGestureDetector();
+ ~PinchGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~PinchGestureEvent();
+ ~PinchGestureEvent() override;
// Data
{
class PinchGesture;
-typedef IntrusivePtr< PinchGesture > PinchGesturePtr;
+using PinchGesturePtr = IntrusivePtr<PinchGesture>;
/**
* @copydoc Dali::PinchGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PinchGesture() = default;
+ ~PinchGesture() override = default;
private:
Vector2 mScreenCenterPoint;
/**
* Non-virtual destructor; PinchGestureProcessor is not a base class
*/
- ~PinchGestureProcessor();
+ ~PinchGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the pinch gesture event occurs in.
* @param[in] pinchEvent The event that has occurred.
*/
- void Process( Scene& scene, const PinchGestureEvent& pinchEvent );
+ void Process( Scene& scene, const PinchGestureEvent& pinchEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~PinchGestureRecognizer();
+ ~PinchGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
class RotationGestureDetector;
-typedef IntrusivePtr<RotationGestureDetector> RotationGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<RotationGestureDetector>::type RotationGestureDetectorContainer;
+using RotationGestureDetectorPtr = IntrusivePtr<RotationGestureDetector>;
+using RotationGestureDetectorContainer = DerivedGestureDetectorContainer<RotationGestureDetector>::type;
/**
* @copydoc Dali::RotationGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RotationGestureDetector() = default;
+ ~RotationGestureDetector() override = default;
private: // GestureDetector overrides
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach( Actor& actor ) { /* Nothing to do */ }
+ void OnActorAttach( Actor& actor ) override { /* Nothing to do */ }
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach( Actor& actor ) { /* Nothing to do */ }
+ void OnActorDetach( Actor& actor ) override { /* Nothing to do */ }
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed( Object& object ) { /* Nothing to do */ }
+ void OnActorDestroyed( Object& object ) override { /* Nothing to do */ }
private:
/**
* Virtual destructor
*/
- virtual ~RotationGestureEvent() = default;
+ ~RotationGestureEvent() override = default;
// Data
{
class RotationGesture;
-typedef IntrusivePtr< RotationGesture > RotationGesturePtr;
+using RotationGesturePtr = IntrusivePtr<RotationGesture>;
/**
* @copydoc Dali::RotationGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RotationGesture() = default;
+ ~RotationGesture() override = default;
private:
Radian mRotation;
/**
* Non-virtual destructor; RotationGestureProcessor is not a base class
*/
- ~RotationGestureProcessor() = default;
+ ~RotationGestureProcessor() override = default;
RotationGestureProcessor( const RotationGestureProcessor& ) = delete; ///< Deleted copy constructor.
RotationGestureProcessor& operator=( const RotationGestureProcessor& rhs ) = delete; ///< Deleted copy assignment operator.
* @param[in] scene The scene the rotation gesture event occurs in.
* @param[in] rotationEvent The event that has occurred.
*/
- void Process( Scene& scene, const RotationGestureEvent& rotationEvent );
+ void Process( Scene& scene, const RotationGestureEvent& rotationEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~RotationGestureRecognizer() = default;
+ ~RotationGestureRecognizer() override = default;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent( const Integration::TouchEvent& event );
+ void SendEvent( const Integration::TouchEvent& event ) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update( const GestureRequest& request ) { /* Nothing to do */ }
+ void Update( const GestureRequest& request ) override { /* Nothing to do */ }
/**
* Sets the minimum touch events required before a rotation can be started
class TapGestureDetector;
-typedef IntrusivePtr<TapGestureDetector> TapGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<TapGestureDetector>::type TapGestureDetectorContainer;
+using TapGestureDetectorPtr = IntrusivePtr<TapGestureDetector>;
+using TapGestureDetectorContainer = DerivedGestureDetectorContainer<TapGestureDetector>::type;
/**
* @copydoc Dali::TapGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TapGestureDetector();
+ ~TapGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~TapGestureEvent();
+ ~TapGestureEvent() override;
// Data
{
class TapGesture;
-typedef IntrusivePtr< TapGesture > TapGesturePtr;
+using TapGesturePtr = IntrusivePtr<TapGesture>;
/**
* @copydoc Dali::TapGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TapGesture() = default;
+ ~TapGesture() override = default;
private:
Vector2 mScreenPoint;
/**
* Non-virtual destructor; TapGestureProcessor is not a base class
*/
- ~TapGestureProcessor();
+ ~TapGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the tap gesture event occurs in.
* @param[in] tapEvent The event that has occurred.
*/
- void Process( Scene& scene, const TapGestureEvent& event);
+ void Process( Scene& scene, const TapGestureEvent& event) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection() { /* Nothing to do */ }
+ void OnGesturedActorStageDisconnection() override { /* Nothing to do */ }
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~TapGestureRecognizer();
+ ~TapGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
{
class TouchEvent;
-typedef IntrusivePtr< TouchEvent > TouchEventPtr;
+using TouchEventPtr = IntrusivePtr<TouchEvent>;
/**
* @copydoc Dali::TouchEvent
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TouchEvent() = default;
+ ~TouchEvent() override = default;
private:
{
class WheelEvent;
-typedef IntrusivePtr< WheelEvent > WheelEventPtr;
+using WheelEventPtr = IntrusivePtr<WheelEvent>;
/**
* @copydoc Dali::WheelEvent
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~WheelEvent() = default;
+ ~WheelEvent() override = default;
// Not copyable or movable
{
class BitmapCompressed;
-typedef IntrusivePtr<BitmapCompressed> BitmapCompressedPtr;
+using BitmapCompressedPtr = IntrusivePtr<BitmapCompressed>;
/**
* BitmapCompressed class.
*/
BitmapCompressed( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN );
- virtual const Bitmap::CompressedProfile* GetCompressedProfile() const { return this; }
- virtual Bitmap::CompressedProfile* GetCompressedProfile() { return this; }
+ const Bitmap::CompressedProfile* GetCompressedProfile() const override { return this; }
+ Bitmap::CompressedProfile* GetCompressedProfile() override { return this; }
private:
/**
* @param[in] bufferSize Buffer size in bytes
* @return pixel buffer pointer
*/
- virtual Dali::Integration::PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
+ Dali::Integration::PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
const uint32_t width,
const uint32_t height,
- const uint32_t numBytes );
+ const uint32_t numBytes ) override;
/**
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
*/
- virtual uint32_t GetBufferSize() const
+ uint32_t GetBufferSize() const override
{
return mBufferSize;
}
/**
* See Dali::Integration::Bitmap::GetReleaseFunction()
*/
- ReleaseFunction GetReleaseFunction(){ return FREE; }
+ ReleaseFunction GetReleaseFunction() override{ return FREE; }
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~BitmapCompressed();
+ ~BitmapCompressed() override;
private:
{
class BitmapPackedPixel;
-typedef IntrusivePtr<BitmapPackedPixel> BitmapPackedPixelPtr;
+using BitmapPackedPixelPtr = IntrusivePtr<BitmapPackedPixel>;
/**
* BitmapPackedPixel class.
BitmapPackedPixel( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
public:
- virtual const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const { return this; }
- virtual Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() { return this; }
+ const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const override { return this; }
+ Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() override { return this; }
/**
* (Re-)Allocate pixel buffer for the Bitmap. Any previously allocated pixel buffer is deleted.
* @param[in] bufferHeight Buffer height in pixels
* @return pixel buffer pointer
*/
- virtual Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
+ Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
uint32_t width,
uint32_t height,
uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0);
+ uint32_t bufferHeight = 0) override;
/**
* Assign a pixel buffer. Any previously allocated pixel buffer is deleted.
* @param[in] bufferWidth Buffer width (stride) in pixels
* @param[in] bufferHeight Buffer height in pixels
*/
- virtual void AssignBuffer(Pixel::Format pixelFormat,
+ void AssignBuffer(Pixel::Format pixelFormat,
Dali::Integration::PixelBuffer* buffer,
uint32_t bufferSize,
uint32_t width,
uint32_t height,
uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0);
+ uint32_t bufferHeight = 0) override;
/**
* Get the width of the buffer (stride)
* @return The width of the buffer in pixels
*/
- virtual unsigned GetBufferWidth() const
+ unsigned GetBufferWidth() const override
{
return mBufferWidth;
}
* Get the height of the buffer
* @return The height of the buffer in pixels
*/
- virtual unsigned GetBufferHeight() const
+ unsigned GetBufferHeight() const override
{
return mBufferHeight;
}
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
*/
- virtual uint32_t GetBufferSize() const
+ uint32_t GetBufferSize() const override
{
return mBufferWidth * mBytesPerPixel * mBufferHeight;
}
/**
* See Dali::Integration::Bitmap::GetReleaseFunction()
*/
- ReleaseFunction GetReleaseFunction(){ return FREE; }
+ ReleaseFunction GetReleaseFunction() override{ return FREE; }
/**
* Get the pixel buffer stride.
* @return The buffer stride (in bytes).
*/
- virtual uint32_t GetBufferStride() const;
+ uint32_t GetBufferStride() const override;
/**
* Get the pixel format
* Check the bitmap data and test whether it has any transparent pixels.
* This property can then be tested for with IsFullyOpaque().
*/
- virtual void TestForTransparency();
+ void TestForTransparency() override;
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~BitmapPackedPixel();
+ ~BitmapPackedPixel() override;
protected:
{
class PixelData;
-typedef IntrusivePtr<PixelData> PixelDataPtr;
+using PixelDataPtr = IntrusivePtr<PixelData>;
class PixelData : public BaseObject
{
*
* Release the pixel buffer if exists.
*/
- ~PixelData();
+ ~PixelData() override;
public:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
public: //signals
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RenderTask();
+ ~RenderTask() override;
private: // not copyable
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RenderTaskList();
+ ~RenderTaskList() override;
/**
* 2nd-phase construction
/**
* @copydoc CompleteNotificationInterface::NotifyCompleted()
*/
- virtual void NotifyCompleted();
+ void NotifyCompleted() override;
private:
}
class FrameBuffer;
-typedef IntrusivePtr<FrameBuffer> FrameBufferPtr;
+using FrameBufferPtr = IntrusivePtr<FrameBuffer>;
class FrameBuffer : public BaseObject
{
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~FrameBuffer();
+ ~FrameBuffer() override;
/**
* @brief Get the FrameBuffer render object
}
class Geometry;
-typedef IntrusivePtr<Geometry> GeometryPtr;
+using GeometryPtr = IntrusivePtr<Geometry>;
/**
* Geometry is an object that contains an array of structures of values that
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Geometry();
+ ~Geometry() override;
private: // unimplemented methods
Geometry( const Geometry& );
}
class Renderer;
-typedef IntrusivePtr<Renderer> RendererPtr;
+using RendererPtr = IntrusivePtr<Renderer>;
/**
* Renderer is an object that can be used to show content by combining a Geometry with a shader and textures.
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @brief Adds a draw command to the Renderer.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Renderer();
+ ~Renderer() override;
private: // unimplemented methods
Renderer( const Renderer& );
}
class Sampler;
-typedef IntrusivePtr<Sampler> SamplerPtr;
+using SamplerPtr = IntrusivePtr<Sampler>;
/**
* Sampler is an object that contains an array of structures of values that
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Sampler();
+ ~Sampler() override;
private: // data
EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via the update thread
}
class Shader;
-typedef IntrusivePtr<Shader> ShaderPtr;
+using ShaderPtr = IntrusivePtr<Shader>;
/**
* Shader is an object that contains an array of structures of values that
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
private: // implementation
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Shader();
+ ~Shader() override;
private: // unimplemented methods
}
class Texture;
-typedef IntrusivePtr<Texture> TexturePtr;
+using TexturePtr = IntrusivePtr<Texture>;
class Texture : public BaseObject
{
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Texture();
+ ~Texture() override;
private: // unimplemented methods
Texture( const Texture& );
class TextureSet;
-typedef IntrusivePtr<TextureSet> TextureSetPtr;
+using TextureSetPtr = IntrusivePtr<TextureSet>;
/**
* TextureSet is an object that holds all the textures used by a renderer
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TextureSet();
+ ~TextureSet() override;
private: // unimplemented methods
TextureSet( const TextureSet& );
{
class VertexBuffer;
-typedef IntrusivePtr<VertexBuffer> VertexBufferPtr;
+using VertexBufferPtr = IntrusivePtr<VertexBuffer>;
/**
* VertexBuffer is an object that contains an array of structures of values that
/**
* @brief Destructor
*/
- ~VertexBuffer();
+ ~VertexBuffer() override;
private: // implementation
/**
{
// typedef ... Type; not defined, only support types declared below
};
-template<> struct PropertyImplementationType< Property::BOOLEAN > { typedef bool Type; };
-template<> struct PropertyImplementationType< Property::FLOAT > { typedef float Type; };
-template<> struct PropertyImplementationType< Property::INTEGER > { typedef int Type; };
-template<> struct PropertyImplementationType< Property::VECTOR2 > { typedef Vector2 Type; };
-template<> struct PropertyImplementationType< Property::VECTOR3 > { typedef Vector3 Type; };
-template<> struct PropertyImplementationType< Property::VECTOR4 > { typedef Vector4 Type; };
-template<> struct PropertyImplementationType< Property::MATRIX3 > { typedef Matrix3 Type; };
-template<> struct PropertyImplementationType< Property::MATRIX > { typedef Matrix Type; };
-template<> struct PropertyImplementationType< Property::RECTANGLE > { typedef Rect<int> Type; };
-template<> struct PropertyImplementationType< Property::ROTATION > { typedef Quaternion Type; };
+template<>
+struct PropertyImplementationType<Property::BOOLEAN>
+{
+ using Type = bool;
+};
+template<>
+struct PropertyImplementationType<Property::FLOAT>
+{
+ using Type = float;
+};
+template<>
+struct PropertyImplementationType<Property::INTEGER>
+{
+ using Type = int;
+};
+template<>
+struct PropertyImplementationType<Property::VECTOR2>
+{
+ using Type = Vector2;
+};
+template<>
+struct PropertyImplementationType<Property::VECTOR3>
+{
+ using Type = Vector3;
+};
+template<>
+struct PropertyImplementationType<Property::VECTOR4>
+{
+ using Type = Vector4;
+};
+template<>
+struct PropertyImplementationType<Property::MATRIX3>
+{
+ using Type = Matrix3;
+};
+template<>
+struct PropertyImplementationType<Property::MATRIX>
+{
+ using Type = Matrix;
+};
+template<>
+struct PropertyImplementationType<Property::RECTANGLE>
+{
+ using Type = Rect<int>;
+};
+template<>
+struct PropertyImplementationType<Property::ROTATION>
+{
+ using Type = Quaternion;
+};
uint32_t GetPropertyImplementationSize( Property::Type& propertyType );
/**
* Virtual destructor
*/
- virtual ~MemoryPoolRelayoutContainer();
+ ~MemoryPoolRelayoutContainer() override;
/**
* @brief Add relayout information to the container if it does'nt already exist
* @param actor The actor to relayout
* @param size The size to relayout
*/
- virtual void Add( const Dali::Actor& actor, const Vector2& size );
+ void Add( const Dali::Actor& actor, const Vector2& size ) override;
/**
* @brief Remove information from the container
bool Contains( const Dali::Actor& actor );
private:
-
- typedef Vector< RelayoutInfo* > RelayoutInfoContainer;
+ using RelayoutInfoContainer = Vector<RelayoutInfo*>;
RelayoutInfoContainer mRelayoutInfos; ///< The list of relayout infos
/**
* Destructor
*/
- virtual ~RelayoutController();
+ ~RelayoutController() override;
/**
* @brief Get the singleton of RelayoutController object.
namespace Dali
{
-
-typedef Rect<int> ClippingBox;
+using ClippingBox = Rect<int>;
namespace Internal
{
class Layer;
-typedef OwnerContainer< RenderItem* > RenderItemContainer;
+using RenderItemContainer = OwnerContainer<RenderItem*>;
struct RenderList;
-typedef OwnerContainer< RenderList* > RenderListContainer;
+using RenderListContainer = OwnerContainer<RenderList*>;
/**
* The RenderList structure provides the renderer with a list of renderers.
/**
* @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMapChanged()
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const = 0;
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override = 0;
/**
* @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMap()
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const = 0;
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override = 0;
protected:
/**
* Virtual destructor, this is an interface, no deletion through this interface
*/
- virtual ~NodeDataProvider() { }
+ ~NodeDataProvider() override { }
};
} // SceneGraph
class RenderDataProvider
{
public:
- typedef std::vector< Render::Sampler* > Samplers;
+ using Samplers = std::vector<Render::Sampler*>;
/**
* Constructor.
class UniformMap;
class UniformPropertyMapping;
-typedef Dali::Vector< const UniformPropertyMapping* > CollectedUniformMap;
+using CollectedUniformMap = Dali::Vector<const UniformPropertyMapping*>;
/**
* This class maps uniform names to property value pointers.
unsigned int mState; ///< State, bitmask of FrameBufferStatus flags
};
- typedef Dali::Vector< FrameBufferState > FrameBufferStateVector;
+ using FrameBufferStateVector = Dali::Vector<FrameBufferState>;
/**
* @brief Set the clear state
class Geometry
{
public:
- typedef Dali::Geometry::Type Type;
+ using Type = Dali::Geometry::Type;
Geometry();
return true;
}
- std::vector<Render::Texture*> textures = mRenderDataProvider->GetTextures();
- for (Render::Texture* texture : textures)
+ for( const auto& texture : mRenderDataProvider->GetTextures() )
{
if (texture && texture->IsNativeImage())
{
/**
* @copydoc Dali::Internal::GlResourceOwner::GlContextDestroyed()
*/
- void GlContextDestroyed();
+ void GlContextDestroyed() override;
/**
* @copydoc Dali::Internal::GlResourceOwner::GlCleanup()
*/
- void GlCleanup();
+ void GlCleanup() override;
/**
* Create a new renderer instance
/**
* Destructor
*/
- ~Renderer();
+ ~Renderer() override;
/**
* Set the face-culling mode.
const PropertyInputImpl* propertyValue;
};
- typedef Dali::Vector< UniformIndexMap > UniformIndexMappings;
+ using UniformIndexMappings = Dali::Vector<UniformIndexMap>;
UniformIndexMappings mUniformIndexMap;
Vector<GLint> mAttributesLocation;
struct Sampler
{
-
- typedef Dali::FilterMode::Type FilterMode;
- typedef Dali::WrapMode::Type WrapMode;
+ using FilterMode = Dali::FilterMode::Type;
+ using WrapMode = Dali::WrapMode::Type;
/**
* Constructor
class Texture
{
public:
-
- typedef Dali::TextureType::Type Type;
+ using Type = Dali::TextureType::Type;
/**
* Constructor
/**
* Destructor, non virtual as not a base class
*/
- ~ProgramController();
+ ~ProgramController() override;
public: // API
/**
* @copydoc ProgramCache::GetGlAbstraction
*/
- virtual Integration::GlAbstraction& GetGlAbstraction();
+ Integration::GlAbstraction& GetGlAbstraction() override;
/**
* @copydoc ProgramCache::GetProgram
*/
- virtual Program* GetProgram( size_t shaderHash );
+ Program* GetProgram( size_t shaderHash ) override;
/**
* @copydoc ProgramCache::AddProgram
*/
- virtual void AddProgram( size_t shaderHash, Program* program );
+ void AddProgram( size_t shaderHash, Program* program ) override;
/**
* @copydoc ProgramCache::GetCurrentProgram
*/
- virtual Program* GetCurrentProgram();
+ Program* GetCurrentProgram() override;
/**
* @copydoc ProgramCache::SetCurrentProgram
*/
- virtual void SetCurrentProgram( Program* program );
+ void SetCurrentProgram( Program* program ) override;
/**
* @copydoc ProgramCache::IsBinarySupported
*/
- virtual bool IsBinarySupported();
+ bool IsBinarySupported() override;
/**
* @copydoc ProgramCache::ProgramBinaryFormat
*/
- virtual GLenum ProgramBinaryFormat();
+ GLenum ProgramBinaryFormat() override;
/**
* @copydoc ProgramCache::StoreBinary
*/
- virtual void StoreBinary( Internal::ShaderDataPtr programData );
+ void StoreBinary( Internal::ShaderDataPtr programData ) override;
private: // not implemented as non-copyable
Integration::GlAbstraction& mGlAbstraction;
Program* mCurrentProgram;
- typedef OwnerContainer< ProgramPair* > ProgramContainer;
- typedef ProgramContainer::Iterator ProgramIterator;
+ using ProgramContainer = OwnerContainer<ProgramPair*>;
+ using ProgramIterator = ProgramContainer::Iterator;
ProgramContainer mProgramCache;
GLint mProgramBinaryFormat;
Internal::ShaderDataPtr mProgramData; ///< Shader program source and binary (when compiled & linked or loaded)
// location caches
- typedef std::pair< std::string, GLint > NameLocationPair;
- typedef std::vector< NameLocationPair > Locations;
+ using NameLocationPair = std::pair<std::string, GLint>;
+ using Locations = std::vector<NameLocationPair>;
Locations mAttributeLocations; ///< attribute location cache
Locations mUniformLocations; ///< uniform location cache
/**
* Virtual destructor
*/
- virtual ~Shader();
+ ~Shader() override;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The following methods are called during Update
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
*/
- virtual void UniformMappingsChanged( const UniformMap& mappings );
+ void UniformMappingsChanged( const UniformMap& mappings ) override;
private: // Data
/**
* Virtual destructor.
*/
- virtual ~AnimatorBase()
+ ~AnimatorBase() override
{
delete mAnimatorFunction;
if (mPropertyOwner && mConnectedToSceneGraph)
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner )
*/
- void PropertyOwnerConnected( PropertyOwner& owner ) override final
+ void PropertyOwnerConnected( PropertyOwner& owner ) final
{
mEnabled = true;
}
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
*/
- void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override final
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) final
{
// If we are active, then bake the value if required
if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::DISCARD )
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner )
*/
- void PropertyOwnerDestroyed( PropertyOwner& owner ) override final
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) final
{
mPropertyOwner = nullptr;
}
/**
* Virtual destructor.
*/
- virtual ~Animator()
+ ~Animator() override
{
}
/**
* @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final
+ void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) final
{
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
/**
* Virtual destructor.
*/
- virtual ~AnimatorTransformProperty()
+ ~AnimatorTransformProperty() override
{
}
/**
* @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final
+ void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) final
{
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const int32_t& property)
+ float operator()(float alpha, const int32_t& property) override
{
// integers need to be correctly rounded
return roundf(static_cast<float>( property ) + static_cast<float>( mRelative ) * alpha );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const int32_t& property)
+ float operator()(float alpha, const int32_t& property) override
{
// integers need to be correctly rounded
return roundf(static_cast<float>( property ) + (static_cast<float>(mTarget - property) * alpha) );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const float& property)
+ float operator()(float alpha, const float& property) override
{
return float(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const float& property)
+ float operator()(float alpha, const float& property) override
{
return float(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float alpha, const Vector2& property)
+ Vector2 operator()(float alpha, const Vector2& property) override
{
return Vector2(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float alpha, const Vector2& property)
+ Vector2 operator()(float alpha, const Vector2& property) override
{
return Vector2(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float alpha, const Vector3& property)
+ Vector3 operator()(float alpha, const Vector3& property) override
{
return Vector3(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float alpha, const Vector3& property)
+ Vector3 operator()(float alpha, const Vector3& property) override
{
return Vector3(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
return Vector4(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
return Vector4(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
Vector4 result(property);
result.a += mRelative * alpha;
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
Vector4 result(property);
result.a = property.a + ((mTarget - property.a) * alpha);
}
using AnimatorFunctionBase::operator();
- bool operator()(float alpha, const bool& property)
+ bool operator()(float alpha, const bool& property) override
{
// Alpha is not useful here, just keeping to the same template as other update functors
return bool(alpha >= 1.0f ? (property || mRelative) : property);
}
using AnimatorFunctionBase::operator();
- bool operator()(float alpha, const bool& property)
+ bool operator()(float alpha, const bool& property) override
{
// Alpha is not useful here, just keeping to the same template as other update functors
return bool(alpha >= 1.0f ? mTarget : property);
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float alpha, const Quaternion& rotation)
+ Quaternion operator()(float alpha, const Quaternion& rotation) override
{
if (alpha > 0.0f)
{
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float alpha, const Quaternion& rotation)
+ Quaternion operator()(float alpha, const Quaternion& rotation) override
{
return Quaternion::Slerp(rotation, mTarget, alpha);
}
}
using AnimatorFunctionBase::operator();
- bool operator()(float progress, const bool& property)
+ bool operator()(float progress, const bool& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- float operator()(float progress, const int32_t& property)
+ float operator()(float progress, const int32_t& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- float operator()(float progress, const float& property)
+ float operator()(float progress, const float& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float progress, const Vector2& property)
+ Vector2 operator()(float progress, const Vector2& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float progress, const Vector3& property)
+ Vector3 operator()(float progress, const Vector3& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float progress, const Vector4& property)
+ Vector4 operator()(float progress, const Vector4& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float progress, const Quaternion& property)
+ Quaternion operator()(float progress, const Quaternion& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float progress, const Vector3& property)
+ Vector3 operator()(float progress, const Vector3& property) override
{
Vector3 position(property);
static_cast<void>( mPath->SamplePosition(progress, position) );
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float progress, const Quaternion& property)
+ Quaternion operator()(float progress, const Quaternion& property) override
{
Vector3 tangent;
if( mPath->SampleTangent(progress, tangent) )
namespace SceneGraph
{
-
-typedef Dali::Vector<PropertyOwner*> PropertyOwnerContainer;
-typedef PropertyOwnerContainer::Iterator PropertyOwnerIter;
+using PropertyOwnerContainer = Dali::Vector<PropertyOwner*>;
+using PropertyOwnerIter = PropertyOwnerContainer::Iterator;
/**
* An abstract base class for Constraints.
};
public:
-
- typedef Dali::Constraint::RemoveAction RemoveAction;
+ using RemoveAction = Dali::Constraint::RemoveAction;
/**
* Constructor
/**
* Virtual destructor.
*/
- virtual ~ConstraintBase();
+ ~ConstraintBase() override;
/**
* Property resetter observes the lifecycle of this object
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected()
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner )
+ void PropertyOwnerConnected( PropertyOwner& owner ) override
{
}
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*/
- virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
{
if ( !mDisconnected )
{
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed()
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override
{
if ( !mDisconnected )
{
inline void SetRemoveActionMessage( EventThreadServices& eventThreadServices, const ConstraintBase& constraint, Dali::Constraint::RemoveAction removeAction )
{
- typedef MessageValue1< ConstraintBase, Dali::Constraint::RemoveAction > LocalType;
+ using LocalType = MessageValue1<ConstraintBase, Dali::Constraint::RemoveAction>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class ConstraintBase;
-typedef OwnerContainer< ConstraintBase* > ConstraintOwnerContainer;
-typedef ConstraintOwnerContainer::Iterator ConstraintIter;
+using ConstraintOwnerContainer = OwnerContainer<ConstraintBase *>;
+using ConstraintIter = ConstraintOwnerContainer::Iterator;
} // namespace SceneGraph
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::ConstraintBase::Apply()
*/
- virtual void Apply( BufferIndex updateBufferIndex )
+ void Apply( BufferIndex updateBufferIndex ) override
{
if ( !mDisconnected )
{
/**
* @copydoc Dali::Internal::SceneGraph::ConstraintBase::OnDisconnect()
*/
- virtual void OnDisconnect()
+ void OnDisconnect() override
{
// Discard target object/property pointers
mTargetProperty.Reset();
/**
* Virtual destructor.
*/
- virtual ~AnimatablePropertyBase()
+ ~AnimatablePropertyBase() override
{}
protected: // for derived classes
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
*/
- virtual bool IsClean() const
+ bool IsClean() const override
{
return ( CLEAN_FLAG == mDirtyFlags );
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true; // Animatable properties are always valid
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<bool>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetBoolean()
*/
- virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
+ const bool& GetBoolean( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<int>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetInteger()
*/
- virtual const int& GetInteger( BufferIndex bufferIndex ) const
+ const int& GetInteger( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<float>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetFloat()
*/
- virtual const float& GetFloat( BufferIndex bufferIndex ) const
+ const float& GetFloat( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector2>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
+ const Vector2& GetVector2( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector4>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetVector4( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix3>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix3()
*/
- virtual const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const
+ const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< T >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, T > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, T>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
const T& delta )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, const T& > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, const T&>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class DiscardQueue
{
public:
-
- typedef OwnerContainer< Shader* > ShaderQueue;
- typedef OwnerContainer< Renderer* > RendererQueue;
- typedef OwnerContainer< Camera* > CameraQueue;
- typedef OwnerContainer< Scene* > SceneQueue;
+ using ShaderQueue = OwnerContainer<Shader*>;
+ using RendererQueue = OwnerContainer<Renderer*>;
+ using CameraQueue = OwnerContainer<Camera*>;
+ using SceneQueue = OwnerContainer<Scene*>;
/**
* Create a new DiscardQueue.
/**
* Virtual destructor.
*/
- virtual ~InheritedVector3()
+ ~InheritedVector3() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector3()
*/
- virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedColor()
+ ~InheritedColor() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector4>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetVector4( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector4()
*/
- virtual const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedQuaternion()
+ ~InheritedQuaternion() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
*/
- virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedMatrix()
+ ~InheritedMatrix() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetConstraintInputMatrix()
*/
- virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~PropertyBase();
+ ~PropertyBase() override;
/**
* Reset the property to a base value; only required if the property is animated.
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* Virtual destructor
*/
- virtual ~PropertyOwnerMessageBase();
+ ~PropertyOwnerMessageBase() override;
private:
class AnimatablePropertyMessage : public PropertyOwnerMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~AnimatablePropertyMessage()
+ ~AnimatablePropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class AnimatablePropertyComponentMessage : public PropertyOwnerMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
/**
* Send a message.
/**
* Virtual destructor
*/
- virtual ~AnimatablePropertyComponentMessage()
+ ~AnimatablePropertyComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
inline void InstallCustomPropertyMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer<PropertyBase>& property )
{
- typedef MessageValue1< PropertyOwner, OwnerPointer<PropertyBase> > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, OwnerPointer<PropertyBase> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void ApplyConstraintMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer<ConstraintBase>& constraint )
{
- typedef MessageValue1< PropertyOwner, OwnerPointer<ConstraintBase> > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, OwnerPointer<ConstraintBase> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// The update-thread can modify this object.
ConstraintBase& constraint = const_cast< ConstraintBase& >( constConstraint );
- typedef MessageValue1< PropertyOwner, ConstraintBase* > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, ConstraintBase*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer< UniformPropertyMapping >& map )
{
- typedef MessageValue1< PropertyOwner, OwnerPointer< UniformPropertyMapping > > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, OwnerPointer<UniformPropertyMapping> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, const std::string& uniformName )
{
- typedef MessageValue1< PropertyOwner, std::string > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, std::string>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class PropertyOwner;
-typedef OwnerContainer< PropertyBase* > OwnedPropertyContainer;
-typedef OwnedPropertyContainer::Iterator OwnedPropertyIter;
+using OwnedPropertyContainer = OwnerContainer<PropertyBase*>;
+using OwnedPropertyIter = OwnedPropertyContainer::Iterator;
/**
* An update-thread object which own properties.
bool mUpdated;
private:
-
- typedef Dali::Vector<PropertyOwner::Observer*> ObserverContainer;
- typedef ObserverContainer::Iterator ObserverIter;
- typedef ObserverContainer::ConstIterator ConstObserverIter;
+ using ObserverContainer = Dali::Vector<PropertyOwner::Observer*>;
+ using ObserverIter = ObserverContainer::Iterator;
+ using ConstObserverIter = ObserverContainer::ConstIterator;
ObserverContainer mObservers; ///< Container of observer raw-pointers (not owned)
/**
* Virtual Destructor
*/
- virtual ~PropertyResetterBase()
+ ~PropertyResetterBase() override
{
if( mPropertyOwner != nullptr )
{
*
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner ) override
+ void PropertyOwnerConnected( PropertyOwner& owner ) override
{
mDisconnected = false;
mActive = ACTIVE;
* @param[in] bufferIndex the current buffer index
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
{
mDisconnected = true;
}
* Called shortly before the propertyOwner is destroyed
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) override
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override
{
mDisconnected = true;
mPropertyOwner = nullptr;
/**
* Virtual destructor.
*/
- virtual ~Resetter()
+ ~Resetter() override
{
// Disconnect from modifier object. Although this resetter should match the lifecycle of the modifier object,
// there are situations where it is deleted first (e.g. if the property owner is destroyed)
/**
* The Animator or Constraint is destroyed
*/
- virtual void ObjectDestroyed() override
+ void ObjectDestroyed() override
{
// When the modifier is destroyed, reduce the running value to ensure we stay alive for
// another frame to reset the other buffer.
ModifierType* mModifier;
};
-
-typedef Resetter<SceneGraph::AnimatorBase> AnimatorResetter;
-typedef Resetter<SceneGraph::ConstraintBase> ConstraintResetter;
-
-
+using AnimatorResetter = Resetter<SceneGraph::AnimatorBase>;
+using ConstraintResetter = Resetter<SceneGraph::ConstraintBase>;
} // namespace SceneGraph
void Destroy( PropertyOwner& object );
private:
- typedef Dali::Vector<Observer*> Observers;
- typedef Observers::Iterator ObserversIterator;
+ using Observers = Dali::Vector<Observer*>;
+ using ObserversIterator = Observers::Iterator;
Observers mObservers;
};
class PropertyNotification;
-typedef OwnerContainer< PropertyNotification* > PropertyNotificationContainer;
-typedef PropertyNotificationContainer::Iterator PropertyNotificationIter;
-typedef PropertyNotificationContainer::ConstIterator PropertyNotificationConstIter;
-typedef bool(*ConditionFunction)(const Dali::PropertyInput& value, Dali::Internal::PropertyNotification::RawArgumentContainer& args);
+using PropertyNotificationContainer = OwnerContainer<PropertyNotification*>;
+using PropertyNotificationIter = PropertyNotificationContainer::Iterator;
+using PropertyNotificationConstIter = PropertyNotificationContainer::ConstIterator;
+using ConditionFunction = bool ( * )( const Dali::PropertyInput&, Dali::Internal::PropertyNotification::RawArgumentContainer& );
/**
* PropertyNotifications are used to inspect properties of scene graph objects, as part of a scene
class PropertyNotification
{
public:
-
- typedef Dali::PropertyNotification::NotifyMode NotifyMode;
- typedef Dali::Internal::PropertyNotification::ConditionType ConditionType;
- typedef Dali::Internal::PropertyNotification::RawArgumentContainer RawArgumentContainer;
- typedef const void *(*GetPropertyFunction)( const SceneGraph::PropertyBase*, int );
+ using NotifyMode = Dali::PropertyNotification::NotifyMode;
+ using ConditionType = Dali::Internal::PropertyNotification::ConditionType;
+ using RawArgumentContainer = Dali::Internal::PropertyNotification::RawArgumentContainer;
+ using GetPropertyFunction = const void* (*)( const SceneGraph::PropertyBase*, int );
/**
* Construct a new PropertyNotification
/// Messages
inline void AddFrameRenderedCallbackMessage( EventThreadServices& eventThreadServices, const Scene& scene, const CallbackBase* callback, int32_t frameId )
{
- typedef MessageValue2< Scene, CallbackBase*, int32_t > LocalType;
+ using LocalType = MessageValue2<Scene, CallbackBase*, int32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddFramePresentedCallbackMessage( EventThreadServices& eventThreadServices, const Scene& scene, const CallbackBase* callback, int32_t frameId )
{
- typedef MessageValue2< Scene, CallbackBase*, int32_t > LocalType;
+ using LocalType = MessageValue2<Scene, CallbackBase*, int32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class UniformPropertyMapping
{
public:
- typedef unsigned long Hash;
+ using Hash = unsigned long;
/**
* Constructor
void MappingChanged();
private:
- typedef OwnerContainer< UniformPropertyMapping* > UniformMapContainer;
- typedef UniformMapContainer::Iterator UniformMapIter;
- typedef Dali::Vector< Observer* > Observers;
- typedef Observers::Iterator ObserversIter;
+ using UniformMapContainer = OwnerContainer<UniformPropertyMapping*>;
+ using UniformMapIter = UniformMapContainer::Iterator;
+ using Observers = Dali::Vector<Observer*>;
+ using ObserversIter = Observers::Iterator;
UniformMapContainer mUniformMaps; // Owner container of uniform maps
void RenderMessageDispatcher::RemoveRenderer( Render::Renderer& renderer )
{
- typedef MessageValue1< RenderManager, Render::Renderer* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Renderer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void RenderMessageDispatcher::AddRenderTracker( Render::RenderTracker& renderTracker )
{
- typedef MessageValue1< RenderManager, Render::RenderTracker* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::RenderTracker*>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void RenderMessageDispatcher::RemoveRenderTracker( Render::RenderTracker& renderTracker )
{
- typedef MessageValue1< RenderManager, Render::RenderTracker* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::RenderTracker*>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
/**
* Destructor
*/
- virtual ~SceneControllerImpl();
+ ~SceneControllerImpl() override;
public: // from SceneController
/**
* @copydoc SceneController::GetRenderMessageDispatcher()
*/
- virtual RenderMessageDispatcher& GetRenderMessageDispatcher() { return mRenderMessageDispatcher; }
+ RenderMessageDispatcher& GetRenderMessageDispatcher() override { return mRenderMessageDispatcher; }
/**
* @copydoc SceneController::GetRenderQueue()
*/
- virtual RenderQueue& GetRenderQueue() { return mRenderQueue; }
+ RenderQueue& GetRenderQueue() override { return mRenderQueue; }
/**
* @copydoc SceneController::GetDiscardQueue()
*/
- virtual DiscardQueue& GetDiscardQueue() { return mDiscardQueue; }
+ DiscardQueue& GetDiscardQueue() override { return mDiscardQueue; }
private:
/**
* Virtual destructor.
*/
- virtual ~GestureProperty()
+ ~GestureProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get< T >();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return true;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return mInputChanged;
}
/**
* Virtual destructor.
*/
- virtual ~GesturePropertyVector2()
+ ~GesturePropertyVector2() override
{
}
/**
* @copydoc Dali::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
+ const Vector2& GetVector2( BufferIndex bufferIndex ) const override
{
return mValue;
}
/**
* Virtual destructor.
*/
- virtual ~GesturePropertyBool()
+ ~GesturePropertyBool() override
{
}
/**
* @copydoc Dali::PropertyInput::GetBoolean()
*/
- virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
+ const bool& GetBoolean( BufferIndex bufferIndex ) const override
{
return mValue;
}
GestureState state;
};
- typedef std::vector< PanGestureProfiling::Position > PanPositionContainer;
+ using PanPositionContainer = std::vector<PanGestureProfiling::Position>;
void PrintData() const;
volatile bool read;
};
- typedef std::vector<PanInfo> PanInfoHistory;
- typedef PanInfoHistory::iterator PanInfoHistoryIter;
- typedef PanInfoHistory::const_iterator PanInfoHistoryConstIter;
+ using PanInfoHistory = std::vector<PanInfo>;
+ using PanInfoHistoryIter = PanInfoHistory::iterator;
+ using PanInfoHistoryConstIter = PanInfoHistory::const_iterator;
private:
static const unsigned int PAN_GESTURE_HISTORY = 30u;
/**
* Virtual destructor
*/
- virtual ~PanGesture();
+ ~PanGesture() override;
/**
* Adds a PanGesture to the internal circular-buffer waiting to be handled by UpdateProperties.
// Struct to keep pairs of local and screen data together.
// TODO: This can encapsulate some functionality also.
- typedef struct
+ using RelativeVectors = struct
+
{
Vector2 local;
+
Vector2 screen;
- } RelativeVectors;
+ };
/**
* Houses new code to process input events and generate an output point.
inline void SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder );
/// Sort comparitor function pointer type.
- typedef bool ( *ComparitorPointer )( const SortAttributes& lhs, const SortAttributes& rhs );
- typedef std::vector< SortAttributes > SortingHelper;
+ using ComparitorPointer = bool ( * )( const SortAttributes&, const SortAttributes& );
+
+ using SortingHelper = std::vector<SortAttributes>;
Dali::Vector< ComparitorPointer > mSortComparitors; ///< Contains all sort comparitors, used for quick look-up
RenderInstructionProcessor::SortingHelper mSortingHelper; ///< Helper used to sort Renderers
/**
* Non-virtual Destructor.
*/
- ~FrameCallback();
+ ~FrameCallback() override;
/**
* Called from the update-thread when connecting to the scene-graph.
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected()
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner ) { /* Nothing to do */ }
+ void PropertyOwnerConnected( PropertyOwner& owner ) override { /* Nothing to do */ }
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*/
- virtual void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) { /* Nothing to do */ }
+ void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) override { /* Nothing to do */ }
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*
* Will use this to disconnect the frame-callback if the accompanying node is destroyed
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner );
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override;
// Construction
/**
* A container of Layer pointers sorted by depth
*/
-typedef std::vector<Layer*> SortedLayerPointers;
+using SortedLayerPointers = std::vector<Layer *>;
-typedef SortedLayerPointers::iterator SortedLayersIter;
-typedef SortedLayerPointers::const_iterator SortedLayersConstIter;
+using SortedLayersIter = SortedLayerPointers::iterator;
+using SortedLayersConstIter = SortedLayerPointers::const_iterator;
} // namespace SceneGraph
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const = 0;
+ Dali::Property::Type GetType() const override = 0;
/**
* @copydoc Dali::SceneGraph::AnimatableProperty::Get()
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const{ return Vector3::ZERO; }
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override{ return Vector3::ZERO; }
/**
* Retrieve a component of property
/**
* @copydoc Dali::AnimatableProperty::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex){}
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override{}
/**
* @copydoc Dali::AnimatableProperty::IsClean()
*/
- virtual bool IsClean() const{ return false; }
+ bool IsClean() const override{ return false; }
/**
* Initializes the property
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
mProperty( property )
{}
- Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
- Vector3& Get( BufferIndex bufferIndex )
+ Vector3& Get( BufferIndex bufferIndex ) override
{
return mTxManager->GetVector3PropertyValue( mId, mProperty );
}
- const Vector3& Get( BufferIndex bufferIndex ) const
+ const Vector3& Get( BufferIndex bufferIndex ) const override
{
return mTxManager->GetVector3PropertyValue( mId, mProperty );
}
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return Get(bufferIndex);
}
- const float& GetFloatComponent( uint32_t component )
+ const float& GetFloatComponent( uint32_t component ) override
{
return mTxManager->GetVector3PropertyComponentValue( mId, mProperty, component );
}
- void Set(BufferIndex bufferIndex, const Vector3& value)
+ void Set(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->SetVector3PropertyValue( mId, mProperty, value );
}
mTxManager->BakeVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void Bake(BufferIndex bufferIndex, const Vector3& value)
+ void Bake(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeVector3PropertyValue(mId, mProperty, value );
}
- void BakeX(BufferIndex bufferIndex, float value)
+ void BakeX(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeXVector3PropertyValue(mId, mProperty, value );
}
- void BakeY(BufferIndex bufferIndex, float value)
+ void BakeY(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeYVector3PropertyValue(mId, mProperty, value );
}
- void BakeZ(BufferIndex bufferIndex, float value)
+ void BakeZ(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeZVector3PropertyValue(mId, mProperty, value );
}
- void SetFloatComponent( float value, uint32_t component)
+ void SetFloatComponent( float value, uint32_t component) override
{
mTxManager->SetVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void BakeFloatComponent( float value, uint32_t component )
+ void BakeFloatComponent( float value, uint32_t component ) override
{
mTxManager->BakeVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void BakeRelative(BufferIndex bufferIndex, const Vector3& value)
+ void BakeRelative(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeRelativeVector3PropertyValue(mId, mProperty, value );
}
- void BakeRelativeMultiply(BufferIndex bufferIndex, const Vector3& value)
+ void BakeRelativeMultiply(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeMultiplyVector3PropertyValue(mId, mProperty, value );
}
:TransformManagerPropertyHandler()
{}
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
- Quaternion& Get( BufferIndex bufferIndex )
+ Quaternion& Get( BufferIndex bufferIndex ) override
{
return mTxManager->GetQuaternionPropertyValue( mId );
}
- const Quaternion& Get( BufferIndex bufferIndex ) const
+ const Quaternion& Get( BufferIndex bufferIndex ) const override
{
return mTxManager->GetQuaternionPropertyValue( mId );
}
- const float& GetFloatComponent( uint32_t component)
+ const float& GetFloatComponent( uint32_t component) override
{
return mTxManager->GetQuaternionPropertyValue( mId ).mVector[component];
}
- void Set(BufferIndex bufferIndex, const Quaternion& value)
+ void Set(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->SetQuaternionPropertyValue( mId, value );
}
- void Bake(BufferIndex bufferIndex, const Quaternion& value)
+ void Bake(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->BakeQuaternionPropertyValue( mId, value );
}
- void BakeRelative(BufferIndex bufferIndex, const Quaternion& value)
+ void BakeRelative(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->BakeRelativeQuaternionPropertyValue( mId, value );
}
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return Get(bufferIndex);
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerVector3Input()
+ ~TransformManagerVector3Input() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector3()
*/
- virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerQuaternionInput()
+ ~TransformManagerQuaternionInput() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
*/
- virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerMatrixInput()
+ ~TransformManagerMatrixInput() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
if( mTxManager )
{
/**
* @copydoc Dali::PropertyInput::GetConstraintInputMatrix()
*/
- virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const override
{
if( mTxManager )
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
TRANSFORM_PROPERTY_COUNT,
};
-typedef uint32_t TransformId; // 4,294,967,295 transforms supported
+using TransformId = uint32_t; // 4,294,967,295 transforms supported
static const TransformId INVALID_TRANSFORM_ID = -1;
} //SceneGraph
void UpdateManager::RemoveScene( Scene* scene )
{
// Initialize the context from render manager
- typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, SceneGraph::Scene*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
{
if( shaderData )
{
-
- typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
+ using DerivedType = MessageValue3<Shader, Internal::ShaderDataPtr, ProgramCache*, bool>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
(mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR
IsAnimationRunning() || // ..at least one animation is running OR
mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR
+ mImpl->frameCallbackProcessor || // ..a frame callback processor is existed OR
gestureUpdated; // ..a gesture property was updated
bool keepRendererRendering = false;
{
mImpl->surfaceRectChanged = true;
- typedef MessageValue1< RenderManager, Rect<int32_t> > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Rect<int32_t> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SurfaceReplaced( Scene* scene )
{
- typedef MessageValue1< RenderManager, Scene* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Scene*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
{
// Message has ownership of Sampler while in transit from update to render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Sampler> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveSampler( Render::Sampler* sampler )
{
- typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Sampler*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
{
- typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::Sampler*, uint32_t, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
{
- typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType;
+ using DerivedType = MessageValue4<RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddVertexBuffer( OwnerPointer< Render::VertexBuffer >& vertexBuffer )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::VertexBuffer > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::VertexBuffer> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveVertexBuffer( Render::VertexBuffer* vertexBuffer )
{
- typedef MessageValue1< RenderManager, Render::VertexBuffer* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::VertexBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetVertexBufferFormat( Render::VertexBuffer* vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue2< RenderManager, Render::VertexBuffer*, OwnerPointer< Render::VertexBuffer::Format > > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::VertexBuffer*, OwnerPointer<Render::VertexBuffer::Format> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetVertexBufferData( Render::VertexBuffer* vertexBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue3< RenderManager, Render::VertexBuffer*, OwnerPointer< Dali::Vector<uint8_t> >, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::VertexBuffer*, OwnerPointer<Dali::Vector<uint8_t> >, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Geometry> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
{
- typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Geometry*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
{
- typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::Geometry*, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
{
- typedef IndexBufferMessage< RenderManager > DerivedType;
+ using DerivedType = IndexBufferMessage<RenderManager>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
{
- typedef MessageValue2< RenderManager, Render::Geometry*, Render::VertexBuffer* > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
{
- typedef MessageValue2< RenderManager, Render::Geometry*, Render::VertexBuffer* > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
{
// Message has ownership of Texture while in transit from update -> render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Texture> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveTexture( Render::Texture* texture)
{
- typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
{
- typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams>;
// Reserve some memory inside the message queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::GenerateMipmaps( Render::Texture* texture )
{
- typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
{
- typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::FrameBuffer> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
{
- typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::FrameBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
{
- typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType;
+ using DerivedType = MessageValue4<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachDepthTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachDepthStencilTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
/**
* Destructor.
*/
- virtual ~UpdateManager();
+ ~UpdateManager() override;
// Node connection methods
* @brief Accept compiled shaders passed back on render thread for saving.
* @param[in] shaderData Source code, hash over source, and corresponding compiled binary to be saved.
*/
- virtual void SaveBinary( Internal::ShaderDataPtr shaderData );
+ void SaveBinary( Internal::ShaderDataPtr shaderData ) override;
/**
* @brief Set the destination for compiled shader binaries to be passed on to.
inline void InstallRootMessage( UpdateManager& manager, OwnerPointer<Layer>& root )
{
// Message has ownership of Layer while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer<Layer> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Layer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
Layer* root = const_cast< Layer* >( constRoot );
- typedef MessageValue1< UpdateManager, Layer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Layer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddNodeMessage( UpdateManager& manager, OwnerPointer<Node>& node )
{
// Message has ownership of Node while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer<Node> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Node> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
Node& parent = const_cast< Node& >( constParent );
Node& child = const_cast< Node& >( constChild );
- typedef MessageValue2< UpdateManager, Node*, Node* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Node*, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can modify this object.
Node& node = const_cast< Node& >( constNode );
- typedef MessageValue1< UpdateManager, Node* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
Node& node = const_cast< Node& >( constNode );
- typedef MessageValue1< UpdateManager, Node* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddCameraMessage( UpdateManager& manager, OwnerPointer< Camera >& camera )
{
// Message has ownership of Camera while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Camera > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Camera> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveCameraMessage( UpdateManager& manager, const Camera* camera )
{
- typedef MessageValue1< UpdateManager, Camera* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Camera*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddObjectMessage( UpdateManager& manager, OwnerPointer<PropertyOwner>& object )
{
// Message has ownership of object while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer<PropertyOwner> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<PropertyOwner> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveObjectMessage( UpdateManager& manager, const PropertyOwner* object )
{
- typedef MessageValue1< UpdateManager, PropertyOwner* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, PropertyOwner*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddAnimationMessage( UpdateManager& manager, OwnerPointer< SceneGraph::Animation >& animation )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::Animation > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<SceneGraph::Animation> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Animation& animation = const_cast< Animation& >( constAnimation );
- typedef MessageValue1< UpdateManager, Animation* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Animation*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Animation& animation = const_cast< Animation& >( constAnimation );
- typedef MessageValue1< UpdateManager, Animation* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Animation*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddRenderTaskListMessage( UpdateManager& manager, OwnerPointer< SceneGraph::RenderTaskList >& taskList )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::RenderTaskList > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<SceneGraph::RenderTaskList> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
RenderTaskList& taskList = const_cast< RenderTaskList& >( constTaskList );
- typedef MessageValue1< UpdateManager, RenderTaskList* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, RenderTaskList*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddSceneMessage( UpdateManager& manager, OwnerPointer< SceneGraph::Scene >& scene )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::Scene > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<SceneGraph::Scene> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Scene& scene = const_cast< Scene& >( constScene );
- typedef MessageValue1< UpdateManager, Scene* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Scene*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddPropertyNotificationMessage( UpdateManager& manager, OwnerPointer< PropertyNotification >& propertyNotification )
{
// Message has ownership of PropertyNotification while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< PropertyNotification > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<PropertyNotification> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
PropertyNotification& propertyNotification = const_cast< PropertyNotification& >( constPropertyNotification );
- typedef MessageValue1< UpdateManager, PropertyNotification* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, PropertyNotification*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
PropertyNotification* propertyNotification = const_cast< PropertyNotification* >( constPropertyNotification );
- typedef MessageValue2< UpdateManager, PropertyNotification*, PropertyNotification::NotifyMode > LocalType;
+ using LocalType = MessageValue2<UpdateManager, PropertyNotification*, PropertyNotification::NotifyMode>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void AddShaderMessage( UpdateManager& manager, OwnerPointer< Shader >& shader )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< Shader > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Shader> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void RemoveShaderMessage( UpdateManager& manager, const Shader* shader )
{
- typedef MessageValue1< UpdateManager, Shader* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Shader*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
Internal::ShaderDataPtr shaderData,
bool modifiesGeometry )
{
- typedef MessageValue3< UpdateManager, Shader*, Internal::ShaderDataPtr, bool > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Shader*, Internal::ShaderDataPtr, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDefaultSurfaceRectMessage( UpdateManager& manager, const Rect<int32_t>& rect )
{
- typedef MessageValue1< UpdateManager, Rect<int32_t> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Rect<int32_t> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Scene& scene = const_cast< Scene& >( constScene );
- typedef MessageValue1< UpdateManager, Scene* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Scene*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void KeepRenderingMessage( UpdateManager& manager, float durationSeconds )
{
- typedef MessageValue1< UpdateManager, float > LocalType;
+ using LocalType = MessageValue1<UpdateManager, float>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRenderingBehaviorMessage( UpdateManager& manager, DevelStage::Rendering renderingBehavior )
{
- typedef MessageValue1< UpdateManager, DevelStage::Rendering > LocalType;
+ using LocalType = MessageValue1<UpdateManager, DevelStage::Rendering>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetLayerDepthsMessage( UpdateManager& manager, const std::vector< Layer* >& layers, const Layer* rootLayer )
{
- typedef MessageValue2< UpdateManager, std::vector< Layer* >, const Layer* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, std::vector<Layer*>, const Layer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddRendererMessage( UpdateManager& manager, OwnerPointer< Renderer >& object )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< Renderer > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Renderer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveRendererMessage( UpdateManager& manager, const Renderer& object )
{
- typedef MessageValue1< UpdateManager, Renderer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Renderer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void AddTextureSetMessage( UpdateManager& manager, OwnerPointer< TextureSet >& textureSet )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< TextureSet > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<TextureSet> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void RemoveTextureSetMessage( UpdateManager& manager, TextureSet& textureSet )
{
- typedef MessageValue1< UpdateManager, TextureSet* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, TextureSet*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddSamplerMessage( UpdateManager& manager, OwnerPointer< Render::Sampler >& sampler )
{
// Message has ownership of Sampler while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::Sampler > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::Sampler> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveSamplerMessage( UpdateManager& manager, Render::Sampler& sampler )
{
- typedef MessageValue1< UpdateManager, Render::Sampler* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Sampler*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetFilterModeMessage( UpdateManager& manager, Render::Sampler& sampler, uint32_t minFilterMode, uint32_t magFilterMode )
{
- typedef MessageValue3< UpdateManager, Render::Sampler*, uint32_t, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::Sampler*, uint32_t, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetWrapModeMessage( UpdateManager& manager, Render::Sampler& sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
{
- typedef MessageValue4< UpdateManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > LocalType;
+ using LocalType = MessageValue4<UpdateManager, Render::Sampler*, uint32_t, uint32_t, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddVertexBuffer( UpdateManager& manager, OwnerPointer< Render::VertexBuffer >& vertexBuffer )
{
// Message has ownership of vertexBuffer while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::VertexBuffer > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::VertexBuffer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveVertexBuffer( UpdateManager& manager, Render::VertexBuffer& vertexBuffer )
{
- typedef MessageValue1< UpdateManager, Render::VertexBuffer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::VertexBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetVertexBufferFormat( UpdateManager& manager, Render::VertexBuffer& vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format )
{
// Message has ownership of VertexBuffer::Format while in transit from event -> update
- typedef MessageValue2< UpdateManager, Render::VertexBuffer*, OwnerPointer< Render::VertexBuffer::Format> > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::VertexBuffer*, OwnerPointer<Render::VertexBuffer::Format> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetVertexBufferData( UpdateManager& manager, Render::VertexBuffer& vertexBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
{
// Message has ownership of VertexBuffer data while in transit from event -> update
- typedef MessageValue3< UpdateManager, Render::VertexBuffer*, OwnerPointer< Vector<uint8_t> >, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::VertexBuffer*, OwnerPointer<Vector<uint8_t> >, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddGeometry( UpdateManager& manager, OwnerPointer< Render::Geometry >& geometry )
{
// Message has ownership of Geometry while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::Geometry > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::Geometry> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveGeometry( UpdateManager& manager, Render::Geometry& geometry )
{
- typedef MessageValue1< UpdateManager, Render::Geometry* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Geometry*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::VertexBuffer& vertexBuffer )
{
- typedef MessageValue2< UpdateManager, Render::Geometry*, Render::VertexBuffer* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::VertexBuffer& vertexBuffer )
{
- typedef MessageValue2< UpdateManager, Render::Geometry*, Render::VertexBuffer* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
/**
* Virtual destructor
*/
- virtual ~IndexBufferMessage()
+ ~IndexBufferMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
DALI_ASSERT_DEBUG( mManager && "Message does not have an object" );
mManager->SetIndexBuffer( mRenderGeometry, mIndices );
inline void SetIndexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, Dali::Vector<uint16_t>& indices )
{
- typedef IndexBufferMessage< UpdateManager > LocalType;
+ using LocalType = IndexBufferMessage<UpdateManager>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetGeometryTypeMessage( UpdateManager& manager, Render::Geometry& geometry, uint32_t geometryType )
{
- typedef MessageValue2< UpdateManager, Render::Geometry*, uint32_t > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::Geometry*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddTexture( UpdateManager& manager, OwnerPointer< Render::Texture >& texture )
{
// Message has ownership of Texture while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::Texture > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::Texture> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveTexture( UpdateManager& manager, Render::Texture& texture )
{
- typedef MessageValue1< UpdateManager, Render::Texture* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Texture*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void UploadTextureMessage( UpdateManager& manager, Render::Texture& texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
{
- typedef MessageValue3< UpdateManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::Texture*, PixelDataPtr, Texture::UploadParams>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void GenerateMipmapsMessage( UpdateManager& manager, Render::Texture& texture )
{
- typedef MessageValue1< UpdateManager, Render::Texture* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Texture*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddFrameBuffer( UpdateManager& manager, OwnerPointer< Render::FrameBuffer >& frameBuffer )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::FrameBuffer > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::FrameBuffer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer )
{
- typedef MessageValue1< UpdateManager, Render::FrameBuffer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::FrameBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachColorTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
{
- typedef MessageValue4< UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > LocalType;
+ using LocalType = MessageValue4<UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachDepthTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachDepthStencilTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthIndicesMessage( UpdateManager& manager, OwnerPointer< NodeDepths >& nodeDepths )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< NodeDepths > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<NodeDepths> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddResetterMessage( UpdateManager& manager, OwnerPointer<PropertyResetterBase> resetter )
{
- typedef MessageValue1< UpdateManager, OwnerPointer<PropertyResetterBase> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<PropertyResetterBase> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddFrameCallbackMessage( UpdateManager& manager, OwnerPointer< FrameCallback >& frameCallback, const Node& rootNode )
{
- typedef MessageValue2< UpdateManager, OwnerPointer< FrameCallback >, const Node* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, OwnerPointer<FrameCallback>, const Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveFrameCallbackMessage( UpdateManager& manager, FrameCallbackInterface& frameCallback )
{
- typedef MessageValue1< UpdateManager, FrameCallbackInterface* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, FrameCallbackInterface*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
class Node;
-typedef Dali::Vector< Node* > NodeContainer;
-typedef NodeContainer::Iterator NodeIter;
-typedef NodeContainer::ConstIterator NodeConstIter;
+using NodeContainer = Dali::Vector<Node *>;
+using NodeIter = NodeContainer::Iterator;
+using NodeConstIter = NodeContainer::ConstIterator;
/**
* Flag whether property has changed, during the Update phase.
/**
* Virtual destructor
*/
- virtual ~NodePropertyMessageBase();
+ ~NodePropertyMessageBase() override;
private:
class NodePropertyMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~NodePropertyMessage()
+ ~NodePropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class NodePropertyComponentMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
/**
* Send a message.
/**
* Virtual destructor
*/
- virtual ~NodePropertyComponentMessage()
+ ~NodePropertyComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class NodeTransformPropertyMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(TransformManagerPropertyHandler<P>::*MemberFunction)( BufferIndex, const P& );
+ using MemberFunction = void ( TransformManagerPropertyHandler<P>::* )( BufferIndex, const P& );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~NodeTransformPropertyMessage()
+ ~NodeTransformPropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class NodeTransformComponentMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(TransformManagerPropertyHandler<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( TransformManagerPropertyHandler<P>::* )( BufferIndex, float );
/**
* Send a message.
/**
* Virtual destructor
*/
- virtual ~NodeTransformComponentMessage()
+ ~NodeTransformComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
* @param[in] updated The updated flag
* (used for partial rendering to mark an animating sub tree for example).
*/
- virtual void SetUpdated(bool updated)
+ void SetUpdated(bool updated) override
{
mUpdated = updated;
/**
* @copydoc UniformMap::Add
*/
- void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map );
+ void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map ) override;
/**
* @copydoc UniformMap::Remove
*/
- void RemoveUniformMapping( const std::string& uniformName );
+ void RemoveUniformMapping( const std::string& uniformName ) override;
/**
* Prepare the node for rendering.
* Protected virtual destructor; See also Node::Delete( Node* )
* Kept protected to allow destructor chaining from layer
*/
- virtual ~Node();
+ ~Node() override;
private: // from NodeDataProvider
/**
* @copydoc NodeDataProvider::GetModelMatrix
*/
- virtual const Matrix& GetModelMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetModelMatrix( BufferIndex bufferIndex ) const override
{
return GetWorldMatrix( bufferIndex );
}
/**
* @copydoc NodeDataProvider::GetRenderColor
*/
- virtual const Vector4& GetRenderColor( BufferIndex bufferIndex ) const
+ const Vector4& GetRenderColor( BufferIndex bufferIndex ) const override
{
return GetWorldColor( bufferIndex );
}
/**
* @copydoc UniformMapDataProvider::GetUniformMapChanged
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override
{
return mUniformMapChanged[bufferIndex];
}
/**
* @copydoc UniformMapDataProvider::GetUniformMap
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override
{
return mCollectedUniformMap[bufferIndex];
}
inline void SetInheritOrientationMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetParentOriginMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& origin )
{
- typedef MessageValue1< Node, Vector3 > LocalType;
+ using LocalType = MessageValue1<Node, Vector3>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetAnchorPointMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& anchor )
{
- typedef MessageValue1< Node, Vector3 > LocalType;
+ using LocalType = MessageValue1<Node, Vector3>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetInheritPositionMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetInheritScaleMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetColorModeMessage( EventThreadServices& eventThreadServices, const Node& node, ColorMode colorMode )
{
- typedef MessageValue1< Node, ColorMode > LocalType;
+ using LocalType = MessageValue1<Node, ColorMode>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDrawModeMessage( EventThreadServices& eventThreadServices, const Node& node, DrawMode::Type drawMode )
{
- typedef MessageValue1< Node, DrawMode::Type > LocalType;
+ using LocalType = MessageValue1<Node, DrawMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachRendererMessage( EventThreadServices& eventThreadServices, const Node& node, const Renderer& renderer )
{
- typedef MessageValue1< Node, Renderer* > LocalType;
+ using LocalType = MessageValue1<Node, Renderer*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void DetachRendererMessage( EventThreadServices& eventThreadServices, const Node& node, const Renderer& renderer )
{
- typedef MessageValue1< Node, const Renderer* > LocalType;
+ using LocalType = MessageValue1<Node, const Renderer*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Node& node, uint32_t depthIndex )
{
- typedef MessageValue1< Node, uint32_t > LocalType;
+ using LocalType = MessageValue1<Node, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetClippingModeMessage( EventThreadServices& eventThreadServices, const Node& node, ClippingMode::Type clippingMode )
{
- typedef MessageValue1< Node, ClippingMode::Type > LocalType;
+ using LocalType = MessageValue1<Node, ClippingMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetPositionUsesAnchorPointMessage( EventThreadServices& eventThreadServices, const Node& node, bool positionUsesAnchorPoint )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
Renderer* mRenderer;
};
-typedef Dali::Vector< Renderable > RenderableContainer;
+using RenderableContainer = Dali::Vector<Renderable>;
/**
* Layers have a "depth" relative to all other layers in the scene-graph.
class Layer : public Node
{
public:
-
- typedef Dali::Layer::SortFunctionType SortFunctionType;
+ using SortFunctionType = Dali::Layer::SortFunctionType;
// Creation methods
/**
* Virtual destructor
*/
- virtual ~Layer();
+ ~Layer() override;
/**
* From Node, to convert a node to a layer.
* @return The layer.
*/
- virtual Layer* GetLayer()
+ Layer* GetLayer() override
{
return this;
}
*/
inline void SetSortFunctionMessage( EventThreadServices& eventThreadServices, const Layer& layer, Dali::Layer::SortFunctionType function )
{
- typedef MessageValue1< Layer, Dali::Layer::SortFunctionType > LocalType;
+ using LocalType = MessageValue1<Layer, Dali::Layer::SortFunctionType>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetClippingMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool enabled )
{
- typedef MessageValue1< Layer, bool > LocalType;
+ using LocalType = MessageValue1<Layer, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetClippingBoxMessage( EventThreadServices& eventThreadServices, const Layer& layer, const Dali::ClippingBox& clippingbox )
{
- typedef MessageValue1< Layer, Dali::ClippingBox > LocalType;
+ using LocalType = MessageValue1<Layer, Dali::ClippingBox>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const Layer& layer,
Dali::Layer::Behavior behavior )
{
- typedef MessageValue1< Layer, Dali::Layer::Behavior > LocalType;
+ using LocalType = MessageValue1<Layer, Dali::Layer::Behavior>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetDepthTestDisabledMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool disable )
{
- typedef MessageValue1< Layer, bool > LocalType;
+ using LocalType = MessageValue1<Layer, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// A queue of message buffers
typedef vector< MessageBuffer* > MessageBufferQueue;
-typedef MessageBufferQueue::iterator MessageBufferIter;
+using MessageBufferIter = MessageBufferQueue::iterator;
-typedef Dali::Mutex MessageQueueMutex;
+using MessageQueueMutex = Dali::Mutex;
} // unnamed namespace
inline void SetTypeMessage( EventThreadServices& eventThreadServices, const Camera& camera, Dali::Camera::Type parameter )
{
- typedef MessageValue1< Camera, Dali::Camera::Type > LocalType;
+ using LocalType = MessageValue1<Camera, Dali::Camera::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetProjectionModeMessage( EventThreadServices& eventThreadServices, const Camera& camera, Dali::Camera::ProjectionMode parameter )
{
- typedef MessageValue1< Camera, Dali::Camera::ProjectionMode > LocalProjectionMode;
+ using LocalProjectionMode = MessageValue1<Camera, Dali::Camera::ProjectionMode>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalProjectionMode ) );
inline void SetFieldOfViewMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetAspectRatioMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetLeftClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRightClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetTopClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBottomClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetNearClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetFarClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetTargetPositionMessage( EventThreadServices& eventThreadServices, const Camera& camera, const Vector3& parameter )
{
- typedef MessageValue1< Camera, Vector3 > LocalType;
+ using LocalType = MessageValue1<Camera, Vector3>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetInvertYAxisMessage( EventThreadServices& eventThreadServices, const Camera& camera, bool parameter )
{
- typedef MessageValue1< Camera, bool > LocalType;
+ using LocalType = MessageValue1<Camera, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class RenderTaskList
{
public:
-
- typedef OwnerContainer< RenderTask* > RenderTaskContainer;
+ using RenderTaskContainer = OwnerContainer<RenderTask*>;
/**
* Construct a new RenderTaskList.
inline void AddTaskMessage( EventThreadServices& eventThreadServices, const RenderTaskList& list, OwnerPointer< RenderTask >& task )
{
// Message has ownership of the RenderTask while in transit from event -> update
- typedef MessageValue1< RenderTaskList, OwnerPointer< RenderTask > > LocalType;
+ using LocalType = MessageValue1<RenderTaskList, OwnerPointer<RenderTask> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
RenderTask& task = const_cast< RenderTask& >( constTask );
- typedef MessageValue1< RenderTaskList, RenderTask* > LocalType;
+ using LocalType = MessageValue1<RenderTaskList, RenderTask*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
/**
* Virtual destructor
*/
- virtual ~RenderTask();
+ ~RenderTask() override;
/**
* Initialize the render task. Called in update thread
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner )
*/
- void PropertyOwnerConnected( PropertyOwner& owner );
+ void PropertyOwnerConnected( PropertyOwner& owner ) override;
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner )
*/
- void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner );
+ void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) override;
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner )
*/
- void PropertyOwnerDestroyed( PropertyOwner& owner );
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override;
private:
// Messages for RenderTask
inline void SetFrameBufferMessage( EventThreadServices& eventThreadServices, const RenderTask& task, Render::FrameBuffer* frameBuffer )
{
- typedef MessageValue1< RenderTask, Render::FrameBuffer*> LocalType;
+ using LocalType = MessageValue1<RenderTask, Render::FrameBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetClearColorMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector4& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector4 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector4>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeClearColorMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector4& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector4 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector4>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetClearEnabledMessage( EventThreadServices& eventThreadServices, const RenderTask& task, bool enabled )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetCullModeMessage( EventThreadServices& eventThreadServices, const RenderTask& task, bool mode )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRefreshRateMessage( EventThreadServices& eventThreadServices, const RenderTask& task, uint32_t refreshRate )
{
- typedef MessageValue1< RenderTask, uint32_t > LocalType;
+ using LocalType = MessageValue1<RenderTask, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
Node* node = const_cast< Node* >( constNode );
- typedef MessageValue1< RenderTask, Node* > LocalType;
+ using LocalType = MessageValue1<RenderTask, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetCameraMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Node* constNode, const Camera* constCamera )
{
- typedef MessageValue2< RenderTask, Node*, Camera* > LocalType;
+ using LocalType = MessageValue2<RenderTask, Node*, Camera*>;
Node* node = const_cast< Node* >( constNode );
Camera* camera = const_cast< Camera* >( constCamera );
inline void SetExclusiveMessage( EventThreadServices& eventThreadServices, const RenderTask& task, bool exclusive )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetSyncRequiredMessage(EventThreadServices& eventThreadServices, const RenderTask& task, bool requiresSync )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeViewportPositionMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector2& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector2 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector2>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeViewportSizeMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector2& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector2 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector2>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
if( mResendFlag & RESEND_DRAW_COMMANDS )
{
- typedef MessageValue2< Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t > DerivedType;
+ using DerivedType = MessageValue2<Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDrawCommands, mDrawCommands.data(), mDrawCommands.size() );
}
if( mResendFlag & RESEND_FACE_CULLING_MODE )
{
- typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, FaceCullingMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
}
if( mResendFlag & RESEND_BLEND_BIT_MASK )
{
- typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
}
if( mResendFlag & RESEND_BLEND_COLOR )
{
- typedef MessageValue1< Render::Renderer, Vector4 > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, Vector4>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor() );
}
if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA )
{
- typedef MessageValue1< Render::Renderer, bool > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, bool>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
}
if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
{
- typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
}
if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
{
- typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
}
if( mResendFlag & RESEND_DEPTH_WRITE_MODE )
{
- typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, DepthWriteMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode );
}
if( mResendFlag & RESEND_DEPTH_TEST_MODE )
{
- typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, DepthTestMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode );
}
if( mResendFlag & RESEND_DEPTH_FUNCTION )
{
- typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, DepthFunction::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction );
}
if( mResendFlag & RESEND_RENDER_MODE )
{
- typedef MessageValue1< Render::Renderer, RenderMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, RenderMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode );
}
if( mResendFlag & RESEND_STENCIL_FUNCTION )
{
- typedef MessageValue1< Render::Renderer, StencilFunction::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilFunction::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction );
}
if( mResendFlag & RESEND_STENCIL_FUNCTION_MASK )
{
- typedef MessageValue1< Render::Renderer, int > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask );
}
if( mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE )
{
- typedef MessageValue1< Render::Renderer, int > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference );
}
if( mResendFlag & RESEND_STENCIL_MASK )
{
- typedef MessageValue1< Render::Renderer, int > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask );
}
if( mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL )
{
- typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail );
}
if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL )
{
- typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail );
}
if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS )
{
- typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass );
}
if( mResendFlag & RESEND_SHADER )
{
- typedef MessageValue1< Render::Renderer, bool > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, bool>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetShaderChanged, true );
}
class SceneController;
class Renderer;
-typedef Dali::Vector< Renderer* > RendererContainer;
-typedef RendererContainer::Iterator RendererIter;
-typedef RendererContainer::ConstIterator RendererConstIter;
+using RendererContainer = Dali::Vector<Renderer*>;
+using RendererIter = RendererContainer::Iterator;
+using RendererConstIter = RendererContainer::ConstIterator;
class TextureSet;
class Geometry;
/**
* Destructor
*/
- virtual ~Renderer();
+ ~Renderer() override;
/**
* Overriden delete operator
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
*/
- virtual void UniformMappingsChanged( const UniformMap& mappings );
+ void UniformMappingsChanged( const UniformMap& mappings ) override;
public: // ConnectionChangePropagator::Observer
/**
* @copydoc ConnectionChangePropagator::ConnectionsChanged
*/
- virtual void ConnectionsChanged( PropertyOwner& owner );
+ void ConnectionsChanged( PropertyOwner& owner ) override;
/**
* @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
*/
- virtual void ConnectedUniformMapChanged( );
+ void ConnectedUniformMapChanged( ) override;
/**
* @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
*/
- virtual void ObservedObjectDestroyed(PropertyOwner& owner);
+ void ObservedObjectDestroyed(PropertyOwner& owner) override;
public: // PropertyOwner implementation
/**
/**
* @copydoc UniformMapDataProvider::GetUniformMapChanged
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const{ return mUniformMapChanged[bufferIndex];}
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override{ return mUniformMapChanged[bufferIndex];}
/**
* @copydoc UniformMapDataProvider::GetUniformMap
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const;
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override;
void SetDrawCommands( Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size );
/// Messages
inline void SetTexturesMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const TextureSet& textureSet )
{
- typedef MessageValue1< Renderer, TextureSet* > LocalType;
+ using LocalType = MessageValue1<Renderer, TextureSet*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Render::Geometry& geometry )
{
- typedef MessageValue1< Renderer, Render::Geometry* > LocalType;
+ using LocalType = MessageValue1<Renderer, Render::Geometry*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetShaderMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Shader& shader )
{
- typedef MessageValue1< Renderer, Shader* > LocalType;
+ using LocalType = MessageValue1<Renderer, Shader*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int depthIndex )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetFaceCullingModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, FaceCullingMode::Type faceCullingMode )
{
- typedef MessageValue1< Renderer, FaceCullingMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, FaceCullingMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBlendModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, BlendMode::Type blendingMode )
{
- typedef MessageValue1< Renderer, BlendMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, BlendMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBlendingOptionsMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t options )
{
- typedef MessageValue1< Renderer, uint32_t > LocalType;
+ using LocalType = MessageValue1<Renderer, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBlendColorMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Vector4& blendColor )
{
- typedef MessageValue1< Renderer, Vector4 > LocalType;
+ using LocalType = MessageValue1<Renderer, Vector4>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetIndexedDrawFirstElementMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t firstElement )
{
- typedef MessageValue1< Renderer, uint32_t > LocalType;
+ using LocalType = MessageValue1<Renderer, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetIndexedDrawElementsCountMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t elementsCount )
{
- typedef MessageValue1< Renderer, uint32_t > LocalType;
+ using LocalType = MessageValue1<Renderer, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetEnablePreMultipliedAlphaMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, bool preMultiplied )
{
- typedef MessageValue1< Renderer, bool > LocalType;
+ using LocalType = MessageValue1<Renderer, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthWriteModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthWriteMode::Type depthWriteMode )
{
- typedef MessageValue1< Renderer, DepthWriteMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, DepthWriteMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthTestModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthTestMode::Type depthTestMode )
{
- typedef MessageValue1< Renderer, DepthTestMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, DepthTestMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthFunctionMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthFunction::Type depthFunction )
{
- typedef MessageValue1< Renderer, DepthFunction::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, DepthFunction::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRenderModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, RenderMode::Type mode )
{
- typedef MessageValue1< Renderer, RenderMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, RenderMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilFunctionMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilFunction::Type stencilFunction )
{
- typedef MessageValue1< Renderer, StencilFunction::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilFunction::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilFunctionMaskMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int mask )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilFunctionReferenceMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilFunctionReference )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilMaskMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilMask )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilOperationOnFailMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation )
{
- typedef MessageValue1< Renderer, StencilOperation::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilOperationOnZFailMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation )
{
- typedef MessageValue1< Renderer, StencilOperation::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilOperationOnZPassMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation )
{
- typedef MessageValue1< Renderer, StencilOperation::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeOpacityMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, float opacity )
{
- typedef MessageDoubleBuffered1< Renderer, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<Renderer, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDrawCommandsMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size )
{
- typedef MessageValue2< Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t > LocalType;
+ using LocalType = MessageValue2<Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetTextureMessage( EventThreadServices& eventThreadServices, const TextureSet& textureSet, uint32_t index, Render::Texture* texture )
{
- typedef MessageValue2< TextureSet, uint32_t, Render::Texture* > LocalType;
+ using LocalType = MessageValue2<TextureSet, uint32_t, Render::Texture*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetSamplerMessage( EventThreadServices& eventThreadServices, const TextureSet& textureSet, uint32_t index, Render::Sampler* sampler )
{
- typedef MessageValue2< TextureSet, uint32_t, Render::Sampler* > LocalType;
+ using LocalType = MessageValue2<TextureSet, uint32_t, Render::Sampler*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
struct Vector3;
struct Vector4;
-typedef Rect<float> Padding; ///< Padding definition @SINCE_1_0.0
+using Padding = Rect<float>; ///< Padding definition @SINCE_1_0.0
/**
* @brief Actor is the primary object with which Dali applications interact.
// Typedefs
- typedef Signal< bool (Actor, const TouchEvent&) > TouchEventSignalType; ///< Touch signal type @SINCE_1_1.37
- typedef Signal< bool (Actor, const HoverEvent&) > HoverSignalType; ///< Hover signal type @SINCE_1_0.0
- typedef Signal< bool (Actor, const WheelEvent&) > WheelEventSignalType; ///< Wheel signal type @SINCE_1_0.0
- typedef Signal< void (Actor) > OnSceneSignalType; ///< Scene connection signal type @SINCE_1_9.24
- typedef Signal< void (Actor) > OffSceneSignalType; ///< Scene disconnection signal type @SINCE_1_9.24
- typedef Signal< void (Actor) > OnRelayoutSignalType; ///< Called when the actor is relaid out @SINCE_1_0.0
- typedef Signal< void ( Actor, LayoutDirection::Type ) > LayoutDirectionChangedSignalType; ///< Layout direction changes signal type. @SINCE_1_2.60
+ using TouchEventSignalType = Signal<bool( Actor, const TouchEvent& )>; ///< Touch signal type @SINCE_1_1.37
+ using HoverSignalType = Signal<bool( Actor, const HoverEvent& )>; ///< Hover signal type @SINCE_1_0.0
+ using WheelEventSignalType = Signal<bool( Actor, const WheelEvent& )>; ///< Wheel signal type @SINCE_1_0.0
+ using OnSceneSignalType = Signal<void( Actor )>; ///< Scene connection signal type @SINCE_1_9.24
+ using OffSceneSignalType = Signal<void( Actor )>; ///< Scene disconnection signal type @SINCE_1_9.24
+ using OnRelayoutSignalType = Signal<void( Actor )>; ///< Called when the actor is relaid out @SINCE_1_0.0
+ using LayoutDirectionChangedSignalType = Signal<void( Actor, LayoutDirection::Type )>; ///< Layout direction changes signal type. @SINCE_1_2.60
// Creation
* @brief Pointer to Dali::CustomActorImpl object.
* @SINCE_1_0.0
*/
-typedef IntrusivePtr<CustomActorImpl> CustomActorImplPtr;
+using CustomActorImplPtr = IntrusivePtr<CustomActorImpl>;
/**
* @brief CustomActorImpl is an abstract base class for custom control implementations.
* @brief Virtual destructor
* @SINCE_1_0.0
*/
- virtual ~CustomActorImpl();
+ ~CustomActorImpl() override;
public:
/**
* @SINCE_1_0.0
* @see Dali::Layer::SetClippingBox()
*/
-typedef Rect<int32_t> ClippingBox;
+using ClippingBox = Rect<int32_t>;
/**
* @brief Layers provide a mechanism for overlaying groups of actors on top of each other.
* @SINCE_1_0.0
* @param[in] position This is the actor translation from camera
*/
- typedef float (*SortFunctionType)( const Vector3& position );
+ using SortFunctionType = float ( * )( const Vector3& );
/**
* @brief Creates an empty Layer handle.
* @{
*/
-typedef float (*AlphaFunctionPrototype)(float progress); ///< Prototype of an alpha function @SINCE_1_0.0
+using AlphaFunctionPrototype = float ( * )( float ); ///< Prototype of an alpha function @SINCE_1_0.0
- /**
+/**
* @brief Alpha functions are used in animations to specify the rate of change of the animation parameter over time.
*
* Understanding an animation as a parametric function over time, the alpha function is applied to the parameter of
class DALI_CORE_API Animation : public BaseHandle
{
public:
+ using AnimationSignalType = Signal<void( Animation& )>; ///< Animation finished signal type @SINCE_1_0.0
- typedef Signal< void (Animation&) > AnimationSignalType; ///< Animation finished signal type @SINCE_1_0.0
-
- typedef Any AnyFunction; ///< Interpolation function @SINCE_1_0.0
+ using AnyFunction = Any; ///< Interpolation function @SINCE_1_0.0
/**
* @brief Enumeration for what to do when the animation ends, is stopped, or is destroyed.
class ConstraintBase;
}
-typedef Vector< PropertyInput* > PropertyInputContainer;
+using PropertyInputContainer = Vector<PropertyInput*>;
/**
* @brief An abstract base class for Constraints.
* @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.
class DALI_CORE_API VectorBase
{
public: // Typedefs
-
- typedef std::size_t SizeType;
+ using SizeType = std::size_t;
protected: // Construction
class VectorAlgorithms : public VectorBase
{
protected: // API for deriving classes
-
- typedef VectorBase::SizeType SizeType;
+ using SizeType = VectorBase::SizeType;
/**
* @brief Empty constructor.
* @brief Type definitions.
* @SINCE_1_0.0
*/
- typedef VectorBase::SizeType SizeType; ///< Size type @SINCE_1_0.0
- typedef T* Iterator; ///< Most simple Iterator is a pointer @SINCE_1_0.0
- typedef const T* ConstIterator; ///< Const iterator @SINCE_1_0.0
- typedef T ItemType; ///< Item type @SINCE_1_0.0
+ using SizeType = VectorBase::SizeType; ///< Size type @SINCE_1_0.0
+ using Iterator = T*; ///< Most simple Iterator is a pointer @SINCE_1_0.0
+ using ConstIterator = const T*; ///< Const iterator @SINCE_1_0.0
+ using ItemType = T; ///< Item type @SINCE_1_0.0
/**
* @brief Enumeration for BaseType.
*
* Objects can be implicitly converted to this for validity checks.
*/
- typedef void (IntrusivePtr::*BooleanType)() const;
+ using BooleanType = void ( IntrusivePtr<T>::* )() const;
/**
* @brief Converts an object handle to a BooleanType.
const uint32_t CORE_MAJOR_VERSION = 1;
const uint32_t CORE_MINOR_VERSION = 9;
-const uint32_t CORE_MICRO_VERSION = 27;
+const uint32_t CORE_MICRO_VERSION = 28;
const char * const CORE_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
class DALI_CORE_API LongPressGestureDetector : public GestureDetector
{
public: // Typedefs
-
- typedef Signal< void ( Actor, const LongPressGesture& ) > DetectedSignalType; ///< Gesture detected signal type @SINCE_1_0.0
+ using DetectedSignalType = Signal<void( Actor, const LongPressGesture& )>; ///< Gesture detected signal type @SINCE_1_0.0
public: // Creation & Destruction
};
// Typedefs
- typedef Signal< void ( Actor, const PanGesture& ) > DetectedSignalType; ///< Pan gesture detected signal type @SINCE_1_0.0
+ using DetectedSignalType = Signal<void( Actor, const PanGesture& )>; ///< Pan gesture detected signal type @SINCE_1_0.0
// Directional Pan
- typedef std::pair< Radian, Radian > AngleThresholdPair; ///< Range of angles for a direction @SINCE_1_0.0
+ using AngleThresholdPair = std::pair<Radian, Radian>; ///< Range of angles for a direction @SINCE_1_0.0
static const Radian DIRECTION_LEFT; ///< For a left pan (-PI Radians).
static const Radian DIRECTION_RIGHT; ///< For a right pan (0 Radians).
* @brief Signal type.
* @SINCE_1_0.0
*/
- typedef Signal< void ( Actor, const PinchGesture& ) > DetectedSignalType;
+ using DetectedSignalType = Signal<void( Actor, const PinchGesture& )>;
public: // Creation & Destruction
/**
* @brief Signal type.
*/
- typedef Signal< void ( Actor, const RotationGesture& ) > DetectedSignalType;
+ using DetectedSignalType = Signal<void( Actor, const RotationGesture& )>;
public: // Creation & Destruction
* @brief Signal type for detected signal.
* @SINCE_1_0.0
*/
- typedef Signal< void ( Actor, const TapGesture& ) > DetectedSignalType;
+ using DetectedSignalType = Signal<void( Actor, const TapGesture& )>;
public: // Creation & Destruction
* This can only be used for images of up to 65535 x 65535 pixels.
* @SINCE_1_0.0
*/
-typedef Dali::Uint16Pair ImageDimensions;
+using ImageDimensions = Dali::Uint16Pair;
/**
* @brief Fitting options, used when resizing images to fit desired dimensions.
* The implementation should destroy the NativeImage resources.
* @SINCE_1_0.0
*/
- virtual ~NativeImageInterface()
+ ~NativeImageInterface() override
{
}
* @brief Size is an alias of Dali::Vector2.
* @SINCE_1_0.0
*/
-typedef Vector2 Size;
+using Size = Vector2;
/**
* @brief Print a Vector2.
* @brief Typedef for a viewport ( a rectangle representing a screen area ).
* @SINCE_1_0.0
*/
-typedef Rect<int32_t> Viewport;
+using Viewport = Rect<int32_t>;
/**
* @}
}
struct AnyContainerBase; // Forward declaration for typedef
- typedef AnyContainerBase* (*CloneFunc)( const AnyContainerBase& base );
- typedef void (*DeleteFunc)( const AnyContainerBase* base );
+ using CloneFunc = AnyContainerBase* (*)( const AnyContainerBase& );
+
+ using DeleteFunc = void ( * )( const AnyContainerBase* );
/**
* @brief Base container to hold type for match verification and instance cloning function.
* @brief Pointer-to-member type.
* Objects can be implicitly converted to this for validity checks.
*/
- typedef void (BaseHandle::*BooleanType)() const;
+ using BooleanType = void ( BaseHandle::* )() const;
/**
* @brief Converts an handle to a BooleanType.
* @brief A reference counted object may only be deleted by calling Unreference().
* @SINCE_1_0.0
*/
- virtual ~BaseObject();
+ ~BaseObject() override;
/**
* @brief Registers the object as created with the Object registry.
* @brief Object created signal.
* @SINCE_1_0.0
*/
- typedef Signal< void ( BaseHandle ) > ObjectCreatedSignalType;
+ using ObjectCreatedSignalType = Signal<void( BaseHandle )>;
/**
* @brief Object destroyed signal.
* @SINCE_1_0.0
*/
- typedef Signal< void ( const Dali::RefObject* ) > ObjectDestroyedSignalType;
+ using ObjectDestroyedSignalType = Signal<void( const Dali::RefObject* )>;
/**
* @brief Allows the creation of an empty objectRegistry handle.
class DALI_CORE_API Property::Array
{
public:
-
- typedef std::size_t SizeType;
+ using SizeType = std::size_t;
/**
* @brief Default constructor.
{
typedef std::vector< StringValuePair > StringValueContainer;
-typedef std::pair< Property::Index, Property::Value > IndexValuePair;
-typedef std::vector< IndexValuePair > IndexValueContainer;
+using IndexValuePair = std::pair<Property::Index, Property::Value>;
+using IndexValueContainer = std::vector<IndexValuePair>;
}; // unnamed namespace
* @{
*/
-typedef std::pair< Property::Key, Property::Value > KeyValuePair;
-typedef std::pair<std::string, Property::Value> StringValuePair;
+using KeyValuePair = std::pair<Property::Key, Property::Value>;
+using StringValuePair = std::pair<std::string, Property::Value>;
/**
* @brief A Map of property values, the key type could be String or Property::Index.
class DALI_CORE_API Property::Map
{
public:
-
- typedef std::size_t SizeType;
+ using SizeType = std::size_t;
/**
* @brief Default constructor.
* @brief Signal type for Dali::PropertyNotification::NotifySignal().
* @SINCE_1_0.0
*/
-typedef Signal< void (PropertyNotification& source) > PropertyNotifySignalType;
+using PropertyNotifySignalType = Signal<void( PropertyNotification& )>;
/**
* @}
class Matrix;
struct Extents;
-typedef std::pair< Property::Key, Property::Value > KeyValuePair;
+using KeyValuePair = std::pair<Property::Key, Property::Value>;
/**
* @brief A value-type representing a property value.
* @brief A valid property index is zero or greater.
* @SINCE_1_0.0
*/
- typedef int32_t Index;
+ using Index = int32_t;
static constexpr int32_t INVALID_INDEX{-1}; ///< -1 is not a valid property index
static constexpr int32_t INVALID_KEY{-1}; ///< -1 is not a valid property key
static constexpr int32_t INVALID_COMPONENT_INDEX{-1}; ///< -1 is not a valid property index
- typedef Dali::Vector< Index > IndexContainer; ///< A vector of property indices @SINCE_1_0.0
+ using IndexContainer = Dali::Vector<Index>; ///< A vector of property indices @SINCE_1_0.0
/**
* @brief A value-type representing a property value.
}
// Destruction
- ~Impl()
+ ~Impl() override
{
Reset();
}
/**
* From BaseObject::Impl::Observer
*/
- virtual void ObjectDestroyed( BaseObject& object )
+ void ObjectDestroyed( BaseObject& object ) override
{
mObject = nullptr;
}
* @brief Typedef for signals sent by this class.
* @SINCE_1_0.0
*/
- typedef Signal< void (RenderTask& source) > RenderTaskSignalType;
+ using RenderTaskSignalType = Signal<void( RenderTask& )>;
/**
* @brief A pointer to a function for converting screen to frame-buffer coordinates.
* @param[in,out] coordinates The screen coordinates to convert where (0,0) is the top-left of the screen
* @return True if the conversion was successful, otherwise coordinates should be unmodified
*/
- typedef bool (* ScreenToFrameBufferFunction)( Vector2& coordinates );
+ using ScreenToFrameBufferFunction = bool ( * )( Vector2& );
/**
* @brief A pointer to a function for converting screen to frame-buffer coordinates.
* @param[in,out] coordinates The screen coordinates to convert where (0,0) is the top-left of the screen
* @return True if the conversion was successful, otherwise coordinates should be unmodified
*/
- typedef bool (* const ConstScreenToFrameBufferFunction)( Vector2& coordinates );
+ using ConstScreenToFrameBufferFunction = bool ( *const )( Vector2& );
/**
* @brief The default conversion function returns false for any screen coordinates.
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~BaseSignal();
+ ~BaseSignal() override;
/**
* @brief Queries whether there are any connected slots.
/**
* @copydoc SlotObserver::SlotDisconnected
*/
- virtual void SlotDisconnected( CallbackBase* callback );
+ void SlotDisconnected( CallbackBase* callback ) override;
private:
// the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef R(*Dispatcher)(CallbackBase& base);
+ using Dispatcher = R ( * )( CallbackBase& );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
returnVal = (*dispatcher)( callback );
}
else if( !callback.mImpl && callback.mFunction )
{
- typedef R(*Function1)();
+ using Function1 = R ( * )();
returnVal = (*(reinterpret_cast< Function1 >( callback.mFunction )))();
}
// so the library containing the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef void(*Dispatcher)(CallbackBase& base,P1);
+ using Dispatcher = void ( * )( CallbackBase&, P1 );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
(*dispatcher)( callback, param1 );
}
else if( !callback.mImpl && callback.mFunction )
{
// convert function type
- typedef void(*Function1)(P1);
+ using Function1 = void ( * )( P1 );
(*(reinterpret_cast< Function1 >( callback.mFunction )))( param1 );
}
}
// so the library containing the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef R(*Dispatcher)(CallbackBase& base,P1);
+ using Dispatcher = R ( * )( CallbackBase&, P1 );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
returnVal = (*dispatcher)( callback, param1 );
}
else if( !callback.mImpl && callback.mFunction )
{
// convert function type
- typedef R(*Function1)(P1);
+ using Function1 = R ( * )( P1 );
returnVal = (*(reinterpret_cast< Function1 >( callback.mFunction )))( param1 );
}
// so the library containing the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef void(*Dispatcher)(CallbackBase& base,P1,P2);
+ using Dispatcher = void ( * )( CallbackBase&, P1, P2 );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
(*dispatcher)( callback, param1, param2 );
}
else if( !callback.mImpl && callback.mFunction )
{
// convert function type
- typedef void(*Function2)(P1,P2);
+ using Function2 = void ( * )( P1, P2 );
(*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2 );
}
}
// so the library containing the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef R(*Dispatcher)(CallbackBase& base,P1,P2);
+ using Dispatcher = R ( * )( CallbackBase&, P1, P2 );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
returnVal = (*dispatcher)( callback, param1, param2 );
}
else if( !callback.mImpl && callback.mFunction )
{
// convert function type
- typedef R(*Function2)(P1,P2);
+ using Function2 = R ( * )( P1, P2 );
returnVal = (*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2 );
}
// so the library containing the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef void(*Dispatcher)(CallbackBase& base,P1,P2,P3);
+ using Dispatcher = void ( * )( CallbackBase&, P1, P2, P3 );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
(*dispatcher)( callback, param1, param2, param3 );
}
else if( !callback.mImpl && callback.mFunction )
{
// convert function type
- typedef void(*Function2)(P1,P2,P3);
+ using Function2 = void ( * )( P1, P2, P3 );
(*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2, param3 );
}
}
// so the library containing the code has to be loaded, otherwise we crash boom bang
if( callback.mImpl && callback.mImpl->mObjectPointer )
{
- typedef R(*Dispatcher)(CallbackBase& base,P1,P2,P3);
+ using Dispatcher = R ( * )( CallbackBase&, P1, P2, P3 );
Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
returnVal = (*dispatcher)( callback, param1, param2, param3 );
}
else if( !callback.mImpl && callback.mFunction )
{
// convert function type
- typedef R(*Function2)(P1,P2,P3);
+ using Function2 = R ( * )( P1, P2, P3 );
returnVal = (*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2, param3 );
}
* @brief Function with static linkage.
* @SINCE_1_0.0
*/
- typedef void(*Function)(void);
+ using Function = void ( * )();
/**
* @brief Member function.
* @SINCE_1_0.0
*/
- typedef void (CallbackBase::*MemberFunction)( void );
+ using MemberFunction = void ( CallbackBase::* )();
/**
* @brief Used to call the correct member function.
* @SINCE_1_0.0
*/
- typedef void (*Dispatcher)( CallbackBase& base );
+ using Dispatcher = void ( * )( CallbackBase& );
/**
* @brief Used to destroy mObjectPointer (NULL if not mObjectPointer is not owned).
* @SINCE_1_0.0
*/
- typedef void(*Destructor)(void* object);
+ using Destructor = void ( * )( void* );
/**
* @brief Copy constructor operator not declared.
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)();
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(P1);
+ using MemberFunction = void ( T::* )( P1 );
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)( param1 );
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(P1, P2);
+ using MemberFunction = void ( T::* )( P1, P2 );
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)( param1, param2 );
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(P1, P2, P3);
+ using MemberFunction = void ( T::* )( P1, P2, P3 );
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)( param1, param2, param3 );
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(void);
+ using MemberFunction = R ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
return (object->*function)();
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(P1);
+ using MemberFunction = R ( T::* )( P1 );
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
return (object->*function)( param1 );
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(P1, P2);
+ using MemberFunction = R ( T::* )( P1, P2 );
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
return (object->*function)( param1, param2 );
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(P1, P2, P3);
+ using MemberFunction = R ( T::* )( P1, P2, P3 );
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
return (object->*function)( param1, param2, param3 );
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)();
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
}
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
return R();
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
return R();
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
return R();
{
// "downcast" the object and function type back to the correct ones
T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
+ using MemberFunction = void ( T::* )();
MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
(object->*function)(/*ignore params*/);
return R();
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~ConnectionTrackerInterface();
+ ~ConnectionTrackerInterface() override;
/**
* @brief Called when a signal is connected.
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~ConnectionTracker();
+ ~ConnectionTracker() override;
/**
* @brief Disconnects all signals from this object.
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
/**
* @brief Returns the connection count.
* @brief Used to call the correct function.
* @SINCE_1_0.0
*/
- typedef void (*Dispatcher)( void* objectPtr );
+ using Dispatcher = void ( * )( void* );
/**
* @brief Used to destroy mObjectPointer.
* @SINCE_1_0.0
*/
- typedef void(*Destructor)( void* objectPtr );
+ using Destructor = void ( * )( void* );
/**
* @brief Not defined.
*/
class RelayoutContainer;
-typedef RelayoutContainer* RelayoutContainerPtr;
-
+using RelayoutContainerPtr = RelayoutContainer*;
/**
* @brief Interface to encapsulate information required for relayout.
Name: dali2
Summary: DALi 3D Engine
-Version: 1.9.27
+Version: 1.9.28
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-core.git / commitdiff