this patch is auto generated by clang-tidy with modernize-use-override.
Change-Id: Id2a6abb4a6ce9725bd870dc6a846e8cea33b37ae
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Bitmap();
+ ~Bitmap() override;
protected:
/**
* Virtual destructor
*/
- virtual ~HoverEvent();
+ ~HoverEvent() override;
};
} // namespace Integration
/**
* Virtual destructor
*/
- virtual ~KeyEvent();
+ ~KeyEvent() override;
// Data
/**
* Virtual destructor
*/
- virtual ~MultiPointEvent();
+ ~MultiPointEvent() override;
protected:
/**
/**
* Virtual destructor
*/
- virtual ~TouchEvent();
+ ~TouchEvent() override;
};
} // namespace Integration
/**
* Virtual destructor
*/
- virtual ~WheelEvent();
+ ~WheelEvent() override;
// Data
/**
* Destructor
*/
- ~Core();
+ ~Core() override;
/**
* @copydoc Dali::Integration::Core::Initialize()
/**
* Virtual destructor
*/
- virtual ~Message()
+ ~Message() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)();
}
/**
* Virtual destructor
*/
- virtual ~MessageValue1()
+ ~MessageValue1() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1 );
}
/**
* Virtual destructor
*/
- virtual ~MessageValue2()
+ ~MessageValue2() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2 );
}
/**
* Virtual destructor
*/
- virtual ~MessageValue3()
+ ~MessageValue3() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3 );
}
/**
* Virtual destructor
*/
- virtual ~MessageValue4()
+ ~MessageValue4() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4 );
}
/**
* Virtual destructor
*/
- virtual ~MessageValue5()
+ ~MessageValue5() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4, param5 );
}
/**
* Virtual destructor
*/
- virtual ~MessageValue6()
+ ~MessageValue6() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4, param5, param6 );
}
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered0()
+ ~MessageDoubleBuffered0() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex );
}
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered1()
+ ~MessageDoubleBuffered1() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param );
}
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered2()
+ ~MessageDoubleBuffered2() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3 );
}
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered3()
+ ~MessageDoubleBuffered3() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3, param4 );
}
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered4()
+ ~MessageDoubleBuffered4() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3, param4, param5 );
}
* Protected Destructor
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~ShaderData()
+ ~ShaderData() override
{
// vector releases its data
}
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Actor();
+ ~Actor() override;
/**
* Called on a child during Add() when the parent actor is connected to the Scene.
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* @copydoc Dali::Internal::Object::SetSceneGraphProperty()
*/
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
+ void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
*/
- virtual int32_t GetPropertyComponentIndex( Property::Index index ) const;
+ int32_t GetPropertyComponentIndex( Property::Index index ) const override;
/**
* Retrieve the actor's node.
* Retrieve the parent object of an Actor.
* @return The parent object, or NULL if the Actor does not have a parent.
*/
- virtual Object* GetParentObject() const;
+ Object* GetParentObject() const override;
/**
* Set Sibling order
/**
* copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~CameraActor();
+ ~CameraActor() override;
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~CustomActor();
+ ~CustomActor() override;
private:
/**
* @copydoc Internal::Actor::OnSceneConnectionExternal
*/
- virtual void OnSceneConnectionExternal( int32_t depth )
+ void OnSceneConnectionExternal( int32_t depth ) override
{
mImpl->OnSceneConnection( depth );
}
/**
* @copydoc Internal::Actor::OnSceneDisconnectionExternal
*/
- virtual void OnSceneDisconnectionExternal()
+ void OnSceneDisconnectionExternal() override
{
mImpl->OnSceneDisconnection();
}
/**
* @copydoc Internal::Actor::OnChildAdd
*/
- virtual void OnChildAdd(Actor& child)
+ void OnChildAdd(Actor& child) override
{
Dali::Actor handle(&child);
mImpl->OnChildAdd(handle);
/**
* @copydoc Internal::Actor::OnChildRemove
*/
- virtual void OnChildRemove(Actor& child)
+ void OnChildRemove(Actor& child) override
{
Dali::Actor handle(&child);
mImpl->OnChildRemove(handle);
/**
* @copydoc Internal::Actor::OnPropertySet
*/
- virtual void OnPropertySet( Property::Index index, const Property::Value& propertyValue )
+ void OnPropertySet( Property::Index index, const Property::Value& propertyValue ) override
{
mImpl->OnPropertySet(index, propertyValue);
}
/**
* @copydoc Internal::Actor::OnSizeSet
*/
- virtual void OnSizeSet(const Vector3& targetSize)
+ void OnSizeSet(const Vector3& targetSize) override
{
mImpl->OnSizeSet(targetSize);
}
/**
* @copydoc Internal::Actor::OnSizeAnimation
*/
- virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize)
+ void OnSizeAnimation(Animation& animation, const Vector3& targetSize) override
{
Dali::Animation animationHandle(&animation);
mImpl->OnSizeAnimation(animationHandle, targetSize);
/**
* @copydoc Internal::Actor::OnRelayout
*/
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
+ void OnRelayout( const Vector2& size, RelayoutContainer& container ) override
{
mImpl->OnRelayout( size, container );
}
/**
* @copydoc Internal::Actor::OnSetResizePolicy
*/
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+ void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) override
{
mImpl->OnSetResizePolicy( policy, dimension );
}
/**
* @copydoc Internal::Actor::GetNaturalSize
*/
- virtual Vector3 GetNaturalSize() const
+ Vector3 GetNaturalSize() const override
{
return mImpl->GetNaturalSize();
}
/**
* @copydoc Internal::Actor::CalculateChildSize
*/
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+ float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) override
{
return mImpl->CalculateChildSize( child, dimension );
}
/**
* @copydoc Internal::Actor::GetHeightForWidth
*/
- virtual float GetHeightForWidth( float width )
+ float GetHeightForWidth( float width ) override
{
return mImpl->GetHeightForWidth( width );
}
/**
* @copydoc Internal::Actor::GetWidthForHeight
*/
- virtual float GetWidthForHeight( float height )
+ float GetWidthForHeight( float height ) override
{
return mImpl->GetWidthForHeight( height );
}
/**
* @copydoc Internal::Actor::RelayoutDependentOnChildren
*/
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
+ bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) override
{
return mImpl->RelayoutDependentOnChildren( dimension );
}
/**
* @copydoc Internal::Actor::OnCalculateRelayoutSize
*/
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
+ void OnCalculateRelayoutSize( Dimension::Type dimension ) override
{
return mImpl->OnCalculateRelayoutSize( dimension );
}
/**
* @copydoc Internal::Actor::OnLayoutNegotiated
*/
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
+ void OnLayoutNegotiated( float size, Dimension::Type dimension ) override
{
return mImpl->OnLayoutNegotiated( size, dimension );
}
/**
* @copydoc Dali::Internal::Actor::OnInitialize
*/
- void OnInitialize();
+ void OnInitialize() override;
/**
* Query the current depth of the layer
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Layer();
+ ~Layer() override;
private: // From Actor
/**
* From Actor.
*/
- virtual void OnSceneConnectionInternal();
+ void OnSceneConnectionInternal() override;
/**
* From Actor.
*/
- virtual void OnSceneDisconnectionInternal();
+ void OnSceneDisconnectionInternal() override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Animation();
+ ~Animation() override;
private:
/**
* Virtual destructor.
*/
- virtual ~AnimationPlaylist();
+ ~AnimationPlaylist() override;
/**
* Called when an animation is constructed.
/**
* @copydoc CompleteNotificationInterface::NotifyCompleted()
*/
- virtual void NotifyCompleted();
+ void NotifyCompleted() override;
private:
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnectorBase()
+ ~AnimatorConnectorBase() override
{
if( mObject )
{
/**
* From Object::Observer
*/
- virtual void SceneObjectAdded( Object& object ) override final
+ void SceneObjectAdded( Object& object ) final
{
// If the animator has not been created yet, create it now.
if( !mAnimator && mObject )
/**
* From Object::Observer
*/
- virtual void SceneObjectRemoved( Object& object ) override final
+ void SceneObjectRemoved( Object& object ) final
{
}
/**
* From Object::Observer
*/
- virtual void ObjectDestroyed( Object& object )
+ void ObjectDestroyed( Object& object ) override
{
mObject = nullptr;
}
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnector()
+ ~AnimatorConnector() override
{
}
/**
* @copydoc AnimatorConnectorBase::DoCreateAnimator()
*/
- bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) override final
+ bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) final
{
bool resetterRequired = false;
// components only supported for float property type
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnector()
+ ~AnimatorConnector() override
{
}
/**
* @copydoc AnimatorConnectorBase::DoCreateAnimator()
*/
- bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) override final
+ bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) final
{
bool resetterRequired = false;
if( mComponentIndex == Property::INVALID_COMPONENT_INDEX )
/**
* Virtual destructor.
*/
- virtual ~Constrainer();
+ ~Constrainer() override;
public: // Object::Observer methods
/**
* @copydoc Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object ){}
+ void SceneObjectAdded( Object& object ) override{}
/**
* @copydoc Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object ){}
+ void SceneObjectRemoved( Object& object ) override{}
/**
* @copydoc Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
public:
/**
* Virtual destructor.
*/
- virtual ~ConstraintBase();
+ ~ConstraintBase() override;
/**
* Adds a constraint source to the constraint
/**
* @copydoc Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object );
+ void SceneObjectAdded( Object& object ) override;
/**
* @copydoc Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object );
+ void SceneObjectRemoved( Object& object ) override;
/**
* @copydoc Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
// This is not responsible for removing constraints.
}
/**
* @copydoc ConstraintBase::DoClone()
*/
- ConstraintBase* DoClone( Object& object ) override final
+ ConstraintBase* DoClone( Object& object ) final
{
ConstraintFunctionPtr funcPtr( mUserFunction->Clone() );
return new Constraint( object,
/**
* @copydoc ConstraintBase::ConnectConstraint()
*/
- void ConnectConstraint() override final
+ void ConnectConstraint() final
{
// Should not come here if target object has been destroyed
DALI_ASSERT_DEBUG( nullptr != mTargetObject );
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
// This is not responsible for removing constraints.
}
/**
* @copydoc ConstraintBase::DoClone()
*/
- virtual ConstraintBase* DoClone( Object& object ) override final
+ ConstraintBase* DoClone( Object& object ) final
{
ConstraintFunctionPtr funcPtr( mUserFunction->Clone() );
return new Constraint( object,
/**
* @copydoc ConstraintBase::ConnectConstraint()
*/
- void ConnectConstraint() override final
+ void ConnectConstraint() final
{
// Should not come here if target object has been destroyed
DALI_ASSERT_DEBUG( nullptr != mTargetObject );
}
- virtual ~KeyFrameChannel()
+ ~KeyFrameChannel() override
{
}
- bool IsActive (float progress);
+ bool IsActive (float progress) override;
V GetValue(float progress, Dali::Animation::Interpolation interpolation) const;
KeyFrames();
protected:
- virtual ~KeyFrames();
+ ~KeyFrames() override;
private:
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~KeyFrameSpec() {}
+ ~KeyFrameSpec() override {}
};
/**
* Destructor. Ensure progress value pairs are cleared down
*/
- virtual ~KeyFrameBaseSpec<V>()
+ ~KeyFrameBaseSpec<V>() override
{
delete mKeyFrames;
mPVs.clear();
* Get the number of key frames
* @return The size of the progress value vector
*/
- virtual std::size_t GetNumberOfKeyFrames() const
+ std::size_t GetNumberOfKeyFrames() const override
{
return mPVs.size();
}
/**
* @copydoc KeyFrameSpec::GetKeyFrameAsValue()
*/
- virtual void GetKeyFrameAsValue( std::size_t index, Property::Value& value )
+ void GetKeyFrameAsValue( std::size_t index, Property::Value& value ) override
{
value = mPVs[index].mValue;
}
/**
* virtual destructor
*/
- virtual ~LinearConstrainer();
+ ~LinearConstrainer() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
public:
/**
* @copydoc Dali::PathConstrainer::Apply
*/
- void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap );
+ void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap ) override;
private:
/**
* virtual destructor
*/
- virtual ~PathConstrainer();
+ ~PathConstrainer() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
public:
/**
* @copydoc Dali::PathConstrainer::Apply
*/
- void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap );
+ void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap ) override;
private:
/**
* virtual destructor
*/
- virtual ~Path();
+ ~Path() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
public:
/**
* Virtual Destructor
*/
- virtual ~PropertyInputIndexer()
+ ~PropertyInputIndexer() override
{
}
/**
* @copydoc Dali::Internal::PropertyInput::GetType()
*/
- virtual Property::Type GetType() const
+ Property::Type GetType() const override
{
return mInput->GetType();
}
/**
* @copydoc Dali::Internal::PropertyInput::GetBoolean()
*/
- virtual const bool& GetBoolean() const
+ const bool& GetBoolean() const override
{
return mInput->GetConstraintInputBoolean( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetInteger()
*/
- virtual const int& GetInteger() const
+ const int& GetInteger() const override
{
return mInput->GetConstraintInputInteger( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetFloat()
*/
- virtual const float& GetFloat() const
+ const float& GetFloat() const override
{
return mInput->GetConstraintInputFloat( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2() const
+ const Vector2& GetVector2() const override
{
return mInput->GetConstraintInputVector2( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3() const
+ const Vector3& GetVector3() const override
{
return mInput->GetConstraintInputVector3( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4() const
+ const Vector4& GetVector4() const override
{
return mInput->GetConstraintInputVector4( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetMatrix3()
*/
- virtual const Matrix3& GetMatrix3() const
+ const Matrix3& GetMatrix3() const override
{
return mInput->GetConstraintInputMatrix3( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetMatrix()
*/
- virtual const Matrix& GetMatrix() const
+ const Matrix& GetMatrix() const override
{
return mInput->GetConstraintInputMatrix( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::Quaternion()
*/
- virtual const Quaternion& GetQuaternion() const
+ const Quaternion& GetQuaternion() const override
{
return mInput->GetConstraintInputQuaternion( mBufferIndex );
}
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Object();
+ ~Object() override;
/**
* Called immediately by derived classes, after the scene-object has been created & passed to the scene-graph.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- ~ObjectRegistry();
+ ~ObjectRegistry() override;
private:
/**
* Virtual destructor
*/
- virtual ~PropertyCondition();
+ ~PropertyCondition() override;
private:
/**
* @brief Destructor.
*/
- virtual ~AnimatablePropertyMetadata()
+ ~AnimatablePropertyMetadata() override
{
}
/**
* @brief Destructor.
*/
- virtual ~CustomPropertyMetadata()
+ ~CustomPropertyMetadata() override
{
}
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PropertyNotification();
+ ~PropertyNotification() override;
private:
/**
* Virtual destructor.
*/
- virtual ~PropertyNotificationManager();
+ ~PropertyNotificationManager() override;
/**
* Called when a PropertyNotification is constructed.
/**
* @copydoc PropertyNotifier::NotifyProperty
*/
- virtual void NotifyProperty( SceneGraph::PropertyNotification* propertyNotification, bool validity );
+ void NotifyProperty( SceneGraph::PropertyNotification* propertyNotification, bool validity ) override;
private:
/**
* virtual destructor
*/
- virtual ~Scene();
+ ~Scene() override;
/**
* @copydoc Dali::Integration::Scene::Add
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() override;
private:
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() override;
// Layers
/**
* @copydoc Dali::Integration::NotifyContextLost();
*/
- virtual void NotifyContextLost();
+ void NotifyContextLost() override;
/**
* @copydoc Dali::Integration::NotifyContextRegained();
*/
- virtual void NotifyContextRegained();
+ void NotifyContextRegained() override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Stage();
+ ~Stage() override;
private:
/**
* Virtual Destructor
*/
- virtual ~ThreadLocalStorage();
+ ~ThreadLocalStorage() override;
// Undefined
ThreadLocalStorage( const ThreadLocalStorage& );
/**
* Destructor
*/
- virtual ~TypeInfo();
+ ~TypeInfo() override;
/**
* @copydoc Dali::TypeInfo::GetName
private:
TypeRegistry();
- ~TypeRegistry();
+ ~TypeRegistry() override;
/**
* @brief Undefined Copy Constructor
/**
* Destructor
*/
- virtual ~ShaderFactory();
+ ~ShaderFactory() override;
/**
* @brief Looks for precompiled binary version of shader program in memory and file caches.
* @param[in] shader The data to be saved.
* @sa Load
*/
- virtual void SaveBinary( Internal::ShaderDataPtr shader );
+ void SaveBinary( Internal::ShaderDataPtr shader ) override;
private:
/**
* Non virtual destructor
*/
- ~ActorObserver();
+ ~ActorObserver() override;
// Movable
* @param[in] object The object object.
* @see Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object );
+ void SceneObjectAdded( Object& object ) override;
/**
* This will be called when the actor is removed from the scene.
* @param[in] object The object object.
* @see Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object );
+ void SceneObjectRemoved( Object& object ) override;
/**
* This will be called when the actor is destroyed. We should clear the actor.
* No need to stop observing as the object is being destroyed anyway.
* @see Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
private:
Actor* mActor; ///< Raw pointer to an Actor.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~GestureDetector();
+ ~GestureDetector() override;
private:
/**
* @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded(Object& object);
+ void SceneObjectAdded(Object& object) override;
/**
* @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectRemoved(Object& object) {}
+ void SceneObjectRemoved(Object& object) override {}
/**
* @copydoc Dali::Internal::Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed(Object& object);
+ void ObjectDestroyed(Object& object) override;
/**
* For use in derived classes, called after an actor is attached.
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Gesture() = default;
+ ~Gesture() override = default;
private:
GestureType::Value mGestureType;
{
}
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->IsGestureRequired( mType ) && // Does the Application or derived actor type require the gesture?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsTouchConsumed();
}
/**
* Virtual protected destructor.
*/
- virtual ~GestureProcessor();
+ ~GestureProcessor() override;
// Methods to be used by deriving classes
* @param[in] object The object object.
* @see Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded(Object& object) { }
+ void SceneObjectAdded(Object& object) override { }
/**
* This will be called when the actor is removed from the stage, we should clear and stop
* @param[in] object The object object.
* @see Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved(Object& object);
+ void SceneObjectRemoved(Object& object) override;
/**
* This will be called when the actor is destroyed. We should clear the actor.
* No need to stop observing as the object is being destroyed anyway.
* @see Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed(Object& object);
+ void ObjectDestroyed(Object& object) override;
protected: //Data
/**
* Virtual destructor.
*/
- virtual ~GestureRecognizer() {}
+ ~GestureRecognizer() override {}
protected:
Vector2 mScreenSize;
/**
* Virtual destructor
*/
- virtual ~PanGestureRequest()
+ ~PanGestureRequest() override
{
}
/**
* Virtual destructor
*/
- virtual ~TapGestureRequest()
+ ~TapGestureRequest() override
{
}
/**
* Virtual destructor
*/
- virtual ~LongPressGestureRequest()
+ ~LongPressGestureRequest() override
{
}
{
}
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::CHECK_ACTOR );
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE );
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
// Layer::IsTouchConsumed() focuses on touch only. Here we are a wrapper for the public-api
// where the caller may want to check for something completely different.
*/
struct ActorTouchableCheck : public HitTestInterface
{
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->GetTouchRequired() && // Does the Application or derived actor type require a touch event?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsTouchConsumed();
}
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~HoverEvent() = default;
+ ~HoverEvent() override = default;
// Not copyable or movable
*/
struct ActorHoverableCheck : public HitTestAlgorithm::HitTestInterface
{
- bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->GetHoverRequired() && // Does the Application or derived actor type require a hover event?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsHoverConsumed();
}
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~KeyEvent() = default;
+ ~KeyEvent() override = default;
// Not copyable or movable
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~LongPressGestureDetector();
+ ~LongPressGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~LongPressGestureEvent();
+ ~LongPressGestureEvent() override;
// Data
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~LongPressGesture() = default;
+ ~LongPressGesture() override = default;
private:
Vector2 mScreenPoint;
/**
* Non-virtual destructor; LongPressGestureProcessor is not a base class
*/
- ~LongPressGestureProcessor();
+ ~LongPressGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the long press gesture event occurs in.
* @param[in] longPressEvent The event that has occurred.
*/
- void Process( Scene& scene, const LongPressGestureEvent& longPressEvent );
+ void Process( Scene& scene, const LongPressGestureEvent& longPressEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~LongPressGestureRecognizer();
+ ~LongPressGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
/**
* @brief This method sets the minimum holding time required to be recognized as a long press gesture
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PanGestureDetector();
+ ~PanGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
// Default property extensions from Object
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
private:
/**
* Virtual destructor
*/
- virtual ~PanGestureEvent();
+ ~PanGestureEvent() override;
// Data
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PanGesture() = default;
+ ~PanGesture() override = default;
private:
Vector2 mVelocity;
/**
* Destructor
*/
- virtual ~PanGestureProcessor();
+ ~PanGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the pan gesture event occurs in.
* @param[in] panEvent The event that has occurred.
*/
- void Process( Scene& scene, const PanGestureEvent& panEvent );
+ void Process( Scene& scene, const PanGestureEvent& panEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~PanGestureRecognizer();
+ ~PanGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PinchGestureDetector();
+ ~PinchGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~PinchGestureEvent();
+ ~PinchGestureEvent() override;
// Data
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PinchGesture() = default;
+ ~PinchGesture() override = default;
private:
Vector2 mScreenCenterPoint;
/**
* Non-virtual destructor; PinchGestureProcessor is not a base class
*/
- ~PinchGestureProcessor();
+ ~PinchGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the pinch gesture event occurs in.
* @param[in] pinchEvent The event that has occurred.
*/
- void Process( Scene& scene, const PinchGestureEvent& pinchEvent );
+ void Process( Scene& scene, const PinchGestureEvent& pinchEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~PinchGestureRecognizer();
+ ~PinchGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RotationGestureDetector() = default;
+ ~RotationGestureDetector() override = default;
private: // GestureDetector overrides
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach( Actor& actor ) { /* Nothing to do */ }
+ void OnActorAttach( Actor& actor ) override { /* Nothing to do */ }
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach( Actor& actor ) { /* Nothing to do */ }
+ void OnActorDetach( Actor& actor ) override { /* Nothing to do */ }
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed( Object& object ) { /* Nothing to do */ }
+ void OnActorDestroyed( Object& object ) override { /* Nothing to do */ }
private:
/**
* Virtual destructor
*/
- virtual ~RotationGestureEvent() = default;
+ ~RotationGestureEvent() override = default;
// Data
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RotationGesture() = default;
+ ~RotationGesture() override = default;
private:
Radian mRotation;
/**
* Non-virtual destructor; RotationGestureProcessor is not a base class
*/
- ~RotationGestureProcessor() = default;
+ ~RotationGestureProcessor() override = default;
RotationGestureProcessor( const RotationGestureProcessor& ) = delete; ///< Deleted copy constructor.
RotationGestureProcessor& operator=( const RotationGestureProcessor& rhs ) = delete; ///< Deleted copy assignment operator.
* @param[in] scene The scene the rotation gesture event occurs in.
* @param[in] rotationEvent The event that has occurred.
*/
- void Process( Scene& scene, const RotationGestureEvent& rotationEvent );
+ void Process( Scene& scene, const RotationGestureEvent& rotationEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~RotationGestureRecognizer() = default;
+ ~RotationGestureRecognizer() override = default;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent( const Integration::TouchEvent& event );
+ void SendEvent( const Integration::TouchEvent& event ) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update( const GestureRequest& request ) { /* Nothing to do */ }
+ void Update( const GestureRequest& request ) override { /* Nothing to do */ }
/**
* Sets the minimum touch events required before a rotation can be started
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TapGestureDetector();
+ ~TapGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~TapGestureEvent();
+ ~TapGestureEvent() override;
// Data
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TapGesture() = default;
+ ~TapGesture() override = default;
private:
Vector2 mScreenPoint;
/**
* Non-virtual destructor; TapGestureProcessor is not a base class
*/
- ~TapGestureProcessor();
+ ~TapGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the tap gesture event occurs in.
* @param[in] tapEvent The event that has occurred.
*/
- void Process( Scene& scene, const TapGestureEvent& event);
+ void Process( Scene& scene, const TapGestureEvent& event) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection() { /* Nothing to do */ }
+ void OnGesturedActorStageDisconnection() override { /* Nothing to do */ }
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~TapGestureRecognizer();
+ ~TapGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TouchEvent() = default;
+ ~TouchEvent() override = default;
private:
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~WheelEvent() = default;
+ ~WheelEvent() override = default;
// Not copyable or movable
*/
BitmapCompressed( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN );
- virtual const Bitmap::CompressedProfile* GetCompressedProfile() const { return this; }
- virtual Bitmap::CompressedProfile* GetCompressedProfile() { return this; }
+ const Bitmap::CompressedProfile* GetCompressedProfile() const override { return this; }
+ Bitmap::CompressedProfile* GetCompressedProfile() override { return this; }
private:
/**
* @param[in] bufferSize Buffer size in bytes
* @return pixel buffer pointer
*/
- virtual Dali::Integration::PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
+ Dali::Integration::PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
const uint32_t width,
const uint32_t height,
- const uint32_t numBytes );
+ const uint32_t numBytes ) override;
/**
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
*/
- virtual uint32_t GetBufferSize() const
+ uint32_t GetBufferSize() const override
{
return mBufferSize;
}
/**
* See Dali::Integration::Bitmap::GetReleaseFunction()
*/
- ReleaseFunction GetReleaseFunction(){ return FREE; }
+ ReleaseFunction GetReleaseFunction() override{ return FREE; }
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~BitmapCompressed();
+ ~BitmapCompressed() override;
private:
BitmapPackedPixel( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
public:
- virtual const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const { return this; }
- virtual Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() { return this; }
+ const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const override { return this; }
+ Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() override { return this; }
/**
* (Re-)Allocate pixel buffer for the Bitmap. Any previously allocated pixel buffer is deleted.
* @param[in] bufferHeight Buffer height in pixels
* @return pixel buffer pointer
*/
- virtual Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
+ Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
uint32_t width,
uint32_t height,
uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0);
+ uint32_t bufferHeight = 0) override;
/**
* Assign a pixel buffer. Any previously allocated pixel buffer is deleted.
* @param[in] bufferWidth Buffer width (stride) in pixels
* @param[in] bufferHeight Buffer height in pixels
*/
- virtual void AssignBuffer(Pixel::Format pixelFormat,
+ void AssignBuffer(Pixel::Format pixelFormat,
Dali::Integration::PixelBuffer* buffer,
uint32_t bufferSize,
uint32_t width,
uint32_t height,
uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0);
+ uint32_t bufferHeight = 0) override;
/**
* Get the width of the buffer (stride)
* @return The width of the buffer in pixels
*/
- virtual unsigned GetBufferWidth() const
+ unsigned GetBufferWidth() const override
{
return mBufferWidth;
}
* Get the height of the buffer
* @return The height of the buffer in pixels
*/
- virtual unsigned GetBufferHeight() const
+ unsigned GetBufferHeight() const override
{
return mBufferHeight;
}
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
*/
- virtual uint32_t GetBufferSize() const
+ uint32_t GetBufferSize() const override
{
return mBufferWidth * mBytesPerPixel * mBufferHeight;
}
/**
* See Dali::Integration::Bitmap::GetReleaseFunction()
*/
- ReleaseFunction GetReleaseFunction(){ return FREE; }
+ ReleaseFunction GetReleaseFunction() override{ return FREE; }
/**
* Get the pixel buffer stride.
* @return The buffer stride (in bytes).
*/
- virtual uint32_t GetBufferStride() const;
+ uint32_t GetBufferStride() const override;
/**
* Get the pixel format
* Check the bitmap data and test whether it has any transparent pixels.
* This property can then be tested for with IsFullyOpaque().
*/
- virtual void TestForTransparency();
+ void TestForTransparency() override;
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~BitmapPackedPixel();
+ ~BitmapPackedPixel() override;
protected:
*
* Release the pixel buffer if exists.
*/
- ~PixelData();
+ ~PixelData() override;
public:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
public: //signals
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RenderTask();
+ ~RenderTask() override;
private: // not copyable
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RenderTaskList();
+ ~RenderTaskList() override;
/**
* 2nd-phase construction
/**
* @copydoc CompleteNotificationInterface::NotifyCompleted()
*/
- virtual void NotifyCompleted();
+ void NotifyCompleted() override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~FrameBuffer();
+ ~FrameBuffer() override;
/**
* @brief Get the FrameBuffer render object
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Geometry();
+ ~Geometry() override;
private: // unimplemented methods
Geometry( const Geometry& );
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @brief Adds a draw command to the Renderer.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Renderer();
+ ~Renderer() override;
private: // unimplemented methods
Renderer( const Renderer& );
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Sampler();
+ ~Sampler() override;
private: // data
EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via the update thread
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
private: // implementation
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Shader();
+ ~Shader() override;
private: // unimplemented methods
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Texture();
+ ~Texture() override;
private: // unimplemented methods
Texture( const Texture& );
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TextureSet();
+ ~TextureSet() override;
private: // unimplemented methods
TextureSet( const TextureSet& );
/**
* @brief Destructor
*/
- ~VertexBuffer();
+ ~VertexBuffer() override;
private: // implementation
/**
/**
* Virtual destructor
*/
- virtual ~MemoryPoolRelayoutContainer();
+ ~MemoryPoolRelayoutContainer() override;
/**
* @brief Add relayout information to the container if it does'nt already exist
* @param actor The actor to relayout
* @param size The size to relayout
*/
- virtual void Add( const Dali::Actor& actor, const Vector2& size );
+ void Add( const Dali::Actor& actor, const Vector2& size ) override;
/**
* @brief Remove information from the container
/**
* Destructor
*/
- virtual ~RelayoutController();
+ ~RelayoutController() override;
/**
* @brief Get the singleton of RelayoutController object.
/**
* @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMapChanged()
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const = 0;
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override = 0;
/**
* @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMap()
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const = 0;
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override = 0;
protected:
/**
* Virtual destructor, this is an interface, no deletion through this interface
*/
- virtual ~NodeDataProvider() { }
+ ~NodeDataProvider() override { }
};
} // SceneGraph
/**
* @copydoc Dali::Internal::GlResourceOwner::GlContextDestroyed()
*/
- void GlContextDestroyed();
+ void GlContextDestroyed() override;
/**
* @copydoc Dali::Internal::GlResourceOwner::GlCleanup()
*/
- void GlCleanup();
+ void GlCleanup() override;
/**
* Create a new renderer instance
/**
* Destructor
*/
- ~Renderer();
+ ~Renderer() override;
/**
* Set the face-culling mode.
/**
* Destructor, non virtual as not a base class
*/
- ~ProgramController();
+ ~ProgramController() override;
public: // API
/**
* @copydoc ProgramCache::GetGlAbstraction
*/
- virtual Integration::GlAbstraction& GetGlAbstraction();
+ Integration::GlAbstraction& GetGlAbstraction() override;
/**
* @copydoc ProgramCache::GetProgram
*/
- virtual Program* GetProgram( size_t shaderHash );
+ Program* GetProgram( size_t shaderHash ) override;
/**
* @copydoc ProgramCache::AddProgram
*/
- virtual void AddProgram( size_t shaderHash, Program* program );
+ void AddProgram( size_t shaderHash, Program* program ) override;
/**
* @copydoc ProgramCache::GetCurrentProgram
*/
- virtual Program* GetCurrentProgram();
+ Program* GetCurrentProgram() override;
/**
* @copydoc ProgramCache::SetCurrentProgram
*/
- virtual void SetCurrentProgram( Program* program );
+ void SetCurrentProgram( Program* program ) override;
/**
* @copydoc ProgramCache::IsBinarySupported
*/
- virtual bool IsBinarySupported();
+ bool IsBinarySupported() override;
/**
* @copydoc ProgramCache::ProgramBinaryFormat
*/
- virtual GLenum ProgramBinaryFormat();
+ GLenum ProgramBinaryFormat() override;
/**
* @copydoc ProgramCache::StoreBinary
*/
- virtual void StoreBinary( Internal::ShaderDataPtr programData );
+ void StoreBinary( Internal::ShaderDataPtr programData ) override;
private: // not implemented as non-copyable
/**
* Virtual destructor
*/
- virtual ~Shader();
+ ~Shader() override;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The following methods are called during Update
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
*/
- virtual void UniformMappingsChanged( const UniformMap& mappings );
+ void UniformMappingsChanged( const UniformMap& mappings ) override;
private: // Data
/**
* Virtual destructor.
*/
- virtual ~AnimatorBase()
+ ~AnimatorBase() override
{
delete mAnimatorFunction;
if (mPropertyOwner && mConnectedToSceneGraph)
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner )
*/
- void PropertyOwnerConnected( PropertyOwner& owner ) override final
+ void PropertyOwnerConnected( PropertyOwner& owner ) final
{
mEnabled = true;
}
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
*/
- void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override final
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) final
{
// If we are active, then bake the value if required
if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::DISCARD )
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner )
*/
- void PropertyOwnerDestroyed( PropertyOwner& owner ) override final
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) final
{
mPropertyOwner = nullptr;
}
/**
* Virtual destructor.
*/
- virtual ~Animator()
+ ~Animator() override
{
}
/**
* @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final
+ void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) final
{
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
/**
* Virtual destructor.
*/
- virtual ~AnimatorTransformProperty()
+ ~AnimatorTransformProperty() override
{
}
/**
* @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final
+ void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) final
{
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const int32_t& property)
+ float operator()(float alpha, const int32_t& property) override
{
// integers need to be correctly rounded
return roundf(static_cast<float>( property ) + static_cast<float>( mRelative ) * alpha );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const int32_t& property)
+ float operator()(float alpha, const int32_t& property) override
{
// integers need to be correctly rounded
return roundf(static_cast<float>( property ) + (static_cast<float>(mTarget - property) * alpha) );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const float& property)
+ float operator()(float alpha, const float& property) override
{
return float(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const float& property)
+ float operator()(float alpha, const float& property) override
{
return float(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float alpha, const Vector2& property)
+ Vector2 operator()(float alpha, const Vector2& property) override
{
return Vector2(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float alpha, const Vector2& property)
+ Vector2 operator()(float alpha, const Vector2& property) override
{
return Vector2(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float alpha, const Vector3& property)
+ Vector3 operator()(float alpha, const Vector3& property) override
{
return Vector3(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float alpha, const Vector3& property)
+ Vector3 operator()(float alpha, const Vector3& property) override
{
return Vector3(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
return Vector4(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
return Vector4(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
Vector4 result(property);
result.a += mRelative * alpha;
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
Vector4 result(property);
result.a = property.a + ((mTarget - property.a) * alpha);
}
using AnimatorFunctionBase::operator();
- bool operator()(float alpha, const bool& property)
+ bool operator()(float alpha, const bool& property) override
{
// Alpha is not useful here, just keeping to the same template as other update functors
return bool(alpha >= 1.0f ? (property || mRelative) : property);
}
using AnimatorFunctionBase::operator();
- bool operator()(float alpha, const bool& property)
+ bool operator()(float alpha, const bool& property) override
{
// Alpha is not useful here, just keeping to the same template as other update functors
return bool(alpha >= 1.0f ? mTarget : property);
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float alpha, const Quaternion& rotation)
+ Quaternion operator()(float alpha, const Quaternion& rotation) override
{
if (alpha > 0.0f)
{
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float alpha, const Quaternion& rotation)
+ Quaternion operator()(float alpha, const Quaternion& rotation) override
{
return Quaternion::Slerp(rotation, mTarget, alpha);
}
}
using AnimatorFunctionBase::operator();
- bool operator()(float progress, const bool& property)
+ bool operator()(float progress, const bool& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- float operator()(float progress, const int32_t& property)
+ float operator()(float progress, const int32_t& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- float operator()(float progress, const float& property)
+ float operator()(float progress, const float& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float progress, const Vector2& property)
+ Vector2 operator()(float progress, const Vector2& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float progress, const Vector3& property)
+ Vector3 operator()(float progress, const Vector3& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float progress, const Vector4& property)
+ Vector4 operator()(float progress, const Vector4& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float progress, const Quaternion& property)
+ Quaternion operator()(float progress, const Quaternion& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float progress, const Vector3& property)
+ Vector3 operator()(float progress, const Vector3& property) override
{
Vector3 position(property);
static_cast<void>( mPath->SamplePosition(progress, position) );
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float progress, const Quaternion& property)
+ Quaternion operator()(float progress, const Quaternion& property) override
{
Vector3 tangent;
if( mPath->SampleTangent(progress, tangent) )
/**
* Virtual destructor.
*/
- virtual ~ConstraintBase();
+ ~ConstraintBase() override;
/**
* Property resetter observes the lifecycle of this object
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected()
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner )
+ void PropertyOwnerConnected( PropertyOwner& owner ) override
{
}
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*/
- virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
{
if ( !mDisconnected )
{
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed()
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override
{
if ( !mDisconnected )
{
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::ConstraintBase::Apply()
*/
- virtual void Apply( BufferIndex updateBufferIndex )
+ void Apply( BufferIndex updateBufferIndex ) override
{
if ( !mDisconnected )
{
/**
* @copydoc Dali::Internal::SceneGraph::ConstraintBase::OnDisconnect()
*/
- virtual void OnDisconnect()
+ void OnDisconnect() override
{
// Discard target object/property pointers
mTargetProperty.Reset();
/**
* Virtual destructor.
*/
- virtual ~AnimatablePropertyBase()
+ ~AnimatablePropertyBase() override
{}
protected: // for derived classes
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
*/
- virtual bool IsClean() const
+ bool IsClean() const override
{
return ( CLEAN_FLAG == mDirtyFlags );
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true; // Animatable properties are always valid
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<bool>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetBoolean()
*/
- virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
+ const bool& GetBoolean( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<int>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetInteger()
*/
- virtual const int& GetInteger( BufferIndex bufferIndex ) const
+ const int& GetInteger( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<float>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetFloat()
*/
- virtual const float& GetFloat( BufferIndex bufferIndex ) const
+ const float& GetFloat( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector2>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
+ const Vector2& GetVector2( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector4>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetVector4( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix3>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix3()
*/
- virtual const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const
+ const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~InheritedVector3()
+ ~InheritedVector3() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector3()
*/
- virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedColor()
+ ~InheritedColor() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector4>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetVector4( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector4()
*/
- virtual const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedQuaternion()
+ ~InheritedQuaternion() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
*/
- virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedMatrix()
+ ~InheritedMatrix() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetConstraintInputMatrix()
*/
- virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~PropertyBase();
+ ~PropertyBase() override;
/**
* Reset the property to a base value; only required if the property is animated.
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* Virtual destructor
*/
- virtual ~PropertyOwnerMessageBase();
+ ~PropertyOwnerMessageBase() override;
private:
/**
* Virtual destructor
*/
- virtual ~AnimatablePropertyMessage()
+ ~AnimatablePropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
/**
* Virtual destructor
*/
- virtual ~AnimatablePropertyComponentMessage()
+ ~AnimatablePropertyComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
/**
* Virtual Destructor
*/
- virtual ~PropertyResetterBase()
+ ~PropertyResetterBase() override
{
if( mPropertyOwner != nullptr )
{
*
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner ) override
+ void PropertyOwnerConnected( PropertyOwner& owner ) override
{
mDisconnected = false;
mActive = ACTIVE;
* @param[in] bufferIndex the current buffer index
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
{
mDisconnected = true;
}
* Called shortly before the propertyOwner is destroyed
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) override
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override
{
mDisconnected = true;
mPropertyOwner = nullptr;
/**
* Virtual destructor.
*/
- virtual ~Resetter()
+ ~Resetter() override
{
// Disconnect from modifier object. Although this resetter should match the lifecycle of the modifier object,
// there are situations where it is deleted first (e.g. if the property owner is destroyed)
/**
* The Animator or Constraint is destroyed
*/
- virtual void ObjectDestroyed() override
+ void ObjectDestroyed() override
{
// When the modifier is destroyed, reduce the running value to ensure we stay alive for
// another frame to reset the other buffer.
/**
* Destructor
*/
- virtual ~SceneControllerImpl();
+ ~SceneControllerImpl() override;
public: // from SceneController
/**
* @copydoc SceneController::GetRenderMessageDispatcher()
*/
- virtual RenderMessageDispatcher& GetRenderMessageDispatcher() { return mRenderMessageDispatcher; }
+ RenderMessageDispatcher& GetRenderMessageDispatcher() override { return mRenderMessageDispatcher; }
/**
* @copydoc SceneController::GetRenderQueue()
*/
- virtual RenderQueue& GetRenderQueue() { return mRenderQueue; }
+ RenderQueue& GetRenderQueue() override { return mRenderQueue; }
/**
* @copydoc SceneController::GetDiscardQueue()
*/
- virtual DiscardQueue& GetDiscardQueue() { return mDiscardQueue; }
+ DiscardQueue& GetDiscardQueue() override { return mDiscardQueue; }
private:
/**
* Virtual destructor.
*/
- virtual ~GestureProperty()
+ ~GestureProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get< T >();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return true;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return mInputChanged;
}
/**
* Virtual destructor.
*/
- virtual ~GesturePropertyVector2()
+ ~GesturePropertyVector2() override
{
}
/**
* @copydoc Dali::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
+ const Vector2& GetVector2( BufferIndex bufferIndex ) const override
{
return mValue;
}
/**
* Virtual destructor.
*/
- virtual ~GesturePropertyBool()
+ ~GesturePropertyBool() override
{
}
/**
* @copydoc Dali::PropertyInput::GetBoolean()
*/
- virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
+ const bool& GetBoolean( BufferIndex bufferIndex ) const override
{
return mValue;
}
/**
* Virtual destructor
*/
- virtual ~PanGesture();
+ ~PanGesture() override;
/**
* Adds a PanGesture to the internal circular-buffer waiting to be handled by UpdateProperties.
/**
* Non-virtual Destructor.
*/
- ~FrameCallback();
+ ~FrameCallback() override;
/**
* Called from the update-thread when connecting to the scene-graph.
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected()
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner ) { /* Nothing to do */ }
+ void PropertyOwnerConnected( PropertyOwner& owner ) override { /* Nothing to do */ }
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*/
- virtual void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) { /* Nothing to do */ }
+ void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) override { /* Nothing to do */ }
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*
* Will use this to disconnect the frame-callback if the accompanying node is destroyed
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner );
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override;
// Construction
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const = 0;
+ Dali::Property::Type GetType() const override = 0;
/**
* @copydoc Dali::SceneGraph::AnimatableProperty::Get()
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const{ return Vector3::ZERO; }
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override{ return Vector3::ZERO; }
/**
* Retrieve a component of property
/**
* @copydoc Dali::AnimatableProperty::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex){}
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override{}
/**
* @copydoc Dali::AnimatableProperty::IsClean()
*/
- virtual bool IsClean() const{ return false; }
+ bool IsClean() const override{ return false; }
/**
* Initializes the property
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
mProperty( property )
{}
- Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
- Vector3& Get( BufferIndex bufferIndex )
+ Vector3& Get( BufferIndex bufferIndex ) override
{
return mTxManager->GetVector3PropertyValue( mId, mProperty );
}
- const Vector3& Get( BufferIndex bufferIndex ) const
+ const Vector3& Get( BufferIndex bufferIndex ) const override
{
return mTxManager->GetVector3PropertyValue( mId, mProperty );
}
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return Get(bufferIndex);
}
- const float& GetFloatComponent( uint32_t component )
+ const float& GetFloatComponent( uint32_t component ) override
{
return mTxManager->GetVector3PropertyComponentValue( mId, mProperty, component );
}
- void Set(BufferIndex bufferIndex, const Vector3& value)
+ void Set(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->SetVector3PropertyValue( mId, mProperty, value );
}
mTxManager->BakeVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void Bake(BufferIndex bufferIndex, const Vector3& value)
+ void Bake(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeVector3PropertyValue(mId, mProperty, value );
}
- void BakeX(BufferIndex bufferIndex, float value)
+ void BakeX(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeXVector3PropertyValue(mId, mProperty, value );
}
- void BakeY(BufferIndex bufferIndex, float value)
+ void BakeY(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeYVector3PropertyValue(mId, mProperty, value );
}
- void BakeZ(BufferIndex bufferIndex, float value)
+ void BakeZ(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeZVector3PropertyValue(mId, mProperty, value );
}
- void SetFloatComponent( float value, uint32_t component)
+ void SetFloatComponent( float value, uint32_t component) override
{
mTxManager->SetVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void BakeFloatComponent( float value, uint32_t component )
+ void BakeFloatComponent( float value, uint32_t component ) override
{
mTxManager->BakeVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void BakeRelative(BufferIndex bufferIndex, const Vector3& value)
+ void BakeRelative(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeRelativeVector3PropertyValue(mId, mProperty, value );
}
- void BakeRelativeMultiply(BufferIndex bufferIndex, const Vector3& value)
+ void BakeRelativeMultiply(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeMultiplyVector3PropertyValue(mId, mProperty, value );
}
:TransformManagerPropertyHandler()
{}
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
- Quaternion& Get( BufferIndex bufferIndex )
+ Quaternion& Get( BufferIndex bufferIndex ) override
{
return mTxManager->GetQuaternionPropertyValue( mId );
}
- const Quaternion& Get( BufferIndex bufferIndex ) const
+ const Quaternion& Get( BufferIndex bufferIndex ) const override
{
return mTxManager->GetQuaternionPropertyValue( mId );
}
- const float& GetFloatComponent( uint32_t component)
+ const float& GetFloatComponent( uint32_t component) override
{
return mTxManager->GetQuaternionPropertyValue( mId ).mVector[component];
}
- void Set(BufferIndex bufferIndex, const Quaternion& value)
+ void Set(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->SetQuaternionPropertyValue( mId, value );
}
- void Bake(BufferIndex bufferIndex, const Quaternion& value)
+ void Bake(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->BakeQuaternionPropertyValue( mId, value );
}
- void BakeRelative(BufferIndex bufferIndex, const Quaternion& value)
+ void BakeRelative(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->BakeRelativeQuaternionPropertyValue( mId, value );
}
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return Get(bufferIndex);
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerVector3Input()
+ ~TransformManagerVector3Input() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector3()
*/
- virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerQuaternionInput()
+ ~TransformManagerQuaternionInput() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
*/
- virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerMatrixInput()
+ ~TransformManagerMatrixInput() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
if( mTxManager )
{
/**
* @copydoc Dali::PropertyInput::GetConstraintInputMatrix()
*/
- virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const override
{
if( mTxManager )
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
/**
* Destructor.
*/
- virtual ~UpdateManager();
+ ~UpdateManager() override;
// Node connection methods
* @brief Accept compiled shaders passed back on render thread for saving.
* @param[in] shaderData Source code, hash over source, and corresponding compiled binary to be saved.
*/
- virtual void SaveBinary( Internal::ShaderDataPtr shaderData );
+ void SaveBinary( Internal::ShaderDataPtr shaderData ) override;
/**
* @brief Set the destination for compiled shader binaries to be passed on to.
/**
* Virtual destructor
*/
- virtual ~IndexBufferMessage()
+ ~IndexBufferMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
DALI_ASSERT_DEBUG( mManager && "Message does not have an object" );
mManager->SetIndexBuffer( mRenderGeometry, mIndices );
/**
* Virtual destructor
*/
- virtual ~NodePropertyMessageBase();
+ ~NodePropertyMessageBase() override;
private:
/**
* Virtual destructor
*/
- virtual ~NodePropertyMessage()
+ ~NodePropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
/**
* Virtual destructor
*/
- virtual ~NodePropertyComponentMessage()
+ ~NodePropertyComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
/**
* Virtual destructor
*/
- virtual ~NodeTransformPropertyMessage()
+ ~NodeTransformPropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
/**
* Virtual destructor
*/
- virtual ~NodeTransformComponentMessage()
+ ~NodeTransformComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
* @param[in] updated The updated flag
* (used for partial rendering to mark an animating sub tree for example).
*/
- virtual void SetUpdated(bool updated)
+ void SetUpdated(bool updated) override
{
mUpdated = updated;
/**
* @copydoc UniformMap::Add
*/
- void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map );
+ void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map ) override;
/**
* @copydoc UniformMap::Remove
*/
- void RemoveUniformMapping( const std::string& uniformName );
+ void RemoveUniformMapping( const std::string& uniformName ) override;
/**
* Prepare the node for rendering.
* Protected virtual destructor; See also Node::Delete( Node* )
* Kept protected to allow destructor chaining from layer
*/
- virtual ~Node();
+ ~Node() override;
private: // from NodeDataProvider
/**
* @copydoc NodeDataProvider::GetModelMatrix
*/
- virtual const Matrix& GetModelMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetModelMatrix( BufferIndex bufferIndex ) const override
{
return GetWorldMatrix( bufferIndex );
}
/**
* @copydoc NodeDataProvider::GetRenderColor
*/
- virtual const Vector4& GetRenderColor( BufferIndex bufferIndex ) const
+ const Vector4& GetRenderColor( BufferIndex bufferIndex ) const override
{
return GetWorldColor( bufferIndex );
}
/**
* @copydoc UniformMapDataProvider::GetUniformMapChanged
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override
{
return mUniformMapChanged[bufferIndex];
}
/**
* @copydoc UniformMapDataProvider::GetUniformMap
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override
{
return mCollectedUniformMap[bufferIndex];
}
/**
* Virtual destructor
*/
- virtual ~Layer();
+ ~Layer() override;
/**
* From Node, to convert a node to a layer.
* @return The layer.
*/
- virtual Layer* GetLayer()
+ Layer* GetLayer() override
{
return this;
}
/**
* Virtual destructor
*/
- virtual ~RenderTask();
+ ~RenderTask() override;
/**
* Initialize the render task. Called in update thread
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner )
*/
- void PropertyOwnerConnected( PropertyOwner& owner );
+ void PropertyOwnerConnected( PropertyOwner& owner ) override;
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner )
*/
- void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner );
+ void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) override;
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner )
*/
- void PropertyOwnerDestroyed( PropertyOwner& owner );
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override;
private:
/**
* Destructor
*/
- virtual ~Renderer();
+ ~Renderer() override;
/**
* Overriden delete operator
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
*/
- virtual void UniformMappingsChanged( const UniformMap& mappings );
+ void UniformMappingsChanged( const UniformMap& mappings ) override;
public: // ConnectionChangePropagator::Observer
/**
* @copydoc ConnectionChangePropagator::ConnectionsChanged
*/
- virtual void ConnectionsChanged( PropertyOwner& owner );
+ void ConnectionsChanged( PropertyOwner& owner ) override;
/**
* @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
*/
- virtual void ConnectedUniformMapChanged( );
+ void ConnectedUniformMapChanged( ) override;
/**
* @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
*/
- virtual void ObservedObjectDestroyed(PropertyOwner& owner);
+ void ObservedObjectDestroyed(PropertyOwner& owner) override;
public: // PropertyOwner implementation
/**
/**
* @copydoc UniformMapDataProvider::GetUniformMapChanged
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const{ return mUniformMapChanged[bufferIndex];}
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override{ return mUniformMapChanged[bufferIndex];}
/**
* @copydoc UniformMapDataProvider::GetUniformMap
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const;
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override;
void SetDrawCommands( Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size );
* @brief Virtual destructor
* @SINCE_1_0.0
*/
- virtual ~CustomActorImpl();
+ ~CustomActorImpl() override;
public:
/**
* The implementation should destroy the NativeImage resources.
* @SINCE_1_0.0
*/
- virtual ~NativeImageInterface()
+ ~NativeImageInterface() override
{
}
* @brief A reference counted object may only be deleted by calling Unreference().
* @SINCE_1_0.0
*/
- virtual ~BaseObject();
+ ~BaseObject() override;
/**
* @brief Registers the object as created with the Object registry.
}
// Destruction
- ~Impl()
+ ~Impl() override
{
Reset();
}
/**
* From BaseObject::Impl::Observer
*/
- virtual void ObjectDestroyed( BaseObject& object )
+ void ObjectDestroyed( BaseObject& object ) override
{
mObject = nullptr;
}
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~BaseSignal();
+ ~BaseSignal() override;
/**
* @brief Queries whether there are any connected slots.
/**
* @copydoc SlotObserver::SlotDisconnected
*/
- virtual void SlotDisconnected( CallbackBase* callback );
+ void SlotDisconnected( CallbackBase* callback ) override;
private:
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~ConnectionTrackerInterface();
+ ~ConnectionTrackerInterface() override;
/**
* @brief Called when a signal is connected.
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~ConnectionTracker();
+ ~ConnectionTracker() override;
/**
* @brief Disconnects all signals from this object.
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
/**
* @brief Returns the connection count.
projects / platform / core / uifw / dali-core.git / commitdiff