std::vector<Property::Value> attributes;
- DALI_TEST_CHECK(hdl.DoAction(Actor::ACTION_SHOW, attributes));
+ DALI_TEST_CHECK(hdl.DoAction("show", attributes));
application.SendNotification();
application.Render(0);
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, LongPressGestureDetector::SIGNAL_LONG_PRESS_DETECTED, functor );
+ handle.ConnectSignal( &application, "long-press-detected", functor );
// Render and notify
application.SendNotification();
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, PanGestureDetector::SIGNAL_PAN_DETECTED, functor );
+ handle.ConnectSignal( &application, "pan-detected", functor );
// Render and notify
application.SendNotification();
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, PinchGestureDetector::SIGNAL_PINCH_DETECTED, functor );
+ handle.ConnectSignal( &application, "pinch-detected", functor );
// Render and notify
application.SendNotification();
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, TapGestureDetector::SIGNAL_TAP_DETECTED, functor );
+ handle.ConnectSignal( &application, "tap-detected", functor );
// Render and notify
application.SendNotification();
namespace
{
-using namespace Dali;
+// Signals
+
+const char* const SIGNAL_TOUCHED = "touched";
+const char* const SIGNAL_HOVERED = "hovered";
+const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
+const char* const SIGNAL_ON_STAGE = "on-stage";
+const char* const SIGNAL_OFF_STAGE = "off-stage";
+
+// Actions
+
+const char* const ACTION_SHOW = "show";
+const char* const ACTION_HIDE = "hide";
BaseHandle CreateActor()
{
return Dali::Actor::New();
}
-TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor );
+TypeRegistration mType( typeid( Dali::Actor ), typeid( Dali::Handle ), CreateActor );
-SignalConnectorType signalConnector1(mType, Dali::Actor::SIGNAL_TOUCHED, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector2(mType, Dali::Actor::SIGNAL_HOVERED, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector4(mType, Dali::Actor::SIGNAL_ON_STAGE, &Actor::DoConnectSignal);
-SignalConnectorType signalConnector5(mType, Dali::Actor::SIGNAL_OFF_STAGE, &Actor::DoConnectSignal);
+SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
-TypeAction a1(mType, Dali::Actor::ACTION_SHOW, &Actor::DoAction);
-TypeAction a2(mType, Dali::Actor::ACTION_HIDE, &Actor::DoAction);
+TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
+TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
}
bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
- Actor* actor = dynamic_cast<Actor*>(object);
+ Actor* actor = dynamic_cast<Actor*>( object );
- if(Dali::Actor::SIGNAL_TOUCHED == signalName)
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) ) // don't want to convert char* to string
{
actor->TouchedSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_HOVERED == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_HOVERED ) )
{
actor->HoveredSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_MOUSE_WHEEL_EVENT == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) )
{
actor->MouseWheelEventSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_ON_STAGE == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) )
{
actor->OnStageSignal().Connect( tracker, functor );
}
- else if(Dali::Actor::SIGNAL_OFF_STAGE == signalName)
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_OFF_STAGE ) )
{
actor->OffStageSignal().Connect( tracker, functor );
}
return Node::New();
}
-bool Actor::DoAction(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes)
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes )
{
bool done = false;
- Actor* actor = dynamic_cast<Actor*>(object);
+ Actor* actor = dynamic_cast<Actor*>( object );
if( actor )
{
- if(Dali::Actor::ACTION_SHOW == actionName)
+ if( 0 == strcmp( actionName.c_str(), ACTION_SHOW ) ) // dont want to convert char* to string
{
actor->SetVisible(true);
done = true;
}
- else if(Dali::Actor::ACTION_HIDE == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_HIDE ) )
{
actor->SetVisible(false);
done = true;
namespace
{
+// Actions
+
+const char* const ACTION_RAISE = "raise";
+const char* const ACTION_LOWER = "lower";
+const char* const ACTION_RAISE_TO_TOP = "raise-to-top";
+const char* const ACTION_LOWER_TO_BOTTOM = "lower-to-bottom";
+
BaseHandle Create()
{
return Dali::Layer::New();
}
-TypeRegistration mType( typeid(Dali::Layer), typeid(Dali::Actor), Create );
+TypeRegistration mType( typeid( Dali::Layer ), typeid( Dali::Actor ), Create );
-TypeAction a1(mType, Dali::Layer::ACTION_RAISE, &Layer::DoAction);
-TypeAction a2(mType, Dali::Layer::ACTION_LOWER, &Layer::DoAction);
-TypeAction a3(mType, Dali::Layer::ACTION_RAISE_TO_TOP, &Layer::DoAction);
-TypeAction a4(mType, Dali::Layer::ACTION_LOWER_TO_BOTTOM, &Layer::DoAction);
+TypeAction a1( mType, ACTION_RAISE, &Layer::DoAction );
+TypeAction a2( mType, ACTION_LOWER, &Layer::DoAction );
+TypeAction a3( mType, ACTION_RAISE_TO_TOP, &Layer::DoAction );
+TypeAction a4( mType, ACTION_LOWER_TO_BOTTOM, &Layer::DoAction );
const PropertyDetails DEFAULT_PROPERTY_DETAILS[] =
{
return ret;
}
-bool Layer::DoAction(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes)
+bool Layer::DoAction( BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes )
{
bool done = false;
- Layer* layer = dynamic_cast<Layer*>(object);
+ Layer* layer = dynamic_cast<Layer*>( object );
- if(layer)
+ if( layer )
{
- if(Dali::Layer::ACTION_RAISE == actionName)
+ if( 0 == strcmp( actionName.c_str(), ACTION_RAISE ) )
{
layer->Raise();
done = true;
}
- else if(Dali::Layer::ACTION_LOWER == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_LOWER ) )
{
layer->Lower();
done = true;
}
- else if(Dali::Layer::ACTION_RAISE_TO_TOP == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_RAISE_TO_TOP ) )
{
layer->RaiseToTop();
done = true;
}
- else if(Dali::Layer::ACTION_LOWER_TO_BOTTOM == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_LOWER_TO_BOTTOM ) )
{
layer->LowerToBottom();
done = true;
namespace
{
+// Signals
+
+const char* const SIGNAL_TEXT_LOADING_FINISHED = "text-loading-finished";
+
+// Default property names
+
const char* DEFAULT_TEXT_ACTOR_PROPERTY_NAMES[] =
{
"text",
TypeRegistration mType( typeid(Dali::TextActor), typeid(Dali::RenderableActor), Create );
-SignalConnectorType s1( mType, Dali::TextActor::SIGNAL_TEXT_LOADING_FINISHED, &TextActor::DoConnectSignal );
+SignalConnectorType s1( mType, SIGNAL_TEXT_LOADING_FINISHED, &TextActor::DoConnectSignal );
}
bool connected( true );
TextActor* textActor = dynamic_cast<TextActor*>(object);
- if( Dali::TextActor::SIGNAL_TEXT_LOADING_FINISHED == signalName )
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_TEXT_LOADING_FINISHED ) )
{
textActor->TextAvailableSignal().Connect( tracker, functor );
}
namespace // unnamed namespace
{
+// Signals
+
+const char* const SIGNAL_APPLIED = "applied";
+
BaseHandle Create()
{
// not directly creatable
TypeRegistration mType( typeid(Dali::ActiveConstraint), typeid(Dali::Handle), Create );
-SignalConnectorType signalConnector1( mType, Dali::ActiveConstraint::SIGNAL_APPLIED, &ActiveConstraintBase::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_APPLIED, &ActiveConstraintBase::DoConnectSignal );
}
bool connected( true );
ActiveConstraintBase* constraint = dynamic_cast<ActiveConstraintBase*>(object);
- if ( Dali::ActiveConstraint::SIGNAL_APPLIED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_APPLIED ) )
{
constraint->AppliedSignal().Connect( tracker, functor );
}
namespace
{
+// Signals
+
+const char* const SIGNAL_FINISHED = "finished";
+
+// Actions
+
+const char* const ACTION_PLAY = "play";
+const char* const ACTION_STOP = "stop";
+const char* const ACTION_PAUSE = "pause";
+
BaseHandle Create()
{
return Dali::Animation::New(0.f);
TypeRegistration mType( typeid(Dali::Animation), typeid(Dali::BaseHandle), Create );
-SignalConnectorType signalConnector1( mType, Dali::Animation::SIGNAL_FINISHED, &Animation::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &Animation::DoConnectSignal );
-TypeAction action1( mType, Dali::Animation::ACTION_PLAY, &Animation::DoAction );
-TypeAction action2( mType, Dali::Animation::ACTION_STOP, &Animation::DoAction );
-TypeAction action3( mType, Dali::Animation::ACTION_PAUSE, &Animation::DoAction );
+TypeAction action1( mType, ACTION_PLAY, &Animation::DoAction );
+TypeAction action2( mType, ACTION_STOP, &Animation::DoAction );
+TypeAction action3( mType, ACTION_PAUSE, &Animation::DoAction );
const Dali::Animation::EndAction DEFAULT_END_ACTION( Dali::Animation::Bake );
const Dali::Animation::EndAction DEFAULT_DISCONNECT_ACTION( Dali::Animation::BakeFinal );
bool connected( true );
Animation* animation = dynamic_cast<Animation*>(object);
- if ( Dali::Animation::SIGNAL_FINISHED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
{
animation->FinishedSignal().Connect( tracker, functor );
}
TimePeriod(delaySeconds, durationSeconds) ) );
}
-bool Animation::DoAction(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes)
+bool Animation::DoAction( BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes )
{
bool done = false;
- Animation* animation = dynamic_cast<Animation*>(object);
+ Animation* animation = dynamic_cast<Animation*>( object );
if( animation )
{
- if(Dali::Animation::ACTION_PLAY == actionName)
+ if( 0 == strcmp( actionName.c_str(), ACTION_PLAY ) )
{
- if(attributes.size() > 0)
+ if( attributes.size() > 0 )
{
- animation->SetDuration(attributes[0].Get<float>());
+ animation->SetDuration( attributes[0].Get<float>() );
}
animation->Play();
done = true;
}
- else if(Dali::Animation::ACTION_STOP == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_STOP ) )
{
animation->Stop();
done = true;
}
- else if(Dali::Animation::ACTION_PAUSE == actionName)
+ else if( 0 == strcmp( actionName.c_str(), ACTION_PAUSE ) )
{
animation->Pause();
done = true;
// INTERNAL INCLUDES
#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/public-api/object/object-registry.h>
+#include <dali/public-api/object/type-registry.h>
namespace Dali
{
namespace Internal
{
+namespace
+{
+
+// Signals
+
+const char* const SIGNAL_OBJECT_CREATED = "object-created";
+const char* const SIGNAL_OBJECT_DESTROYED = "object-destroyed";
+
+TypeRegistration mType( typeid( Dali::ObjectRegistry ), typeid( Dali::BaseHandle ), NULL );
+
+SignalConnectorType signalConnector1( mType, SIGNAL_OBJECT_CREATED, &ObjectRegistry::DoConnectSignal );
+SignalConnectorType signalConnector2( mType, SIGNAL_OBJECT_DESTROYED, &ObjectRegistry::DoConnectSignal );
+
+}
+
ObjectRegistryPtr ObjectRegistry::New()
{
- return ObjectRegistryPtr(new ObjectRegistry());
+ return ObjectRegistryPtr( new ObjectRegistry() );
}
ObjectRegistry::ObjectRegistry()
bool ObjectRegistry::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
- ObjectRegistry* objectRegistry = dynamic_cast<ObjectRegistry*>(object);
+ ObjectRegistry* objectRegistry = dynamic_cast<ObjectRegistry*>( object );
- if(Dali::ObjectRegistry::SIGNAL_OBJECT_CREATED == signalName)
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_OBJECT_CREATED ) )
{
objectRegistry->ObjectCreatedSignal().Connect( tracker, functor );
}
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_OBJECT_DESTROYED ) )
+ {
+ objectRegistry->ObjectDestroyedSignal().Connect( tracker, functor );
+ }
else
{
// signalName does not match any signal
#include <dali/internal/event/common/object-registry-impl.h>
#include <dali/integration-api/platform-abstraction.h>
#include <dali/public-api/common/constants.h>
+#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#ifdef DYNAMICS_SUPPORT
const float DEFAULT_STEREO_BASE( 65.0f );
+// Signals
+
+const char* const SIGNAL_KEY_EVENT = "key-event";
+const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
+const char* const SIGNAL_TOUCHED = "touched";
+const char* const SIGNAL_CONTEXT_LOST = "context-lost";
+const char* const SIGNAL_CONTEXT_REGAINED = "context-regained";
+const char* const SIGNAL_SCENE_CREATED = "scene-created";
+
+TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
+
+SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT, &Stage::DoConnectSignal );
+SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
+SignalConnectorType signalConnector3( mType, SIGNAL_TOUCHED, &Stage::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_CONTEXT_LOST, &Stage::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_REGAINED, &Stage::DoConnectSignal );
+SignalConnectorType signalConnector6( mType, SIGNAL_SCENE_CREATED, &Stage::DoConnectSignal );
+
} // unnamed namespace
StagePtr Stage::New( AnimationPlaylist& playlist,
KeepRenderingMessage( mUpdateManager, durationSeconds );
}
+bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+{
+ bool connected( true );
+ Stage* stage = dynamic_cast<Stage*>(object);
+
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
+ {
+ stage->KeyEventSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) )
+ {
+ stage->EventProcessingFinishedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) )
+ {
+ stage->TouchedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
+ {
+ stage->ContextLostSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_REGAINED ) )
+ {
+ stage->ContextRegainedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCENE_CREATED ) )
+ {
+ stage->SceneCreatedSignal().Connect( tracker, functor );
+ }
+ else
+ {
+ // signalName does not match any signal
+ connected = false;
+ }
+
+ return connected;
+}
+
void Stage::EmitKeyEventSignal(const KeyEvent& event)
{
// Emit the key event signal when no actor in the stage has gained the key input focus
return mNotificationManager;
}
-
/**
* @copydoc Dali::Stage::KeepRendering()
*/
*/
Dali::Stage::SceneCreatedSignalType& SceneCreatedSignal();
+ /**
+ * Connects a callback function with the object's signals.
+ * @param[in] object The object providing the signal.
+ * @param[in] tracker Used to disconnect the signal.
+ * @param[in] signalName The signal to connect to.
+ * @param[in] functor A newly allocated FunctorDelegate.
+ * @return True if the signal was connected.
+ * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
+ */
+ static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
+
private: // Implementation of ContextNotificationInterface:
/**
namespace
{
+// Signals
+
+const char* const SIGNAL_COLLISION = "collision";
+
BaseHandle Create()
{
DynamicsWorldPtr p = Stage::GetCurrent()->GetDynamicsWorld();
TypeRegistration mType( typeid(Dali::DynamicsWorld), typeid(Dali::Handle), Create );
-SignalConnectorType signalConnector1( mType, Dali::DynamicsWorld::SIGNAL_COLLISION, &DynamicsWorld::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_COLLISION, &DynamicsWorld::DoConnectSignal );
} // unnamed namespace
bool connected( true );
DynamicsWorld* world = dynamic_cast<DynamicsWorld*>(object);
- if( Dali::DynamicsWorld::SIGNAL_COLLISION == signalName )
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_COLLISION ) )
{
world->CollisionSignal().Connect( tracker, functor );
}
namespace
{
+
+// Signals
+
+const char* const SIGNAL_LONG_PRESS_DETECTED = "long-press-detected";
+
BaseHandle Create()
{
return Dali::LongPressGestureDetector::New();
TypeRegistration mType( typeid(Dali::LongPressGestureDetector), typeid(Dali::GestureDetector), Create );
-SignalConnectorType signalConnector1( mType, Dali::LongPressGestureDetector::SIGNAL_LONG_PRESS_DETECTED, &LongPressGestureDetector::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_LONG_PRESS_DETECTED, &LongPressGestureDetector::DoConnectSignal );
}
bool connected( true );
LongPressGestureDetector* gesture = dynamic_cast<LongPressGestureDetector*>(object);
- if ( Dali::LongPressGestureDetector::SIGNAL_LONG_PRESS_DETECTED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_LONG_PRESS_DETECTED ) )
{
gesture->DetectedSignal().Connect( tracker, functor );
}
};
const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTIES ) / sizeof( DEFAULT_PROPERTIES[0] );
+// Signals
+
+const char* const SIGNAL_PAN_DETECTED = "pan-detected";
+
BaseHandle Create()
{
return Dali::PanGestureDetector::New();
TypeRegistration mType( typeid(Dali::PanGestureDetector), typeid(Dali::GestureDetector), Create );
-SignalConnectorType signalConnector1( mType, Dali::PanGestureDetector::SIGNAL_PAN_DETECTED, &PanGestureDetector::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_PAN_DETECTED, &PanGestureDetector::DoConnectSignal );
#if defined(DEBUG_ENABLED)
Integration::Log::Filter* gLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_PAN_GESTURE_DETECTOR");
bool connected( true );
PanGestureDetector* gesture = dynamic_cast<PanGestureDetector*>(object);
- if ( Dali::PanGestureDetector::SIGNAL_PAN_DETECTED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_PAN_DETECTED ) )
{
gesture->DetectedSignal().Connect( tracker, functor );
}
namespace
{
+
+// Signals
+
+const char* const SIGNAL_PINCH_DETECTED = "pinch-detected";
+
BaseHandle Create()
{
return Dali::PinchGestureDetector::New();
TypeRegistration mType( typeid(Dali::PinchGestureDetector), typeid(Dali::GestureDetector), Create );
-SignalConnectorType signalConnector1( mType, Dali::PinchGestureDetector::SIGNAL_PINCH_DETECTED, &PinchGestureDetector::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_PINCH_DETECTED, &PinchGestureDetector::DoConnectSignal );
}
bool connected( true );
PinchGestureDetector* gesture = dynamic_cast<PinchGestureDetector*>(object);
- if ( Dali::PinchGestureDetector::SIGNAL_PINCH_DETECTED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_PINCH_DETECTED ) )
{
gesture->DetectedSignal().Connect( tracker, functor );
}
namespace
{
+
+// Signals
+const char* const SIGNAL_TAP_DETECTED = "tap-detected";
+
BaseHandle Create()
{
return Dali::TapGestureDetector::New();
TypeRegistration mType( typeid(Dali::TapGestureDetector), typeid(Dali::GestureDetector), Create );
-SignalConnectorType signalConnector1( mType, Dali::TapGestureDetector::SIGNAL_TAP_DETECTED, &TapGestureDetector::DoConnectSignal );
+SignalConnectorType signalConnector1( mType, SIGNAL_TAP_DETECTED, &TapGestureDetector::DoConnectSignal );
}
bool connected( true );
TapGestureDetector* gesture = dynamic_cast<TapGestureDetector*>(object);
- if ( Dali::TapGestureDetector::SIGNAL_TAP_DETECTED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_TAP_DETECTED ) )
{
gesture->DetectedSignal().Connect( tracker, functor );
}
namespace
{
-TypeRegistration mType( typeid(Dali::Image), typeid(Dali::BaseHandle), NULL );
+// Signals
-Dali::SignalConnectorType signalConnector2(mType, Dali::Image::SIGNAL_IMAGE_UPLOADED, &Image::DoConnectSignal);
+const char* const SIGNAL_IMAGE_UPLOADED = "uploaded";
+
+TypeRegistration mType( typeid( Dali::Image ), typeid( Dali::BaseHandle ), NULL );
+
+Dali::SignalConnectorType signalConnector1( mType, SIGNAL_IMAGE_UPLOADED, &Image::DoConnectSignal );
}
DALI_ASSERT_DEBUG( dynamic_cast<Image*>( object ) && "Resource ticket not ImageTicket subclass for image resource.\n" );
Image* image = static_cast<Image*>(object);
- if(Dali::Image::SIGNAL_IMAGE_UPLOADED == signalName)
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_IMAGE_UPLOADED ) )
{
image->UploadedSignal().Connect( tracker, functor );
}
namespace
{
+// Signals
+
+const char* const SIGNAL_IMAGE_LOADING_FINISHED = "image-loading-finished";
+
BaseHandle CreateImage()
{
ImagePtr image = ResourceImage::New();
return Dali::Image(image.Get());
}
-TypeRegistration mType( typeid(Dali::ResourceImage), typeid(Dali::Image), CreateImage );
+TypeRegistration mType( typeid( Dali::ResourceImage ), typeid( Dali::Image ), CreateImage );
-Dali::SignalConnectorType signalConnector1(mType, Dali::ResourceImage::SIGNAL_IMAGE_LOADING_FINISHED, &ResourceImage::DoConnectSignal);
+Dali::SignalConnectorType signalConnector1( mType, SIGNAL_IMAGE_LOADING_FINISHED, &ResourceImage::DoConnectSignal );
}
DALI_ASSERT_DEBUG( dynamic_cast<ResourceImage*>( object ) && "Resource ticket not ImageTicket subclass for image resource.\n" );
ResourceImage* image = static_cast<ResourceImage*>(object);
- if( Dali::ResourceImage::SIGNAL_IMAGE_LOADING_FINISHED == signalName )
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_IMAGE_LOADING_FINISHED ) )
{
image->LoadingFinishedSignal().Connect( tracker, functor );
}
- else if(Dali::ResourceImage::SIGNAL_IMAGE_UPLOADED == signalName)
- {
- image->UploadedSignal().Connect( tracker, functor );
- }
else
{
// signalName does not match any signal
namespace
{
+
+// Signals
+
+const char* const SIGNAL_MODEL_LOADING_FINISHED = "model-loading-finished";
+const char* const SIGNAL_MODEL_SAVING_FINISHED = "model-saving-finished";
+
TypeRegistration mType( typeid( Dali::Model ), typeid( Dali::BaseHandle ), NULL );
+
+SignalConnectorType signalConnector1( mType, SIGNAL_MODEL_LOADING_FINISHED, &Model::DoConnectSignal );
+SignalConnectorType signalConnector2( mType, SIGNAL_MODEL_SAVING_FINISHED, &Model::DoConnectSignal );
+
} // unnamed namespace
using Dali::Vector4;
UnregisterObject();
}
+bool Model::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+{
+ bool connected( true );
+ Model* model = dynamic_cast<Model*>(object);
+
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_MODEL_LOADING_FINISHED ) )
+ {
+ model->LoadingFinishedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_MODEL_SAVING_FINISHED ) )
+ {
+ model->SavingFinishedSignal().Connect( tracker, functor );
+ }
+ else
+ {
+ // signalName does not match any signal
+ connected = false;
+ }
+
+ return connected;
+}
+
void Model::ResourceLoadingFailed(const ResourceTicket& ticket)
{
DALI_LOG_TRACE_METHOD(Debug::Filter::gModel);
};
/**
+ * Connects a callback function with the object's signals.
+ * @param[in] object The object providing the signal.
+ * @param[in] tracker Used to disconnect the signal.
+ * @param[in] signalName The signal to connect to.
+ * @param[in] functor A newly allocated FunctorDelegate.
+ * @return True if the signal was connected.
+ * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
+ */
+ static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
+
+ /**
* returns the Id used for lookups
* @return the unique ID of the image data resource
*/
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/object/type-registry.h>
#include <dali/internal/common/event-to-update.h>
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
namespace // For internal properties
{
+// Signals
+
+const char* const SIGNAL_FINISHED = "finished";
+
+TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL );
+
+SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoConnectSignal );
+
const char* DEFAULT_PROPERTY_NAMES[] =
{
"viewport-position",
bool connected( true );
RenderTask* renderTask = dynamic_cast<RenderTask*>(object);
- if ( Dali::RenderTask::SIGNAL_FINISHED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
{
renderTask->FinishedSignal().Connect( tracker, functor );
}
namespace Dali
{
-const char* const Actor::SIGNAL_TOUCHED = "touched";
-const char* const Actor::SIGNAL_HOVERED = "hovered";
-const char* const Actor::SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
-const char* const Actor::SIGNAL_ON_STAGE = "on-stage";
-const char* const Actor::SIGNAL_OFF_STAGE = "off-stage";
-
-const char* const Actor::ACTION_SHOW = "show";
-const char* const Actor::ACTION_HIDE = "hide";
-
Actor::Actor()
{
}
* Key events are received by an actor once set to grab key events, only one actor can be set as focused.
*
* @nosubgrouping
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |-------------------|------------------------------|
+ * | touched | @ref TouchedSignal() |
+ * | hovered | @ref HoveredSignal() |
+ * | mouse-wheel-event | @ref MouseWheelEventSignal() |
+ * | on-stage | @ref OnStageSignal() |
+ * | off-stage | @ref OffStageSignal() |
+ *
+ * Actions
+ * | %Action Name | %Actor method called |
+ * |-------------------|------------------------------|
+ * | show | %SetVisible( true ) |
+ * | hide | %SetVisible( false ) |
*/
class DALI_IMPORT_API Actor : public Constrainable
{
public:
// Typedefs
-
typedef Signal< bool (Actor, const TouchEvent&)> TouchSignalType; ///< Touch signal type
typedef Signal< bool (Actor, const HoverEvent&)> HoverSignalType; ///< Hover signal type
typedef Signal< bool (Actor, const MouseWheelEvent&) > MouseWheelEventSignalType;///< Mousewheel signal type
static const Property::Index SIZE_MODE_FACTOR; ///< name "size-mode-factor", type VECTOR3
/** @} */
- /// @name Signals
- /** @{ */
- static const char* const SIGNAL_TOUCHED; ///< name "touched", @see TouchedSignal()
- static const char* const SIGNAL_HOVERED; ///< name "hovered", @see HoveredSignal()
- static const char* const SIGNAL_MOUSE_WHEEL_EVENT; ///< name "mouse-wheel-event", @see MouseWheelEventSignal()
- static const char* const SIGNAL_ON_STAGE; ///< name "on-stage", @see OnStageSignal()
- static const char* const SIGNAL_OFF_STAGE; ///< name "off-stage", @see OffStageSignal()
- /** @} */
-
- /// @name Actions
- /** @{ */
- static const char* const ACTION_SHOW; ///< name "show", @see SetVisible()
- static const char* const ACTION_HIDE; ///< name "hide", @see SetVisible()
- /** @} */
-
// Creation
/**
using Dali::Layer;
-const char* const Layer::ACTION_RAISE = "raise";
-const char* const Layer::ACTION_LOWER = "lower";
-const char* const Layer::ACTION_RAISE_TO_TOP = "raise-to-top";
-const char* const Layer::ACTION_LOWER_TO_BOTTOM = "lower-to-bottom";
-
-
Layer::Layer()
{
}
* actors in lower layers cannot obscure actors in higher layers.
*
* If depth test is disabled, there is no performance overhead from clearing the depth buffer.
+ *
+ * Actions
+ * | %Action Name | %Layer method called |
+ * |-----------------|----------------------|
+ * | raise | @ref Raise() |
+ * | lower | @ref Lower() |
+ * | raise-to-top | @ref RaiseToTop() |
+ * | lower-to-bottom | @ref LowerToBottom() |
*/
class DALI_IMPORT_API Layer : public Actor
{
static const Property::Index CLIPPING_ENABLE; ///< name "clipping-enable", type BOOLEAN
static const Property::Index CLIPPING_BOX; ///< name "clipping-box", type RECTANGLE
- // Action Names
- static const char* const ACTION_RAISE; ///< name "raise"
- static const char* const ACTION_LOWER; ///< name "lower"
- static const char* const ACTION_RAISE_TO_TOP; ///< name "raise-to-top"
- static const char* const ACTION_LOWER_TO_BOTTOM; ///< name "lower-to-bottom"
-
/**
* @brief The sort function type.
*
using std::string;
-const char* const TextActor::SIGNAL_TEXT_LOADING_FINISHED = "text-loading-finished";
-
TextActor::TextActor()
{
}
* using the font that the TextActor is using.
*
* By default CullFaceMode is set to CullNone to enable the TextActor to be viewed from all angles.
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |-----------------------|----------------------------|
+ * | text-loading-finished | @ref TextAvailableSignal() |
*/
class DALI_IMPORT_API TextActor : public RenderableActor
{
typedef Signal< void (TextActor) > TextSignalType; ///< Text available signal type
- //Signal Names
- static const char* const SIGNAL_TEXT_LOADING_FINISHED; ///< name "text-loading-finished"
-
// Default Properties; additional to RenderableActor properties
static const Property::Index TEXT; ///< name "text" type STRING
static const Property::Index FONT; ///< name "font" type STRING
const float ActiveConstraint::FINAL_WEIGHT = 1.0f;
const float ActiveConstraint::DEFAULT_WEIGHT = 1.0f;
-const char* const ActiveConstraint::SIGNAL_APPLIED = "applied";
-
ActiveConstraint::ActiveConstraint()
{
}
/**
* @brief A constraint which is being applied to an object.
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |--------------|-----------------------|
+ * | applied | @ref AppliedSignal() |
*/
class DALI_IMPORT_API ActiveConstraint : public Handle
{
static const float FINAL_WEIGHT; ///< 1.0f means the constraint is fully-applied, unless weight is still being animated
static const float DEFAULT_WEIGHT; ///< 1.0f
- //Signal Names
- static const char* const SIGNAL_APPLIED; ///< name "applied"
-
/**
* @brief Create an uninitialized Constraint; this can be initialized with Constraint::New().
*
namespace Dali
{
-const char* const Animation::SIGNAL_FINISHED = "finished";
-const char* const Animation::ACTION_PLAY = "play";
-const char* const Animation::ACTION_STOP = "stop";
-const char* const Animation::ACTION_PAUSE = "pause";
-
Animation::Animation()
{
}
*
* If the "Finish" signal is connected to a member function of an object, it must be disconnected before the object is destroyed.
* This is typically done in the object destructor, and requires either the Dali::Connection object or Dali::Animation handle to be stored.
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |--------------|--------------------------|
+ * | finished | @ref FinishedSignal() |
+ *
+ * Actions
+ * | %Action Name | %Animation method called |
+ * |--------------|--------------------------|
+ * | play | Play() |
+ * | stop | Stop() |
+ * | pause | Pause() |
*/
class DALI_IMPORT_API Animation : public BaseHandle
{
Cubic ///< Values in between key frames are interpolated using a cubic polynomial.
};
- //Signal Names
- static const char* const SIGNAL_FINISHED; ///< name "finished"
-
- //Action Names
- static const char* const ACTION_PLAY; ///< name "play"
- static const char* const ACTION_STOP; ///< name "stop"
- static const char* const ACTION_PAUSE; ///< name "pause"
-
/**
* @brief Create an uninitialized Animation; this can be initialized with Animation::New().
*
const Vector4 Stage::DEFAULT_BACKGROUND_COLOR(0.0f, 0.0f, 0.0f, 1.0f);
const Vector4 Stage::DEBUG_BACKGROUND_COLOR(0.2f, 0.5f, 0.2f, 1.0f);
-const char* const Stage::SIGNAL_KEY_EVENT = "key-event";
-const char* const Stage::SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
-const char* const Stage::SIGNAL_TOUCHED = "touched";
-
Stage::Stage()
{
}
* @brief The Stage is a top-level object used for displaying a tree of Actors.
*
* Multiple stage/window support is not currently provided.
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |---------------------------|--------------------------------------|
+ * | key-event | @ref KeyEventSignal() |
+ * | event-processing-finished | @ref EventProcessingFinishedSignal() |
+ * | touched | @ref TouchedSignal() |
+ * | context-lost | @ref ContextLostSignal() |
+ * | context-regained | @ref ContextRegainedSignal() |
+ * | scene-created | @ref SceneCreatedSignal() |
*/
class DALI_IMPORT_API Stage : public BaseHandle
{
static const Vector4 DEFAULT_BACKGROUND_COLOR; ///< Default black background.
static const Vector4 DEBUG_BACKGROUND_COLOR; ///< Green background, useful when debugging.
- // Signal Names
- static const char* const SIGNAL_KEY_EVENT; ///< name "key-event"
- static const char* const SIGNAL_EVENT_PROCESSING_FINISHED; ///< name "event-processing-finished"
- static const char* const SIGNAL_TOUCHED; ///< name "touched"
- static const char* const SIGNAL_CONTEXT_LOST; ///< name "context-lost"
- static const char* const SIGNAL_CONTEXT_REGAINED; ///< name "context-regained"
-
/**
* @brief Allows the creation of an empty stage handle.
*
DynamicsWorld::CollisionSignalType STUB_COLLISION_SIGNAL;
#endif
-const char* const DynamicsWorld::SIGNAL_COLLISION = "collision";
-
DynamicsWorld::DynamicsWorld()
{
}
* // Add the actor to the scene
* dynamicsRootActor.Add( actor );
* @endcode
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |---------------------------|----------------------------|
+ * | collision | @ref CollisionSignal() |
*/
class DALI_IMPORT_API DynamicsWorld : public BaseHandle
{
public:
- // Signal Names
- static const char* const SIGNAL_COLLISION; ///< name "collision"
-
// signals
- typedef Signal< void (DynamicsWorld, const DynamicsCollision) > CollisionSignalType; ///< Type of collision signal
+ typedef Signal< void ( DynamicsWorld, const DynamicsCollision ) > CollisionSignalType; ///< Type of collision signal
public:
/**
namespace Dali
{
-const char* const LongPressGestureDetector::SIGNAL_LONG_PRESS_DETECTED = "long-press-detected";
-
LongPressGestureDetector::LongPressGestureDetector(Internal::LongPressGestureDetector* internal)
: GestureDetector(internal)
{
* @endcode
*
* @see LongPressGesture
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |---------------------|-----------------------|
+ * | long-press-detected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API LongPressGestureDetector : public GestureDetector
{
typedef Signal< void ( Actor, const LongPressGesture& ) > DetectedSignalType; ///< Gesture detected signal type
- //Signal Names
- static const char* const SIGNAL_LONG_PRESS_DETECTED; ///< name "long-press-detected"
-
public: // Creation & Destruction
/**
namespace Dali
{
-const char* const PanGestureDetector::SIGNAL_PAN_DETECTED = "pan-detected";
-
const Radian PanGestureDetector::DIRECTION_LEFT( -Math::PI );
const Radian PanGestureDetector::DIRECTION_RIGHT( 0.0f );
const Radian PanGestureDetector::DIRECTION_UP( -0.5f * Math::PI );
* @endcode
*
* @see PanGesture
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |--------------|-----------------------|
+ * | pan-detected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API PanGestureDetector : public GestureDetector
{
static const Property::Index PANNING; ///< name "panning", type BOOLEAN
/** @} */
- /// @name Signals
- /** @{ */
- static const char* const SIGNAL_PAN_DETECTED; ///< name "pan-detected", @see DetectedSignal()
- /** @} */
-
public: // Creation & Destruction
/**
namespace Dali
{
-
-const char* const PinchGestureDetector::SIGNAL_PINCH_DETECTED = "pinch-detected";
-
PinchGestureDetector::PinchGestureDetector(Internal::PinchGestureDetector* internal)
: GestureDetector(internal)
{
* @endcode
*
* @see PinchGesture
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |----------------|-----------------------|
+ * | pinch-detected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API PinchGestureDetector : public GestureDetector
{
*/
typedef Signal< void ( Actor, const PinchGesture& ) > DetectedSignalType;
- //Signal Names
- static const char* const SIGNAL_PINCH_DETECTED; ///< name "pinch-detected"
-
public: // Creation & Destruction
/**
namespace Dali
{
-
-const char* const TapGestureDetector::SIGNAL_TAP_DETECTED = "tap-detected";
-
TapGestureDetector::TapGestureDetector(Internal::TapGestureDetector* internal)
: GestureDetector(internal)
{
* @endcode
*
* @see TapGesture
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |--------------|-----------------------|
+ * | tap-detected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API TapGestureDetector : public GestureDetector
{
*/
typedef Signal< void ( Actor, const TapGesture& ) > DetectedSignalType;
- //Signal Names
- static const char* const SIGNAL_TAP_DETECTED; ///< name "tap-detected"
-
public: // Creation & Destruction
/**
namespace Dali
{
-const char* const Image::SIGNAL_IMAGE_UPLOADED = "uploaded";
-
Image::Image()
{
}
* <i>Resolution of conflicting policies</i>
* If the same image is created more than once with conflicting policies, ReleasePolicy "Never" overrides "Unused".
*
+ * Signals
+ * | %Signal Name | Method |
+ * |------------------------|------------------------------|
+ * | uploaded | @ref UploadedSignal() |
*/
class DALI_IMPORT_API Image : public BaseHandle
{
};
/**
- * @brief Type of signal for LoadingFinished and Uploaded.
+ * @brief Type of signal for Image Uploaded.
*/
typedef Signal< void (Image) > ImageSignalType;
- // Signal Names
- static const char* const SIGNAL_IMAGE_UPLOADED; ///< Name of Uploaded signal
-
public:
/**
namespace Dali
{
-const char* const ResourceImage::SIGNAL_IMAGE_LOADING_FINISHED = "image-loading-finished";
-
Vector2 ResourceImage::GetImageSize( const std::string& url )
{
Vector2 size;
* Reload only takes effect if both of these conditions apply:
* - The ResourceImage has already finished loading
* - The ResourceImage is either on Stage or using IMMEDIATE load policy
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |------------------------|------------------------------|
+ * | image-loading-finished | @ref LoadingFinishedSignal() |
*/
class DALI_IMPORT_API ResourceImage : public Image
{
*/
typedef Signal< void (ResourceImage) > ResourceImageSignal;
- // Signal Names
- static const char* const SIGNAL_IMAGE_LOADING_FINISHED; ///< Name of LoadingFinished signal
-
public:
/**
namespace Dali
{
-const char* const Model::SIGNAL_MODEL_LOADING_FINISHED = "model-loading-finished";
-const char* const Model::SIGNAL_MODEL_SAVING_FINISHED = "model-saving-finished";
-
Model Model::New(const std::string& url)
{
Internal::ModelPtr internal = Internal::Model::New(url);
*
* Use ModelActorFactory::BuildActorTree() to create actors from this model.
* Use ModelActorFactory::BuildAnimation() to create animations on such actors.
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |------------------------|------------------------------|
+ * | model-loading-finished | @ref LoadingFinishedSignal() |
+ * | model-saving-finished | @ref SavingFinishedSignal() |
*/
class DALI_IMPORT_API Model : public BaseHandle
{
public:
- typedef Signal<void (Model)> ModelSignalType; ///< Signal type
- typedef Signal<void (Model,bool)> ModelSaveSignalType; ///< Signal type for saving models
-
- //Signal Names
- static const char* const SIGNAL_MODEL_LOADING_FINISHED; ///< name "model-loading-finished"
- static const char* const SIGNAL_MODEL_SAVING_FINISHED; ///< name "model-saving-finished"
+ typedef Signal< void ( Model ) > ModelSignalType; ///< Signal type
+ typedef Signal< void ( Model, bool ) > ModelSaveSignalType; ///< Signal type for saving models
public:
/**
namespace Dali
{
-const char* const ObjectRegistry::SIGNAL_OBJECT_CREATED = "object-created";
-const char* const ObjectRegistry::SIGNAL_OBJECT_DESTROYED = "object-destroyed";
-
ObjectRegistry::ObjectRegistry()
{
}
* ObjectRegistry registry = Stage::GetObjectRegistry();
* registry.ObjectCreatedSignal().Connect( ObjectCreatedCallbackFunc );
*
+ * Signals
+ * | %Signal Name | Method |
+ * |------------------|------------------------------|
+ * | object-created | @ref ObjectCreatedSignal() |
+ * | object-destroyed | @ref ObjectDestroyedSignal() |
*/
class DALI_IMPORT_API ObjectRegistry : public BaseHandle
{
public:
- //Signal Names
- static const char* const SIGNAL_OBJECT_CREATED; ///< Created signal name
- static const char* const SIGNAL_OBJECT_DESTROYED; ///< Destroyed signal name
-
// Typedefs
/**
* @brief Object created signal
*/
- typedef Signal< void (BaseHandle) > ObjectCreatedSignalType;
+ typedef Signal< void ( BaseHandle ) > ObjectCreatedSignalType;
/**
* @brief Object destroyed signal
*/
- typedef Signal< void (const Dali::RefObject*) > ObjectDestroyedSignalType;
+ typedef Signal< void ( const Dali::RefObject* ) > ObjectDestroyedSignalType;
/**
* @brief Allows the creation of an empty objectRegistry handle.
return true;
}
-const char* const RenderTask::SIGNAL_FINISHED = "finished";
-
RenderTask::ConstScreenToFrameBufferFunction RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION = DefaultScreenToFrameBufferFunction;
RenderTask::ConstScreenToFrameBufferFunction RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION = FullScreenFrameBufferFunction;
* If the refresh rate id REFRESH_ONCE and a "Finish" signal is connected, it will be emitted when the RenderTask is completed.
* Note that all connected signals must be disconnected before the object is destroyed. This is typically done in the
* object destructor, and requires either the Dali::Connection object or Dali::RenderTask handle to be stored.
+ *
+ * Signals
+ * | %Signal Name | Method |
+ * |--------------|-----------------------|
+ * | finished | @ref FinishedSignal() |
*/
class DALI_IMPORT_API RenderTask : public Constrainable
{
static const Property::Index VIEWPORT_SIZE; ///< Property 1, name "viewport-size", type VECTOR2
static const Property::Index CLEAR_COLOR; ///< Property 2, name "clear-color", type VECTOR4
- //Signal Names
- static const char* const SIGNAL_FINISHED; ///< Name for Finished signal
-
/**
* @brief A pointer to a function for converting screen to frame-buffer coordinates.
* @param[in,out] coordinates The screen coordinates to convert where (0,0) is the top-left of the screen.
projects / platform / core / uifw / dali-core.git / commitdiff