From 4da3f7e4fabb43ce7f34a298023361c57d11923c Mon Sep 17 00:00:00 2001
From: Kimmo Hoikka <kimmo.hoikka@samsung.com>
Date: Thu, 12 Feb 2015 10:43:36 +0000
Subject: [PATCH] remove (unnecessarily) exported signal and action names

Change-Id: Id6e2808bb600403faf71273ec7f6c259cc6269eb
---
 automated-tests/src/dali/utc-Dali-TypeRegistry.cpp | 10 ++--
 dali/internal/event/actors/actor-impl.cpp          | 47 +++++++++++-------
 dali/internal/event/actors/layer-impl.cpp          | 31 +++++++-----
 dali/internal/event/actors/text-actor-impl.cpp     | 10 +++-
 .../event/animation/active-constraint-base.cpp     |  8 ++-
 dali/internal/event/animation/animation-impl.cpp   | 34 ++++++++-----
 .../internal/event/common/object-registry-impl.cpp | 26 ++++++++--
 dali/internal/event/common/stage-impl.cpp          | 57 ++++++++++++++++++++++
 dali/internal/event/common/stage-impl.h            | 12 ++++-
 .../event/dynamics/dynamics-world-impl.cpp         |  8 ++-
 .../events/long-press-gesture-detector-impl.cpp    |  9 +++-
 .../event/events/pan-gesture-detector-impl.cpp     |  8 ++-
 .../event/events/pinch-gesture-detector-impl.cpp   |  9 +++-
 .../event/events/tap-gesture-detector-impl.cpp     |  8 ++-
 dali/internal/event/images/image-impl.cpp          | 10 ++--
 dali/internal/event/images/resource-image-impl.cpp | 14 +++---
 dali/internal/event/modeling/model-impl.cpp        | 32 ++++++++++++
 dali/internal/event/modeling/model-impl.h          | 11 +++++
 .../event/render-tasks/render-task-impl.cpp        | 11 ++++-
 dali/public-api/actors/actor.cpp                   |  9 ----
 dali/public-api/actors/actor.h                     | 31 ++++++------
 dali/public-api/actors/layer.cpp                   |  6 ---
 dali/public-api/actors/layer.h                     | 14 +++---
 dali/public-api/actors/text-actor.cpp              |  2 -
 dali/public-api/actors/text-actor.h                |  8 +--
 dali/public-api/animation/active-constraint.cpp    |  2 -
 dali/public-api/animation/active-constraint.h      |  8 +--
 dali/public-api/animation/animation.cpp            |  5 --
 dali/public-api/animation/animation.h              | 20 +++++---
 dali/public-api/common/stage.cpp                   |  4 --
 dali/public-api/common/stage.h                     | 17 ++++---
 dali/public-api/dynamics/dynamics-world.cpp        |  2 -
 dali/public-api/dynamics/dynamics-world.h          | 10 ++--
 .../events/long-press-gesture-detector.cpp         |  2 -
 .../events/long-press-gesture-detector.h           |  8 +--
 dali/public-api/events/pan-gesture-detector.cpp    |  2 -
 dali/public-api/events/pan-gesture-detector.h      | 10 ++--
 dali/public-api/events/pinch-gesture-detector.cpp  |  3 --
 dali/public-api/events/pinch-gesture-detector.h    |  8 +--
 dali/public-api/events/tap-gesture-detector.cpp    |  3 --
 dali/public-api/events/tap-gesture-detector.h      |  8 +--
 dali/public-api/images/image.cpp                   |  2 -
 dali/public-api/images/image.h                     |  9 ++--
 dali/public-api/images/resource-image.cpp          |  2 -
 dali/public-api/images/resource-image.h            |  8 +--
 dali/public-api/modeling/model.cpp                 |  3 --
 dali/public-api/modeling/model.h                   | 14 +++---
 dali/public-api/object/object-registry.cpp         |  3 --
 dali/public-api/object/object-registry.h           | 13 ++---
 dali/public-api/render-tasks/render-task.cpp       |  2 -
 dali/public-api/render-tasks/render-task.h         |  8 +--
 51 files changed, 390 insertions(+), 211 deletions(-)

