this patch is auto generated by clang-tidy using 'modernize-use-using' check.
Change-Id: I269203c391d6a676db65a28ac7dd4b19301bdbd1
} // 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.
// 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:
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.
/* 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
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.
class MessageValue1 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)( typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P>::PassingType );
/**
* Create a message.
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.
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.
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.
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.
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.
class MessageDoubleBuffered0 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)( BufferIndex );
+ using MemberFunction = void ( T::* )( BufferIndex );
/**
* Create a message.
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.
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.
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.
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.
/**
* 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.
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:
class Layer;
}
-typedef Dali::ClippingBox ClippingBox;
+using ClippingBox = Dali::ClippingBox;
class Layer : public Actor
{
{
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.
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
{
typedef Dali::Vector<Object*> ObjectContainer;
-typedef ObjectContainer::Iterator ObjectIter;
+using ObjectIter = ObjectContainer::Iterator;
/**
* An abstract base class for constrainers.
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.
{
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),
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
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
}
};
-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)
{
namespace Internal
{
-typedef IntrusivePtr<Path> PathPtr;
+using PathPtr = IntrusivePtr<Path>;
/**
* A 3D path
template <class P>
struct PropertyConstraintPtr
{
- typedef OwnerPointer< PropertyConstraint<P> > Type;
+ using Type = OwnerPointer<PropertyConstraint<P> >;
};
} // namespace Internal
}
}
-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.
class ObjectRegistry;
-typedef IntrusivePtr<ObjectRegistry> ObjectRegistryPtr;
+using ObjectRegistryPtr = IntrusivePtr<ObjectRegistry>;
/**
* The ObjectRegistry notifies it's observers when an object is created.
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.
class Stage;
-typedef Stage* StagePtr;
+using StagePtr = Stage *;
} // Internal
// 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
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;
-
- typedef std::vector< ActionPair > ActionContainer;
- typedef std::vector< ConnectionPair > ConnectorContainer;
- typedef std::vector< RegisteredPropertyPair > RegisteredPropertyContainer;
- typedef std::vector< PropertyDefaultValuePair > PropertyDefaultValueContainer;
+ 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>;
+
+ 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.
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* @brief ShaderFactory loads and saves shader binaries synchronously.
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*>;
};
/**
{
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
Scene* mScene;
};
-typedef IntrusivePtr<GestureRecognizer> GestureRecognizerPtr;
+using GestureRecognizerPtr = IntrusivePtr<GestureRecognizer>;
} // namespace Internal
{
class HoverEvent;
-typedef IntrusivePtr< HoverEvent > HoverEventPtr;
+using HoverEventPtr = IntrusivePtr<HoverEvent>;
/**
* @copydoc Dali::HoverEvent
class LongPressGestureDetector;
-typedef IntrusivePtr<LongPressGestureDetector> LongPressGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<LongPressGestureDetector>::type LongPressGestureDetectorContainer;
+using LongPressGestureDetectorPtr = IntrusivePtr<LongPressGestureDetector>;
+using LongPressGestureDetectorContainer = DerivedGestureDetectorContainer<LongPressGestureDetector>::type;
/**
* @copydoc Dali::LongPressGestureDetector
{
class LongPressGesture;
-typedef IntrusivePtr< LongPressGesture > LongPressGesturePtr;
+using LongPressGesturePtr = IntrusivePtr<LongPressGesture>;
/**
* @copydoc Dali::LongPressGesture
{
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
{
class PanGesture;
-typedef IntrusivePtr< PanGesture > PanGesturePtr;
+using PanGesturePtr = IntrusivePtr<PanGesture>;
/**
* @copydoc Dali::PanGesture
class PinchGestureDetector;
-typedef IntrusivePtr<PinchGestureDetector> PinchGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<PinchGestureDetector>::type PinchGestureDetectorContainer;
+using PinchGestureDetectorPtr = IntrusivePtr<PinchGestureDetector>;
+using PinchGestureDetectorContainer = DerivedGestureDetectorContainer<PinchGestureDetector>::type;
/**
* @copydoc Dali::PinchGestureDetector
{
class PinchGesture;
-typedef IntrusivePtr< PinchGesture > PinchGesturePtr;
+using PinchGesturePtr = IntrusivePtr<PinchGesture>;
/**
* @copydoc Dali::PinchGesture
class RotationGestureDetector;
-typedef IntrusivePtr<RotationGestureDetector> RotationGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<RotationGestureDetector>::type RotationGestureDetectorContainer;
+using RotationGestureDetectorPtr = IntrusivePtr<RotationGestureDetector>;
+using RotationGestureDetectorContainer = DerivedGestureDetectorContainer<RotationGestureDetector>::type;
/**
* @copydoc Dali::RotationGestureDetector
{
class RotationGesture;
-typedef IntrusivePtr< RotationGesture > RotationGesturePtr;
+using RotationGesturePtr = IntrusivePtr<RotationGesture>;
/**
* @copydoc Dali::RotationGesture
class TapGestureDetector;
-typedef IntrusivePtr<TapGestureDetector> TapGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<TapGestureDetector>::type TapGestureDetectorContainer;
+using TapGestureDetectorPtr = IntrusivePtr<TapGestureDetector>;
+using TapGestureDetectorContainer = DerivedGestureDetectorContainer<TapGestureDetector>::type;
/**
* @copydoc Dali::TapGestureDetector
{
class TapGesture;
-typedef IntrusivePtr< TapGesture > TapGesturePtr;
+using TapGesturePtr = IntrusivePtr<TapGesture>;
/**
* @copydoc Dali::TapGesture
{
class TouchEvent;
-typedef IntrusivePtr< TouchEvent > TouchEventPtr;
+using TouchEventPtr = IntrusivePtr<TouchEvent>;
/**
* @copydoc Dali::TouchEvent
{
class WheelEvent;
-typedef IntrusivePtr< WheelEvent > WheelEventPtr;
+using WheelEventPtr = IntrusivePtr<WheelEvent>;
/**
* @copydoc Dali::WheelEvent
{
class BitmapCompressed;
-typedef IntrusivePtr<BitmapCompressed> BitmapCompressedPtr;
+using BitmapCompressedPtr = IntrusivePtr<BitmapCompressed>;
/**
* BitmapCompressed class.
{
class BitmapPackedPixel;
-typedef IntrusivePtr<BitmapPackedPixel> BitmapPackedPixelPtr;
+using BitmapPackedPixelPtr = IntrusivePtr<BitmapPackedPixel>;
/**
* BitmapPackedPixel class.
{
class PixelData;
-typedef IntrusivePtr<PixelData> PixelDataPtr;
+using PixelDataPtr = IntrusivePtr<PixelData>;
class PixelData : public BaseObject
{
}
class FrameBuffer;
-typedef IntrusivePtr<FrameBuffer> FrameBufferPtr;
+using FrameBufferPtr = IntrusivePtr<FrameBuffer>;
class FrameBuffer : public BaseObject
{
}
class Geometry;
-typedef IntrusivePtr<Geometry> GeometryPtr;
+using GeometryPtr = IntrusivePtr<Geometry>;
/**
* Geometry is an object that contains an array of structures of values that
}
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.
}
class Sampler;
-typedef IntrusivePtr<Sampler> SamplerPtr;
+using SamplerPtr = IntrusivePtr<Sampler>;
/**
* Sampler is an object that contains an array of structures of values that
}
class Shader;
-typedef IntrusivePtr<Shader> ShaderPtr;
+using ShaderPtr = IntrusivePtr<Shader>;
/**
* Shader is an object that contains an array of structures of values that
}
class Texture;
-typedef IntrusivePtr<Texture> TexturePtr;
+using TexturePtr = IntrusivePtr<Texture>;
class Texture : public BaseObject
{
class TextureSet;
-typedef IntrusivePtr<TextureSet> TextureSetPtr;
+using TextureSetPtr = IntrusivePtr<TextureSet>;
/**
* TextureSet is an object that holds all the textures used by a renderer
{
class VertexBuffer;
-typedef IntrusivePtr<VertexBuffer> VertexBufferPtr;
+using VertexBufferPtr = IntrusivePtr<VertexBuffer>;
/**
* VertexBuffer is an object that contains an array of structures of values that
{
// 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 );
bool Contains( const Dali::Actor& actor );
private:
-
- typedef Vector< RelayoutInfo* > RelayoutInfoContainer;
+ using RelayoutInfoContainer = Vector<RelayoutInfo*>;
RelayoutInfoContainer mRelayoutInfos; ///< The list of relayout infos
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.
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();
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
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
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
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
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.
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.
class AnimatablePropertyComponentMessage : public PropertyOwnerMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
/**
* Send a message.
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)
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 ) );
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;
// 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
/**
* 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
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->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 ) );
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 ) );
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.
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.
class NodePropertyComponentMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
/**
* Send a message.
class NodeTransformPropertyMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(TransformManagerPropertyHandler<P>::*MemberFunction)( BufferIndex, const P& );
+ using MemberFunction = void ( TransformManagerPropertyHandler<P>::* )( BufferIndex, const P& );
/**
* Create a message.
class NodeTransformComponentMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(TransformManagerPropertyHandler<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( TransformManagerPropertyHandler<P>::* )( BufferIndex, float );
/**
* Send a message.
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
*/
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 ) );
// 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;
/// 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.
* @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.
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.
* @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 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.
* @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.
// 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 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.