receivedMouseWheelEvent.z = 0;
receivedMouseWheelEvent.timeStamp = 0;
- mouseWheeledActor = NULL;
+ mouseWheeledActor.Reset();
}
bool functorCalled;
receivedGesture.screenPoint = Vector2(0.0f, 0.0f);
receivedGesture.localPoint = Vector2(0.0f, 0.0f);
- pressedActor = NULL;
+ pressedActor.Reset();
}
bool functorCalled;
receivedTouch.points.clear();
receivedTouch.time = 0;
- touchActor = NULL;
+ touchActor.Reset();
}
bool functorCalled;
DALI_TEST_CHECK(actor);
- actor = NULL;
+ actor.Reset();
DALI_TEST_CHECK(!actor);
END_TEST;
CameraActor cameraActor = CameraActor::DownCast( child );
DALI_TEST_CHECK( cameraActor );
- cameraActor = NULL;
+ cameraActor.Reset();
DALI_TEST_CHECK( !cameraActor );
cameraActor = DownCast< CameraActor >( child );
hoverEvent.time = 0u;
hoverEvent.points.clear();
- hoveredActor = NULL;
+ hoveredActor.Reset();
}
bool functorCalled;
data.Reset();
// Completely delete the actor
- actor = NULL;
+ actor.Reset();
// Emit event, should not crash and should not receive an event.
application.ProcessEvent( GenerateSingleHover( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
receivedKeyEvent.keyPressedName.clear();
receivedKeyEvent.keyPressed.clear();
- keyedActor = NULL;
+ keyedActor.Reset();
}
bool functorCalled;
receivedGesture.screenPoint = Vector2(0.0f, 0.0f);
receivedGesture.localPoint = Vector2(0.0f, 0.0f);
- pressedActor = NULL;
+ pressedActor.Reset();
}
bool functorCalled;
application.Render();
// Delete actor as well
- actor = NULL;
+ actor.Reset();
// Render and notify
application.SendNotification();
receivedGesture.screenPosition = Vector2(0.0f, 0.0f);
receivedGesture.numberOfTouches = 0;
- pannedActor = NULL;
+ pannedActor.Reset();
}
bool functorCalled;
application.Render();
// Delete actor as well
- actor = NULL;
+ actor.Reset();
// Render and notify
application.SendNotification();
receivedGesture.screenCenterPoint = Vector2(0.0f, 0.0f);
receivedGesture.localCenterPoint = Vector2(0.0f, 0.0f);
- pinchedActor = NULL;
+ pinchedActor.Reset();
}
bool functorCalled;
application.Render();
// Delete actor as well
- actor = NULL;
+ actor.Reset();
// Render and notify
application.SendNotification();
RenderableActor renderableActor = RenderableActor::DownCast( child );
DALI_TEST_CHECK( renderableActor );
- renderableActor = NULL;
+ renderableActor.Reset();
DALI_TEST_CHECK( !renderableActor );
renderableActor = DownCast< RenderableActor >( child );
receivedGesture.screenPoint = Vector2(0.0f, 0.0f);
receivedGesture.localPoint = Vector2(0.0f, 0.0f);
- tappedActor = NULL;
+ tappedActor.Reset();
}
bool functorCalled;
Stage::GetCurrent().Remove(actor);
application.SendNotification();
application.Render();
- actor = NULL;
+ actor.Reset();
// Send a Started state, no signal.
application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
touchEvent.time = 0u;
touchEvent.points.clear();
- touchedActor = NULL;
+ touchedActor.Reset();
}
bool functorCalled;
data.Reset();
// Completely delete the actor
- actor = NULL;
+ actor.Reset();
// Emit event, should not crash and should not receive an event.
application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
mHoverStartConsumedActor.SetActor( NULL );
mLastRenderTask.Reset();
- hoverEvent.points[0].hitActor = NULL;
+ hoverEvent.points[0].hitActor.Reset();
return; // No need for hit testing
}
mTouchDownConsumedActor.SetActor( NULL );
mLastRenderTask.Reset();
- touchEvent.points[0].hitActor = NULL;
+ touchEvent.points[0].hitActor.Reset();
mStage.EmitTouchedSignal( touchEvent );
return; // No need for hit testing
return *this;
}
-Actor& Actor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
const std::string& Actor::GetName() const
{
return GetImplementation(*this).GetName();
Actor& operator=(const Actor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Actor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Retrieve the Actor's name.
*
* @pre The Actor has been initialized.
return *this;
}
-CameraActor& CameraActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void CameraActor::SetType( Dali::Camera::Type type )
{
GetImplementation(*this).SetType(type);
CameraActor& operator=(const CameraActor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- CameraActor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the camera type.
* The default type is Dali::Camera::FREE_LOOK
* @param[in] type The camera type
return *this;
}
-CustomActor& CustomActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
CustomActorImpl& CustomActor::GetImplementation()
{
Internal::CustomActor& internal = GetImpl(*this);
*/
CustomActor& operator=(const CustomActor& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- CustomActor& operator=(BaseHandle::NullType* rhs);
-
public: // Not intended for application developers
/**
return *this;
}
-ImageActor& ImageActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void ImageActor::SetImage(Image image)
{
Internal::ImagePtr imagePtr;
ImageActor& operator=(const ImageActor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- ImageActor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the image rendered by the actor.
* Set the image rendered by the actor.
* If actor was already displaying a different image, the old image is dropped and actor may
return *this;
}
-Layer& Layer::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
unsigned int Layer::GetDepth() const
{
return GetImplementation(*this).GetDepth();
Layer& operator=(const Layer& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Layer& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Query the depth of the layer
*
* 0 is bottom most layer, higher number is on top
return *this;
}
-LightActor& LightActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void LightActor::SetLight(Light light)
{
GetImplementation(*this).SetLight(light);
LightActor& operator=(const LightActor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- LightActor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the light properties for the actor.
*
* @param[in] light The light properties
return *this;
}
-MeshActor& MeshActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void MeshActor::SetMaterial(
Actor actor,
const std::string& actorName,
MeshActor& operator=(const MeshActor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- MeshActor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set a custom material on the given actor or one of it's children.
*
* @pre the mesh is loaded
return *this;
}
-RenderableActor& RenderableActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void RenderableActor::SetSortModifier(float modifier)
{
GetImplementation(*this).SetSortModifier(modifier);
RenderableActor& operator=(const RenderableActor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- RenderableActor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Allows modification of an actors position in the depth sort algorithm.
*
* The offset can be altered for each coplanar actor hence allowing an order of painting.
return *this;
}
-TextActor& TextActor::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
string TextActor::GetText() const
{
return GetImplementation(*this).GetText();
TextActor& operator=(const TextActor& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- TextActor& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Get the text label displayed by the actor.
*
* @pre The text actor has been initialized.
return *this;
}
-ActiveConstraint& ActiveConstraint::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Handle ActiveConstraint::GetTargetObject()
{
return GetImplementation(*this).GetTargetObject();
ActiveConstraint& operator=(const ActiveConstraint& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- ActiveConstraint& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Retrieve the object which this constraint is targeting.
*
* @return The target object.
return *this;
}
-Animation& Animation::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void Animation::SetDuration(float durationSeconds)
{
GetImplementation(*this).SetDuration(durationSeconds);
Animation& operator=(const Animation& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Animation& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the duration of an animation.
*
* @pre durationSeconds must be greater than zero.
return *this;
}
-Constraint& Constraint::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void Constraint::SetApplyTime( TimePeriod timePeriod )
{
GetImplementation(*this).SetApplyTime( timePeriod );
Constraint& operator=(const Constraint& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Constraint& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the time taken for the constraint to be fully applied.
*
* The default is zero, meaning that the constraint is applied immediately.
return *this;
}
-KeyFrames& KeyFrames::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Property::Type KeyFrames::GetType() const
{
return GetImplementation(*this).GetType();
KeyFrames& operator=(const KeyFrames& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- KeyFrames& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Gets the type of the key frame.
*
* If no key frames have been added, this returns Property::NONE.
return *this;
}
-Light& Light::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void Light::SetName(const std::string& name)
{
GetImplementation(*this).SetName(name);
Light& operator=(const Light& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Light& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the light's name.
*
* @param[in] name The light's name
return *this;
}
-Stage& Stage::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Stage::Stage(Internal::Stage* internal)
: BaseHandle(internal)
{
*/
Stage& operator=(const Stage& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Stage& operator=(BaseHandle::NullType* rhs);
-
// Containment
/**
return *this;
}
-DynamicsBodyConfig& DynamicsBodyConfig::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void DynamicsBodyConfig::SetType( const DynamicsBodyConfig::BodyType type )
{
#ifdef DYNAMICS_SUPPORT
*/
DynamicsBodyConfig& operator=(const DynamicsBodyConfig& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsBodyConfig& operator=(BaseHandle::NullType* rhs);
-
public:
/**
* @brief Set the type of DynamicsBody.
return *this;
}
-DynamicsBody& DynamicsBody::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
DynamicsBody::DynamicsBody(Internal::DynamicsBody* internal)
#ifdef DYNAMICS_SUPPORT
: BaseHandle(internal)
*/
DynamicsBody& operator=(const DynamicsBody& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsBody& operator=(BaseHandle::NullType* rhs);
-
public:
// Not intended for application developers
/**
return *this;
}
-DynamicsCollision& DynamicsCollision::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Actor DynamicsCollision::GetActorA()
{
#ifdef DYNAMICS_SUPPORT
*/
DynamicsCollision& operator=(const DynamicsCollision& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsCollision& operator=(BaseHandle::NullType* rhs);
-
public:
/**
* @brief Get the first actor in the collision.
return *this;
}
-DynamicsJoint& DynamicsJoint::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void DynamicsJoint::SetLinearLimit( const int axisIndex, const float lowerLimit, const float upperLimit )
{
#ifdef DYNAMICS_SUPPORT
*/
DynamicsJoint& operator=(const DynamicsJoint& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsJoint& operator=(BaseHandle::NullType* rhs);
-
public:
/**
* @brief Set the limit for one or more linear/translation axis.
return *this;
}
-DynamicsShape& DynamicsShape::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
DynamicsShape::DynamicsShape(Internal::DynamicsShape* internal)
#ifdef DYNAMICS_SUPPORT
: BaseHandle(internal)
*/
DynamicsShape& operator=(const DynamicsShape& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsShape& operator=(BaseHandle::NullType* rhs);
-
public:
/**
* @brief Get the type of shape.
return *this;
}
-DynamicsWorldConfig& DynamicsWorldConfig::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void DynamicsWorldConfig::SetType( const DynamicsWorldConfig::WorldType type )
{
#ifdef DYNAMICS_SUPPORT
*/
DynamicsWorldConfig& operator=(const DynamicsWorldConfig& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsWorldConfig& operator=(BaseHandle::NullType* rhs);
-
public:
/**
* @brief Set the type of Dynamics world required for the application.
return *this;
}
-DynamicsWorld& DynamicsWorld::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void DynamicsWorld::SetGravity(const Vector3& gravity )
{
#ifdef DYNAMICS_SUPPORT
*/
DynamicsWorld& operator=(const DynamicsWorld& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- DynamicsWorld& operator=(BaseHandle::NullType* rhs);
-
// Methods that modify the simulation
public:
return *this;
}
-GestureDetector& GestureDetector::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void GestureDetector::Attach(Actor actor)
{
GetImplementation(*this).Attach(GetImplementation(actor));
*/
GestureDetector& operator=(const GestureDetector& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- GestureDetector& operator=(BaseHandle::NullType* rhs);
-
public: // Actor related
/**
return *this;
}
-LongPressGestureDetector& LongPressGestureDetector::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void LongPressGestureDetector::SetTouchesRequired(unsigned int touches)
{
GetImplementation(*this).SetTouchesRequired(touches);
*/
LongPressGestureDetector& operator=(const LongPressGestureDetector& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- LongPressGestureDetector& operator=(BaseHandle::NullType* rhs);
-
public: // Setters
/**
return *this;
}
-PanGestureDetector& PanGestureDetector::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void PanGestureDetector::SetMinimumTouchesRequired(unsigned int minimum)
{
GetImplementation(*this).SetMinimumTouchesRequired(minimum);
*/
PanGestureDetector& operator=(const PanGestureDetector& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- PanGestureDetector& operator=(BaseHandle::NullType* rhs);
-
public: // Setters
/**
return *this;
}
-PinchGestureDetector& PinchGestureDetector::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
PinchGestureDetector::DetectedSignalV2& PinchGestureDetector::DetectedSignal()
{
return GetImplementation(*this).DetectedSignal();
*/
PinchGestureDetector& operator=(const PinchGestureDetector& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- PinchGestureDetector& operator=(BaseHandle::NullType* rhs);
-
public: // Signals
/**
return *this;
}
-TapGestureDetector& TapGestureDetector::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void TapGestureDetector::SetTapsRequired(unsigned int taps)
{
GetImplementation(*this).SetTapsRequired(taps);
*/
TapGestureDetector& operator=(const TapGestureDetector& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- TapGestureDetector& operator=(BaseHandle::NullType* rhs);
-
public: // Setters
/**
return *this;
}
-AnimatableMesh& AnimatableMesh::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
unsigned int AnimatableMesh::GetNumberOfVertices() const
{
return GetImplementation(*this).GetNumberOfVertices();
AnimatableMesh& operator=(const AnimatableMesh& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- AnimatableMesh& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Get the number of vertices with which this mesh was created.
*
* @return number of vertices in this mesh
return *this;
}
-Cloth& Cloth::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Cloth Cloth::New( const float width, const float height, const int xSteps, const int ySteps, const Rect<float>& textureCoordinates )
{
MeshData meshData( MeshFactory::NewPlane(width, height, xSteps, ySteps, textureCoordinates) );
Cloth& operator=(const Cloth& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Cloth& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Downcast an Object handle to a Cloth handle.
*
* If handle points to a Cloth object the downcast produces valid
return *this;
}
-Mesh& Mesh::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Mesh Mesh::New( const MeshData& meshData )
{
// Convert material handle to intrusive pointer
Mesh& operator=(const Mesh& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Mesh& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Create an initialized plane aligned on the XY axis.
*
* @param[in] width The width of the plane
return *this;
}
-BitmapImage& BitmapImage::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
-
const BitmapImage BitmapImage::WHITE()
{
Internal::BitmapImage* internal = new Internal::BitmapImage(1,1,Pixel::RGBA8888, Immediate, Never);
BitmapImage& operator=(const BitmapImage& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- BitmapImage& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief White pixel as image data.
*
* Can be used to create solid color actors.
return *this;
}
-EncodedBufferImage& EncodedBufferImage::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
} // namespace Dali
*/
EncodedBufferImage& operator=(const EncodedBufferImage& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- EncodedBufferImage& operator=(BaseHandle::NullType* rhs);
-
public: // Not intended for application developers
explicit DALI_INTERNAL EncodedBufferImage(Internal::EncodedBufferImage*);
return *this;
}
-FrameBufferImage& FrameBufferImage::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
FrameBufferImage FrameBufferImage::New(unsigned int width, unsigned int height, Pixel::Format pixelformat)
{
Dali::Vector2 stageSize = Stage::GetCurrent().GetSize();
*/
FrameBufferImage& operator=(const FrameBufferImage& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- FrameBufferImage& operator=(BaseHandle::NullType* rhs);
-
public: // Not intended for application developers
explicit DALI_INTERNAL FrameBufferImage(Internal::FrameBufferImage*);
return *this;
}
-GlyphImage& GlyphImage::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
GlyphImage GlyphImage::New( const Character& character )
{
// Retrieves the font family name for the given character.
*/
GlyphImage& operator=(const GlyphImage& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- GlyphImage& operator=(BaseHandle::NullType* rhs);
-
public: // Not intended for application developers
explicit DALI_INTERNAL GlyphImage( Internal::Image* );
return *this;
}
-Image& Image::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Image Image::New(const std::string& filename)
{
Internal::ImagePtr internal = Internal::Image::New( filename,
Image& operator=(const Image& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Image& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Create an initialised image object.
*
* @param [in] filename The filename of the image file to use.
return *this;
}
-NinePatchImage& NinePatchImage::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
NinePatchImage NinePatchImage::New( const std::string& filename )
{
ImageAttributes defaultAttrs;
NinePatchImage& operator=(const NinePatchImage& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- NinePatchImage& operator=(BaseHandle::NullType* rhs);
-
- /**
* Get the stretch borders
* @return The border in pixels from the left, top, right, and bottom of the image respectively.
*/
return *this;
}
-Entity& Entity::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Entity Entity::Find(const std::string& name) const
{
Internal::Entity* entity = GetImplementation(*this).Find(name);
Entity& operator=(const Entity& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Entity& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Find an entity by name.
*
* The search includes this entity and it's children.
return *this;
}
-Material& Material::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void Material::SetName(const std::string& name)
{
GetImplementation(*this).SetName(name);
Material& operator=(const Material& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Material& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the material's name.
*
* @param[in] name The material's name
return *this;
}
-ModelData& ModelData::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
const std::string& ModelData::GetName() const
{
return GetImplementation(*this).GetName();
ModelData& operator=(const ModelData& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- ModelData& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Returns the name of the model.
*
* @return The model name
return *this;
}
-Model& Model::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
LoadingState Model::GetLoadingState()
{
return GetImplementation(*this).GetLoadingState();
Model& operator=(const Model& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Model& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Query whether the model data has loaded.
*
* The asynchronous loading begins when the Model object is created.
return *this;
}
-BaseHandle& BaseHandle::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
bool BaseHandle::DoAction(const std::string& command, const std::vector<Property::Value>& attributes)
{
return GetImplementation(*this).DoAction( command, attributes );
public:
/**
- * @brief Used for null pointer assignment below
- */
- class NullType
- {
- NullType() { }
- };
-
- /**
* @brief This constructor is used by Dali New() methods.
*
* @param [in] handle A pointer to a newly allocated Dali resource
BaseHandle& operator=(const BaseHandle& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- BaseHandle& operator=(NullType* rhs);
-
- /**
* @brief Connects a void() functor to a specified signal.
*
* @pre The signal must be available in this object.
return *this;
}
-Constrainable& Constrainable::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
ActiveConstraint Constrainable::ApplyConstraint( Constraint constraint )
{
return GetImplementation(*this).ApplyConstraint( GetImplementation( constraint ) );
Constrainable& operator=(const Constrainable& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Constrainable& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Constrain one of the properties of an Actor.
*
* @note The constraint will be copied by the Actor. This means that modifying the apply-time etc.
return *this;
}
-Handle& Handle::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
Handle Handle::DownCast( BaseHandle handle )
{
return Handle( dynamic_cast<Dali::Internal::Object*>(handle.GetObjectPtr()) );
Handle& operator=(const Handle& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Handle& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Downcast to a handle.
*
* If not the returned handle is left uninitialized.
return *this;
}
-ObjectRegistry& ObjectRegistry::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
ObjectRegistry::ObjectCreatedSignalV2& ObjectRegistry::ObjectCreatedSignal()
{
return GetImplementation(*this).ObjectCreatedSignal();
*/
ObjectRegistry& operator=(const ObjectRegistry& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- ObjectRegistry& operator=(BaseHandle::NullType* rhs);
-
public: // Signals
/**
return *this;
}
-PropertyCondition& PropertyCondition::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
PropertyCondition::ArgumentContainer PropertyCondition::GetArguments()
{
return GetImplementation(*this).arguments;
*/
PropertyCondition& operator=(const PropertyCondition& rhs);
- /**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- PropertyCondition& operator=(BaseHandle::NullType* rhs);
-
public:
/**
return *this;
}
-PropertyNotification& PropertyNotification::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
PropertyCondition PropertyNotification::GetCondition()
{
return GetImplementation(*this).GetCondition();
PropertyNotification& operator=(const PropertyNotification& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- PropertyNotification& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Get the condition of this notification
*
* @return The condition is returned
return *this;
}
-TypeInfo& TypeInfo::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
const std::string& TypeInfo::GetName() const
{
return GetImplementation(*this).GetName();
TypeInfo& operator=(const TypeInfo& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- TypeInfo& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Retrieve the type name for this type.
*
* @return string name
return *this;
}
-TypeRegistry& TypeRegistry::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
TypeRegistry TypeRegistry::Get()
{
return TypeRegistry(Internal::TypeRegistry::Get());
TypeRegistry& operator=(const TypeRegistry& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- TypeRegistry& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Get TypeInfo for a registered type.
*
* @param [in] uniqueTypeName A unique type name
return *this;
}
-RenderTaskList& RenderTaskList::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
RenderTask RenderTaskList::CreateTask()
{
return GetImplementation(*this).CreateTask();
RenderTaskList& operator=(const RenderTaskList& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- RenderTaskList& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Create a new RenderTask.
*
* This will be appended to the list of render-tasks.
return *this;
}
-RenderTask& RenderTask::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
void RenderTask::SetSourceActor( Actor actor )
{
// NULL handle is allowed
RenderTask& operator=(const RenderTask& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- RenderTask& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Set the actors to be rendered.
* @param[in] actor This actor and its children will be rendered.
* If actor is an empty handle, then nothing will be rendered.
return *this;
}
-ShaderEffect& ShaderEffect::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
ShaderEffect ShaderEffect::New( const std::string& vertexShader, const std::string& fragmentShader, GeometryType type, GeometryHints hints)
{
Internal::ShaderEffectPtr internal = Internal::ShaderEffect::New( vertexShader, fragmentShader, type, hints );
ShaderEffect& operator=(const ShaderEffect& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- ShaderEffect& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Sets image for using as effect texture.
*
* This image texture will be bound to the "sEffect" sampler
return *this;
}
-Font& Font::operator=(BaseHandle::NullType* rhs)
-{
- DALI_ASSERT_ALWAYS( (rhs == NULL) && "Can only assign NULL pointer to handle");
- Reset();
- return *this;
-}
-
PixelSize Font::GetLineHeightFromCapsHeight(const std::string& fontFamily, const std::string& fontStyle, const CapsHeight& capsHeight)
{
return Internal::Font::GetLineHeightFromCapsHeight(fontFamily,fontStyle,capsHeight);
Font& operator=(const Font& rhs);
/**
- * @brief This method is defined to allow assignment of the NULL value,
- * and will throw an exception if passed any other value.
- *
- * Assigning to NULL is an alias for Reset().
- * @param [in] rhs A NULL pointer
- * @return A reference to this handle
- */
- Font& operator=(BaseHandle::NullType* rhs);
-
- /**
* @brief Convert a PixelSize from CapsHeight to it's equivalent LineHeight.
*
* @param [in] fontFamily The family's name of the font requested
projects / platform / core / uifw / dali-core.git / commitdiff