diff --git a/automated-tests/src/dali/utc-Dali-TypeRegistry.cpp b/automated-tests/src/dali/utc-Dali-TypeRegistry.cpp
index 30b9cbe..9032640 100644
--- a/automated-tests/src/dali/utc-Dali-TypeRegistry.cpp
+++ b/automated-tests/src/dali/utc-Dali-TypeRegistry.cpp
@@ -576,7 +576,7 @@ int UtcDaliTypeRegistryActionViaBaseHandle(void)
 
   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);
@@ -1029,7 +1029,7 @@ int UtcDaliLongPressGestureDetectorTypeRegistry(void)
   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();
@@ -1067,7 +1067,7 @@ int UtcDaliPanGestureDetectorTypeRegistry(void)
   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();
@@ -1105,7 +1105,7 @@ int UtcDaliPinchGestureDetectorTypeRegistry(void)
   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();
@@ -1141,7 +1141,7 @@ int UtcDaliTapGestureDetectorTypeRegistry(void)
   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();
diff --git a/dali/internal/event/actors/actor-impl.cpp b/dali/internal/event/actors/actor-impl.cpp
index c19b6ed..21940ed 100644
--- a/dali/internal/event/actors/actor-impl.cpp
+++ b/dali/internal/event/actors/actor-impl.cpp
@@ -210,22 +210,33 @@ struct DynamicsData
 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 );
 
 }
 
@@ -2015,25 +2026,25 @@ Dali::Actor::OffStageSignalType& Actor::OffStageSignal()
 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 );
   }
@@ -3464,19 +3475,19 @@ SceneGraph::Node* Actor::CreateNode() const
   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;
diff --git a/dali/internal/event/actors/layer-impl.cpp b/dali/internal/event/actors/layer-impl.cpp
index 3550e74..f83d627 100644
--- a/dali/internal/event/actors/layer-impl.cpp
+++ b/dali/internal/event/actors/layer-impl.cpp
@@ -39,17 +39,24 @@ namespace Internal
 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[] =
 {
@@ -499,29 +506,29 @@ Property::Value Layer::GetDefaultProperty( Property::Index index ) const
   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;
diff --git a/dali/internal/event/actors/text-actor-impl.cpp b/dali/internal/event/actors/text-actor-impl.cpp
index f4fcbed..c8957f9 100644
--- a/dali/internal/event/actors/text-actor-impl.cpp
+++ b/dali/internal/event/actors/text-actor-impl.cpp
@@ -59,6 +59,12 @@ const Property::Index TextActor::TEXT_COLOR                 = Internal::DEFAULT_
 namespace
 {
 
+// Signals
+
+const char* const SIGNAL_TEXT_LOADING_FINISHED = "text-loading-finished";
+
+// Default property names
+
 const char* DEFAULT_TEXT_ACTOR_PROPERTY_NAMES[] =
 {
   "text",
@@ -127,7 +133,7 @@ BaseHandle Create()
 
 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 );
 
 }
 
@@ -569,7 +575,7 @@ bool TextActor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface*
   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 );
   }
diff --git a/dali/internal/event/animation/active-constraint-base.cpp b/dali/internal/event/animation/active-constraint-base.cpp
index 0212772..3638315 100644
--- a/dali/internal/event/animation/active-constraint-base.cpp
+++ b/dali/internal/event/animation/active-constraint-base.cpp
@@ -41,6 +41,10 @@ namespace Internal
 namespace // unnamed namespace
 {
 
+// Signals
+
+const char* const SIGNAL_APPLIED = "applied";
+
 BaseHandle Create()
 {
   // not directly creatable
@@ -49,7 +53,7 @@ BaseHandle Create()
 
 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 );
 
 }
 
@@ -272,7 +276,7 @@ bool ActiveConstraintBase::DoConnectSignal( BaseObject* object, ConnectionTracke
   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 );
   }
diff --git a/dali/internal/event/animation/animation-impl.cpp b/dali/internal/event/animation/animation-impl.cpp
index 55427b6..358b42e 100644
--- a/dali/internal/event/animation/animation-impl.cpp
+++ b/dali/internal/event/animation/animation-impl.cpp
@@ -50,6 +50,16 @@ static bool HIDE_VALUE = false;
 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);
@@ -57,11 +67,11 @@ BaseHandle Create()
 
 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 );
@@ -691,7 +701,7 @@ bool Animation::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface*
   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 );
   }
@@ -1087,29 +1097,29 @@ void Animation::Resize(Actor& actor, const Vector3& size, AlphaFunction alpha, f
                                                          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;
diff --git a/dali/internal/event/common/object-registry-impl.cpp b/dali/internal/event/common/object-registry-impl.cpp
index a4ba77c..edd5232 100644
--- a/dali/internal/event/common/object-registry-impl.cpp
+++ b/dali/internal/event/common/object-registry-impl.cpp
@@ -24,6 +24,7 @@
 // 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
 {
@@ -31,9 +32,24 @@ 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()
@@ -61,12 +77,16 @@ void ObjectRegistry::UnregisterObject( Dali::BaseObject* object )
 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
diff --git a/dali/internal/event/common/stage-impl.cpp b/dali/internal/event/common/stage-impl.cpp
index 0e5130a..16244b8 100644
--- a/dali/internal/event/common/stage-impl.cpp
+++ b/dali/internal/event/common/stage-impl.cpp
@@ -36,6 +36,7 @@
 #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
@@ -58,6 +59,24 @@ namespace
 
 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,
@@ -489,6 +508,44 @@ void Stage::KeepRendering( float durationSeconds )
   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
diff --git a/dali/internal/event/common/stage-impl.h b/dali/internal/event/common/stage-impl.h
index 3a9bd85..d7787c3 100644
--- a/dali/internal/event/common/stage-impl.h
+++ b/dali/internal/event/common/stage-impl.h
@@ -332,7 +332,6 @@ public:
     return mNotificationManager;
   }
 
-
   /**
    * @copydoc Dali::Stage::KeepRendering()
    */
@@ -392,6 +391,17 @@ public:
    */
   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:
 
   /**
diff --git a/dali/internal/event/dynamics/dynamics-world-impl.cpp b/dali/internal/event/dynamics/dynamics-world-impl.cpp
index 220b803..4eddd39 100644
--- a/dali/internal/event/dynamics/dynamics-world-impl.cpp
+++ b/dali/internal/event/dynamics/dynamics-world-impl.cpp
@@ -44,6 +44,10 @@ namespace Internal
 namespace
 {
 
+// Signals
+
+const char* const SIGNAL_COLLISION = "collision";
+
 BaseHandle Create()
 {
   DynamicsWorldPtr p = Stage::GetCurrent()->GetDynamicsWorld();
@@ -52,7 +56,7 @@ BaseHandle Create()
 
 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
 
@@ -115,7 +119,7 @@ bool DynamicsWorld::DoConnectSignal( BaseObject* object, ConnectionTrackerInterf
   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 );
   }
diff --git a/dali/internal/event/events/long-press-gesture-detector-impl.cpp b/dali/internal/event/events/long-press-gesture-detector-impl.cpp
index dde8c6d..edc5850 100644
--- a/dali/internal/event/events/long-press-gesture-detector-impl.cpp
+++ b/dali/internal/event/events/long-press-gesture-detector-impl.cpp
@@ -31,6 +31,11 @@ namespace Internal
 
 namespace
 {
+
+// Signals
+
+const char* const SIGNAL_LONG_PRESS_DETECTED = "long-press-detected";
+
 BaseHandle Create()
 {
   return Dali::LongPressGestureDetector::New();
@@ -38,7 +43,7 @@ BaseHandle Create()
 
 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 );
 
 }
 
@@ -137,7 +142,7 @@ bool LongPressGestureDetector::DoConnectSignal( BaseObject* object, ConnectionTr
   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 );
   }
diff --git a/dali/internal/event/events/pan-gesture-detector-impl.cpp b/dali/internal/event/events/pan-gesture-detector-impl.cpp
index d1f3734..5c9ea9e 100644
--- a/dali/internal/event/events/pan-gesture-detector-impl.cpp
+++ b/dali/internal/event/events/pan-gesture-detector-impl.cpp
@@ -61,6 +61,10 @@ PropertyDetails DEFAULT_PROPERTIES[] =
 };
 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();
@@ -68,7 +72,7 @@ BaseHandle Create()
 
 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");
@@ -291,7 +295,7 @@ bool PanGestureDetector::DoConnectSignal( BaseObject* object, ConnectionTrackerI
   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 );
   }
diff --git a/dali/internal/event/events/pinch-gesture-detector-impl.cpp b/dali/internal/event/events/pinch-gesture-detector-impl.cpp
index 2d6e322..370c1e8 100644
--- a/dali/internal/event/events/pinch-gesture-detector-impl.cpp
+++ b/dali/internal/event/events/pinch-gesture-detector-impl.cpp
@@ -32,6 +32,11 @@ namespace Internal
 
 namespace
 {
+
+// Signals
+
+const char* const SIGNAL_PINCH_DETECTED = "pinch-detected";
+
 BaseHandle Create()
 {
   return Dali::PinchGestureDetector::New();
@@ -39,7 +44,7 @@ BaseHandle Create()
 
 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 );
 
 }
 
@@ -71,7 +76,7 @@ bool PinchGestureDetector::DoConnectSignal( BaseObject* object, ConnectionTracke
   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 );
   }
diff --git a/dali/internal/event/events/tap-gesture-detector-impl.cpp b/dali/internal/event/events/tap-gesture-detector-impl.cpp
index 6932eb7..2d84a8d 100644
--- a/dali/internal/event/events/tap-gesture-detector-impl.cpp
+++ b/dali/internal/event/events/tap-gesture-detector-impl.cpp
@@ -32,6 +32,10 @@ namespace Internal
 
 namespace
 {
+
+// Signals
+const char* const SIGNAL_TAP_DETECTED = "tap-detected";
+
 BaseHandle Create()
 {
   return Dali::TapGestureDetector::New();
@@ -39,7 +43,7 @@ BaseHandle Create()
 
 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 );
 
 }
 
@@ -124,7 +128,7 @@ bool TapGestureDetector::DoConnectSignal( BaseObject* object, ConnectionTrackerI
   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 );
   }
diff --git a/dali/internal/event/images/image-impl.cpp b/dali/internal/event/images/image-impl.cpp
index 78cf0d3..2c7cd27 100644
--- a/dali/internal/event/images/image-impl.cpp
+++ b/dali/internal/event/images/image-impl.cpp
@@ -39,9 +39,13 @@ namespace Internal
 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 );
 
 }
 
@@ -69,7 +73,7 @@ bool Image::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
   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 );
   }
diff --git a/dali/internal/event/images/resource-image-impl.cpp b/dali/internal/event/images/resource-image-impl.cpp
index b2a937d..4724cbc 100644
--- a/dali/internal/event/images/resource-image-impl.cpp
+++ b/dali/internal/event/images/resource-image-impl.cpp
@@ -38,15 +38,19 @@ namespace Internal
 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 );
 
 }
 
@@ -112,14 +116,10 @@ bool ResourceImage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterf
   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
diff --git a/dali/internal/event/modeling/model-impl.cpp b/dali/internal/event/modeling/model-impl.cpp
index 04a588f..47efeb2 100644
--- a/dali/internal/event/modeling/model-impl.cpp
+++ b/dali/internal/event/modeling/model-impl.cpp
@@ -47,7 +47,17 @@ namespace Internal
 
 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;
@@ -82,6 +92,28 @@ Model::~Model()
   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);
diff --git a/dali/internal/event/modeling/model-impl.h b/dali/internal/event/modeling/model-impl.h
index 81d553b..4154768 100644
--- a/dali/internal/event/modeling/model-impl.h
+++ b/dali/internal/event/modeling/model-impl.h
@@ -105,6 +105,17 @@ public: // Query methods from external model
   };
 
   /**
+   * 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
    */
diff --git a/dali/internal/event/render-tasks/render-task-impl.cpp b/dali/internal/event/render-tasks/render-task-impl.cpp
index 7304bfc..5976370 100644
--- a/dali/internal/event/render-tasks/render-task-impl.cpp
+++ b/dali/internal/event/render-tasks/render-task-impl.cpp
@@ -20,6 +20,7 @@
 
 // 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>
@@ -49,6 +50,14 @@ namespace Internal
 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",
@@ -684,7 +693,7 @@ bool RenderTask::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface
   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 );
   }
diff --git a/dali/public-api/actors/actor.cpp b/dali/public-api/actors/actor.cpp
index 2293fbb..f3beeb8 100644
--- a/dali/public-api/actors/actor.cpp
+++ b/dali/public-api/actors/actor.cpp
@@ -46,15 +46,6 @@
 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()
 {
 }
diff --git a/dali/public-api/actors/actor.h b/dali/public-api/actors/actor.h
index e2afdcb..fff15b4 100644
--- a/dali/public-api/actors/actor.h
+++ b/dali/public-api/actors/actor.h
@@ -227,13 +227,27 @@ typedef ActorContainer::const_iterator ActorConstIter; ///< Const iterator for D
  * 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
@@ -289,21 +303,6 @@ public:
   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
 
   /**
diff --git a/dali/public-api/actors/layer.cpp b/dali/public-api/actors/layer.cpp
index ca32115..5caad6d 100644
--- a/dali/public-api/actors/layer.cpp
+++ b/dali/public-api/actors/layer.cpp
@@ -27,12 +27,6 @@ namespace Dali
 
 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()
 {
 }
diff --git a/dali/public-api/actors/layer.h b/dali/public-api/actors/layer.h
index a00e85b..71437a6 100644
--- a/dali/public-api/actors/layer.h
+++ b/dali/public-api/actors/layer.h
@@ -52,6 +52,14 @@ typedef Rect<int> ClippingBox;
  * 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
 {
@@ -61,12 +69,6 @@ public:
   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.
    *
diff --git a/dali/public-api/actors/text-actor.cpp b/dali/public-api/actors/text-actor.cpp
index f87df0d..64aba2e 100644
--- a/dali/public-api/actors/text-actor.cpp
+++ b/dali/public-api/actors/text-actor.cpp
@@ -29,8 +29,6 @@ namespace Dali
 
 using std::string;
 
-const char* const TextActor::SIGNAL_TEXT_LOADING_FINISHED = "text-loading-finished";
-
 TextActor::TextActor()
 {
 }
diff --git a/dali/public-api/actors/text-actor.h b/dali/public-api/actors/text-actor.h
index 9527569..2c2eadd 100644
--- a/dali/public-api/actors/text-actor.h
+++ b/dali/public-api/actors/text-actor.h
@@ -50,6 +50,11 @@ class 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
 {
@@ -57,9 +62,6 @@ public:
 
   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
diff --git a/dali/public-api/animation/active-constraint.cpp b/dali/public-api/animation/active-constraint.cpp
index 55279b7..5ee5f48 100644
--- a/dali/public-api/animation/active-constraint.cpp
+++ b/dali/public-api/animation/active-constraint.cpp
@@ -27,8 +27,6 @@ namespace Dali
 const float ActiveConstraint::FINAL_WEIGHT   = 1.0f;
 const float ActiveConstraint::DEFAULT_WEIGHT = 1.0f;
 
-const char* const ActiveConstraint::SIGNAL_APPLIED = "applied";
-
 ActiveConstraint::ActiveConstraint()
 {
 }
diff --git a/dali/public-api/animation/active-constraint.h b/dali/public-api/animation/active-constraint.h
index fed31a6..a5a9329 100644
--- a/dali/public-api/animation/active-constraint.h
+++ b/dali/public-api/animation/active-constraint.h
@@ -34,6 +34,11 @@ class ActiveConstraintBase;
 
 /**
  * @brief A constraint which is being applied to an object.
+ *
+ * Signals
+ * | %Signal Name | Method                |
+ * |--------------|-----------------------|
+ * | applied      | @ref AppliedSignal()  |
  */
 class DALI_IMPORT_API ActiveConstraint : public Handle
 {
@@ -45,9 +50,6 @@ public:
   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().
    *
diff --git a/dali/public-api/animation/animation.cpp b/dali/public-api/animation/animation.cpp
index 03d8099..8a1c501 100644
--- a/dali/public-api/animation/animation.cpp
+++ b/dali/public-api/animation/animation.cpp
@@ -32,11 +32,6 @@
 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()
 {
 }
diff --git a/dali/public-api/animation/animation.h b/dali/public-api/animation/animation.h
index fd7cf51..6e9c317 100644
--- a/dali/public-api/animation/animation.h
+++ b/dali/public-api/animation/animation.h
@@ -97,6 +97,18 @@ class 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
 {
@@ -125,14 +137,6 @@ public:
     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().
    *
diff --git a/dali/public-api/common/stage.cpp b/dali/public-api/common/stage.cpp
index b47f7ea..e7d65e9 100644
--- a/dali/public-api/common/stage.cpp
+++ b/dali/public-api/common/stage.cpp
@@ -43,10 +43,6 @@ using Internal::Core;
 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()
 {
 }
diff --git a/dali/public-api/common/stage.h b/dali/public-api/common/stage.h
index 23c8bc6..c97547f 100644
--- a/dali/public-api/common/stage.h
+++ b/dali/public-api/common/stage.h
@@ -46,6 +46,16 @@ struct TouchEvent;
  * @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
 {
@@ -60,13 +70,6 @@ public:
   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.
    *
diff --git a/dali/public-api/dynamics/dynamics-world.cpp b/dali/public-api/dynamics/dynamics-world.cpp
index a044bc3..ef68991 100644
--- a/dali/public-api/dynamics/dynamics-world.cpp
+++ b/dali/public-api/dynamics/dynamics-world.cpp
@@ -35,8 +35,6 @@ namespace Dali
 DynamicsWorld::CollisionSignalType STUB_COLLISION_SIGNAL;
 #endif
 
-const char* const DynamicsWorld::SIGNAL_COLLISION = "collision";
-
 DynamicsWorld::DynamicsWorld()
 {
 }
diff --git a/dali/public-api/dynamics/dynamics-world.h b/dali/public-api/dynamics/dynamics-world.h
index c7b2791..939c80a 100644
--- a/dali/public-api/dynamics/dynamics-world.h
+++ b/dali/public-api/dynamics/dynamics-world.h
@@ -76,16 +76,18 @@ class DynamicsShape;
  * // 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:
   /**
diff --git a/dali/public-api/events/long-press-gesture-detector.cpp b/dali/public-api/events/long-press-gesture-detector.cpp
index b53bb03..f66dea7 100644
--- a/dali/public-api/events/long-press-gesture-detector.cpp
+++ b/dali/public-api/events/long-press-gesture-detector.cpp
@@ -24,8 +24,6 @@
 namespace Dali
 {
 
-const char* const LongPressGestureDetector::SIGNAL_LONG_PRESS_DETECTED = "long-press-detected";
-
 LongPressGestureDetector::LongPressGestureDetector(Internal::LongPressGestureDetector* internal)
 : GestureDetector(internal)
 {
diff --git a/dali/public-api/events/long-press-gesture-detector.h b/dali/public-api/events/long-press-gesture-detector.h
index dc1f874..014c8dc 100644
--- a/dali/public-api/events/long-press-gesture-detector.h
+++ b/dali/public-api/events/long-press-gesture-detector.h
@@ -48,6 +48,11 @@ struct LongPressGesture;
  * @endcode
  *
  * @see LongPressGesture
+ *
+ * Signals
+ * | %Signal Name        | Method                |
+ * |---------------------|-----------------------|
+ * | long-press-detected | @ref DetectedSignal() |
  */
 class DALI_IMPORT_API LongPressGestureDetector : public GestureDetector
 {
@@ -55,9 +60,6 @@ public: // Typedefs
 
   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
 
   /**
diff --git a/dali/public-api/events/pan-gesture-detector.cpp b/dali/public-api/events/pan-gesture-detector.cpp
index 76b63c4..68997d9 100644
--- a/dali/public-api/events/pan-gesture-detector.cpp
+++ b/dali/public-api/events/pan-gesture-detector.cpp
@@ -24,8 +24,6 @@
 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 );
diff --git a/dali/public-api/events/pan-gesture-detector.h b/dali/public-api/events/pan-gesture-detector.h
index 9f819bd..94ebca6 100644
--- a/dali/public-api/events/pan-gesture-detector.h
+++ b/dali/public-api/events/pan-gesture-detector.h
@@ -50,6 +50,11 @@ struct PanGesture;
  * @endcode
  *
  * @see PanGesture
+ *
+ * Signals
+ * | %Signal Name | Method                |
+ * |--------------|-----------------------|
+ * | pan-detected | @ref DetectedSignal() |
  */
 class DALI_IMPORT_API PanGestureDetector : public GestureDetector
 {
@@ -82,11 +87,6 @@ public:
   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
 
   /**
diff --git a/dali/public-api/events/pinch-gesture-detector.cpp b/dali/public-api/events/pinch-gesture-detector.cpp
index db2c648..ffbfa5b 100644
--- a/dali/public-api/events/pinch-gesture-detector.cpp
+++ b/dali/public-api/events/pinch-gesture-detector.cpp
@@ -23,9 +23,6 @@
 
 namespace Dali
 {
-
-const char* const PinchGestureDetector::SIGNAL_PINCH_DETECTED = "pinch-detected";
-
 PinchGestureDetector::PinchGestureDetector(Internal::PinchGestureDetector* internal)
 : GestureDetector(internal)
 {
diff --git a/dali/public-api/events/pinch-gesture-detector.h b/dali/public-api/events/pinch-gesture-detector.h
index 7dde723..57f4fe3 100644
--- a/dali/public-api/events/pinch-gesture-detector.h
+++ b/dali/public-api/events/pinch-gesture-detector.h
@@ -47,6 +47,11 @@ struct PinchGesture;
  * @endcode
  *
  * @see PinchGesture
+ *
+ * Signals
+ * | %Signal Name   | Method                |
+ * |----------------|-----------------------|
+ * | pinch-detected | @ref DetectedSignal() |
  */
 class DALI_IMPORT_API PinchGestureDetector : public GestureDetector
 {
@@ -57,9 +62,6 @@ public: // Typedefs
    */
   typedef Signal< void ( Actor, const PinchGesture& ) > DetectedSignalType;
 
-  //Signal Names
-  static const char* const SIGNAL_PINCH_DETECTED; ///< name "pinch-detected"
-
 public: // Creation & Destruction
 
   /**
diff --git a/dali/public-api/events/tap-gesture-detector.cpp b/dali/public-api/events/tap-gesture-detector.cpp
index fe7507e..9661f4d 100644
--- a/dali/public-api/events/tap-gesture-detector.cpp
+++ b/dali/public-api/events/tap-gesture-detector.cpp
@@ -23,9 +23,6 @@
 
 namespace Dali
 {
-
-const char* const TapGestureDetector::SIGNAL_TAP_DETECTED = "tap-detected";
-
 TapGestureDetector::TapGestureDetector(Internal::TapGestureDetector* internal)
 : GestureDetector(internal)
 {
diff --git a/dali/public-api/events/tap-gesture-detector.h b/dali/public-api/events/tap-gesture-detector.h
index cceca09..6307093 100644
--- a/dali/public-api/events/tap-gesture-detector.h
+++ b/dali/public-api/events/tap-gesture-detector.h
@@ -49,6 +49,11 @@ struct TapGesture;
  * @endcode
  *
  * @see TapGesture
+ *
+ * Signals
+ * | %Signal Name | Method                |
+ * |--------------|-----------------------|
+ * | tap-detected | @ref DetectedSignal() |
  */
 class DALI_IMPORT_API TapGestureDetector : public GestureDetector
 {
@@ -59,9 +64,6 @@ public: // Typedefs
    */
   typedef Signal< void ( Actor, const TapGesture& ) > DetectedSignalType;
 
-  //Signal Names
-  static const char* const SIGNAL_TAP_DETECTED; ///< name "tap-detected"
-
 public: // Creation & Destruction
 
   /**
diff --git a/dali/public-api/images/image.cpp b/dali/public-api/images/image.cpp
index d371c18..ad394d0 100644
--- a/dali/public-api/images/image.cpp
+++ b/dali/public-api/images/image.cpp
@@ -25,8 +25,6 @@
 namespace Dali
 {
 
-const char* const Image::SIGNAL_IMAGE_UPLOADED = "uploaded";
-
 Image::Image()
 {
 }
diff --git a/dali/public-api/images/image.h b/dali/public-api/images/image.h
index 1ff0273..3c719ae 100644
--- a/dali/public-api/images/image.h
+++ b/dali/public-api/images/image.h
@@ -53,6 +53,10 @@ class NativeImage;
  * <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
 {
@@ -71,13 +75,10 @@ public:
   };
 
   /**
-   * @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:
 
   /**
diff --git a/dali/public-api/images/resource-image.cpp b/dali/public-api/images/resource-image.cpp
index 9f4ed32..3866d9d 100644
--- a/dali/public-api/images/resource-image.cpp
+++ b/dali/public-api/images/resource-image.cpp
@@ -28,8 +28,6 @@
 namespace Dali
 {
 
-const char* const ResourceImage::SIGNAL_IMAGE_LOADING_FINISHED = "image-loading-finished";
-
 Vector2 ResourceImage::GetImageSize( const std::string& url )
 {
   Vector2 size;
diff --git a/dali/public-api/images/resource-image.h b/dali/public-api/images/resource-image.h
index 96808b3..4ea879e 100644
--- a/dali/public-api/images/resource-image.h
+++ b/dali/public-api/images/resource-image.h
@@ -73,6 +73,11 @@ class ResourceImage;
  * 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
 {
@@ -95,9 +100,6 @@ public:
    */
   typedef Signal< void (ResourceImage) > ResourceImageSignal;
 
-  // Signal Names
-  static const char* const SIGNAL_IMAGE_LOADING_FINISHED; ///< Name of LoadingFinished signal
-
 public:
 
   /**
diff --git a/dali/public-api/modeling/model.cpp b/dali/public-api/modeling/model.cpp
index 407dfce..47e288c 100644
--- a/dali/public-api/modeling/model.cpp
+++ b/dali/public-api/modeling/model.cpp
@@ -26,9 +26,6 @@
 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);
diff --git a/dali/public-api/modeling/model.h b/dali/public-api/modeling/model.h
index b74ba7e..cdfafd2 100644
--- a/dali/public-api/modeling/model.h
+++ b/dali/public-api/modeling/model.h
@@ -44,17 +44,19 @@ class Model;
  *
  * 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:
   /**
diff --git a/dali/public-api/object/object-registry.cpp b/dali/public-api/object/object-registry.cpp
index f9e138e..6bb320f 100644
--- a/dali/public-api/object/object-registry.cpp
+++ b/dali/public-api/object/object-registry.cpp
@@ -24,9 +24,6 @@
 namespace Dali
 {
 
-const char* const ObjectRegistry::SIGNAL_OBJECT_CREATED = "object-created";
-const char* const ObjectRegistry::SIGNAL_OBJECT_DESTROYED = "object-destroyed";
-
 ObjectRegistry::ObjectRegistry()
 {
 }
diff --git a/dali/public-api/object/object-registry.h b/dali/public-api/object/object-registry.h
index ff18047..8adf1c3 100644
--- a/dali/public-api/object/object-registry.h
+++ b/dali/public-api/object/object-registry.h
@@ -48,26 +48,27 @@ class 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.
diff --git a/dali/public-api/render-tasks/render-task.cpp b/dali/public-api/render-tasks/render-task.cpp
index 8e78377..35fa83d 100644
--- a/dali/public-api/render-tasks/render-task.cpp
+++ b/dali/public-api/render-tasks/render-task.cpp
@@ -38,8 +38,6 @@ static bool FullScreenFrameBufferFunction( Vector2& coordinates )
   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;
 
diff --git a/dali/public-api/render-tasks/render-task.h b/dali/public-api/render-tasks/render-task.h
index 8fc207a..73bf6d3 100644
--- a/dali/public-api/render-tasks/render-task.h
+++ b/dali/public-api/render-tasks/render-task.h
@@ -68,6 +68,11 @@ class RenderTask;
  * 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
 {
@@ -82,9 +87,6 @@ public:
   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.
-- 
2.7.4