dali/internal/event/common/stage-impl.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/common/stage-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23 #include <cmath>
  24 #include <cstring> // for strcmp
  25
  26 // INTERNAL INCLUDES
  27 #include <dali/integration-api/system-overlay.h>
  28 #include <dali/internal/event/actors/layer-impl.h>
  29 #include <dali/internal/event/actors/layer-list.h>
  30 #include <dali/internal/event/actors/camera-actor-impl.h>
  31 #include <dali/internal/event/common/system-overlay-impl.h>
  32 #include <dali/internal/event/common/thread-local-storage.h>
  33 #include <dali/internal/event/common/property-notification-manager.h>
  34 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  35 #include <dali/internal/update/nodes/node.h>
  36 #include <dali/internal/event/common/object-registry-impl.h>
  37 #include <dali/integration-api/platform-abstraction.h>
  38 #include <dali/public-api/common/constants.h>
  39 #include <dali/public-api/events/touch-data.h>
  40 #include <dali/public-api/object/type-registry.h>
  41 #include <dali/public-api/render-tasks/render-task-list.h>
  42 #include <dali/public-api/rendering/frame-buffer.h>
  43
  44 using Dali::Internal::SceneGraph::Node;
  45
  46 namespace
  47 {
  48 #if defined(DEBUG_ENABLED)
  49 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_DEPTH_TIMER" );
  50 #endif
  51 }
  52
  53 namespace Dali
  54 {
  55
  56 namespace Internal
  57 {
  58
  59 namespace
  60 {
  61
  62 const float DEFAULT_STEREO_BASE( 65.0f );
  63
  64 // Signals
  65
  66 const char* const SIGNAL_KEY_EVENT =                 "keyEvent";
  67 const char* const SIGNAL_KEY_EVENT_GENERATED =       "keyEventGenerated";
  68 const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished";
  69 const char* const SIGNAL_TOUCHED =                   "touched";
  70 const char* const SIGNAL_TOUCH =                     "touch";
  71 const char* const SIGNAL_WHEEL_EVENT =               "wheelEvent";
  72 const char* const SIGNAL_CONTEXT_LOST =              "contextLost";
  73 const char* const SIGNAL_CONTEXT_REGAINED =          "contextRegained";
  74 const char* const SIGNAL_SCENE_CREATED =             "sceneCreated";
  75
  76 TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
  77
  78 SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT,                 &Stage::DoConnectSignal );
  79 SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
  80 SignalConnectorType signalConnector3( mType, SIGNAL_TOUCHED,                   &Stage::DoConnectSignal );
  81 SignalConnectorType signalConnector4( mType, SIGNAL_WHEEL_EVENT,               &Stage::DoConnectSignal );
  82 SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_LOST,              &Stage::DoConnectSignal );
  83 SignalConnectorType signalConnector6( mType, SIGNAL_CONTEXT_REGAINED,          &Stage::DoConnectSignal );
  84 SignalConnectorType signalConnector7( mType, SIGNAL_SCENE_CREATED,             &Stage::DoConnectSignal );
  85 SignalConnectorType signalConnector8( mType, SIGNAL_KEY_EVENT_GENERATED,       &Stage::DoConnectSignal );
  86 SignalConnectorType signalConnector9( mType, SIGNAL_TOUCH,                     &Stage::DoConnectSignal );
  87
  88 } // unnamed namespace
  89
  90 StagePtr Stage::New( AnimationPlaylist& playlist,
  91                      PropertyNotificationManager& propertyNotificationManager,
  92                      SceneGraph::UpdateManager& updateManager,
  93                      NotificationManager& notificationManager,
  94                      Integration::RenderController& renderController )
  95 {
  96   return StagePtr( new Stage( playlist, propertyNotificationManager, updateManager, notificationManager, renderController ) );
  97 }
  98
  99 void Stage::Initialize( bool renderToFbo )
 100 {
 101   mRenderToFbo = renderToFbo;
 102   mObjectRegistry = ObjectRegistry::New();
 103
 104   // Create the ordered list of layers
 105   mLayerList = LayerList::New( mUpdateManager, false/*not system-level*/ );
 106
 107   // The stage owns the default layer
 108   mRootLayer = Layer::NewRoot( *mLayerList, mUpdateManager, false/*not system-level*/ );
 109   mRootLayer->SetName("RootLayer");
 110   // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
 111   // This stops actors parented to the stage having their relayout requests propagating
 112   // up to the root layer, and down through other children unnecessarily.
 113   mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 114
 115   // Create the default camera actor first; this is needed by the RenderTaskList
 116   CreateDefaultCameraActor();
 117
 118   // Create the list of render-tasks
 119   mRenderTaskList = RenderTaskList::New( *this, *this, false/*not system-level*/ );
 120
 121   // Create the default render-task
 122   Dali::RenderTask defaultRenderTask = mRenderTaskList->CreateTask();
 123 }
 124
 125 void Stage::Uninitialize()
 126 {
 127   // Remove actors added to SystemOverlay
 128   delete mSystemOverlay;
 129   mSystemOverlay = NULL;
 130
 131   if( mDefaultCamera )
 132   {
 133     // its enough to release the handle so the object is released
 134     // don't need to remove it from root actor as root actor will delete the object
 135     mDefaultCamera.Reset();
 136   }
 137
 138   if( mRootLayer )
 139   {
 140     // we are closing down so just delete the root, no point emit disconnect
 141     // signals or send messages to update
 142     mRootLayer.Reset();
 143   }
 144 }
 145
 146 StagePtr Stage::GetCurrent()
 147 {
 148   StagePtr stage( NULL );
 149   // no checking in this version
 150   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 151   if( tls )
 152   {
 153     stage = tls->GetCurrentStage();
 154   }
 155   return stage;
 156 }
 157
 158 bool Stage::IsInstalled()
 159 {
 160   return ThreadLocalStorage::Created();
 161 }
 162
 163 ObjectRegistry& Stage::GetObjectRegistry()
 164 {
 165   return *mObjectRegistry;
 166 }
 167
 168 void Stage::RegisterObject( Dali::BaseObject* object )
 169 {
 170   mObjectRegistry->RegisterObject( object );
 171 }
 172
 173 void Stage::UnregisterObject( Dali::BaseObject* object )
 174 {
 175   mObjectRegistry->UnregisterObject( object );
 176 }
 177
 178 Layer& Stage::GetRootActor()
 179 {
 180   return *mRootLayer;
 181 }
 182
 183 AnimationPlaylist& Stage::GetAnimationPlaylist()
 184 {
 185   return mAnimationPlaylist;
 186 }
 187
 188 PropertyNotificationManager& Stage::GetPropertyNotificationManager()
 189 {
 190   return mPropertyNotificationManager;
 191 }
 192
 193 void Stage::Add( Actor& actor )
 194 {
 195   mRootLayer->Add( actor );
 196 }
 197
 198 void Stage::Remove( Actor& actor )
 199 {
 200   mRootLayer->Remove( actor );
 201 }
 202
 203 void Stage::SurfaceResized( float width, float height )
 204 {
 205   if( ( fabs( width - mSurfaceSize.width ) > Math::MACHINE_EPSILON_1000 ) || ( fabs( height - mSurfaceSize.height ) > Math::MACHINE_EPSILON_1000 ) )
 206   {
 207     mSurfaceSize.width = width;
 208     mSurfaceSize.height = height;
 209
 210     // Internally we want to report the actual size of the stage.
 211     mSize.width = width;
 212     mSize.height = height - mTopMargin;
 213
 214     // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 215     mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
 216
 217     // Adjust the camera height to allow for top-margin
 218     SetDefaultCameraPosition();
 219
 220     mRootLayer->SetSize( mSize.width, mSize.height );
 221
 222     // Repeat for SystemOverlay actors
 223     if( mSystemOverlay )
 224     {
 225       // Note that the SystemOverlay has a separate camera, configured for the full surface-size.
 226       // This will remain unaffected by changes in SetDefaultCameraPosition()
 227       mSystemOverlay->GetImpl()->SetSize( width, height );
 228     }
 229
 230     SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int>( 0, 0, width, height ) );
 231
 232     // if single render task to screen then set its viewport parameters
 233     if( 1 == mRenderTaskList->GetTaskCount() )
 234     {
 235       Dali::RenderTask defaultRenderTask = mRenderTaskList->GetTask( 0u );
 236
 237       if(!defaultRenderTask.GetTargetFrameBuffer())
 238       {
 239         defaultRenderTask.SetViewport( Viewport(0, 0, width, height) );
 240       }
 241     }
 242
 243     if( mRenderToFbo )
 244     {
 245       Dali::FrameBuffer frameBuffer = Dali::FrameBuffer::New( width, height, Dali::FrameBuffer::Attachment::NONE );
 246       Dali::Texture texture = Dali::Texture::New( Dali::TextureType::TEXTURE_2D, Dali::Pixel::RGB888, width, height );
 247       frameBuffer.AttachColorTexture( texture );
 248
 249       Dali::RenderTask defaultRenderTask = mRenderTaskList->GetTask( 0u );
 250       defaultRenderTask.SetFrameBuffer( frameBuffer );
 251     }
 252   }
 253 }
 254
 255 Vector2 Stage::GetSize() const
 256 {
 257   return mSize;
 258 }
 259
 260 void Stage::SetTopMargin( unsigned int margin )
 261 {
 262   if (mTopMargin == margin)
 263   {
 264     return;
 265   }
 266   mTopMargin = margin;
 267
 268   mSize.width = mSurfaceSize.width;
 269   mSize.height = mSurfaceSize.height - mTopMargin;
 270
 271   // Adjust the camera height to allow for top-margin
 272   SetDefaultCameraPosition();
 273
 274   mRootLayer->SetSize( mSize.width, mSize.height );
 275 }
 276
 277 RenderTaskList& Stage::GetRenderTaskList() const
 278 {
 279   return *mRenderTaskList;
 280 }
 281
 282 void Stage::CreateDefaultCameraActor()
 283 {
 284   // The default camera attributes and position is such that
 285   // children of the default layer, can be positioned at (0,0) and
 286   // be at the top-left of the viewport.
 287   mDefaultCamera = CameraActor::New( Size::ZERO );
 288   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 289   Add(*(mDefaultCamera.Get()));
 290 }
 291
 292 void Stage::SetDefaultCameraPosition()
 293 {
 294   mDefaultCamera->SetY( -(static_cast<float>(mTopMargin) * 0.5f) );
 295 }
 296
 297 Actor& Stage::GetDefaultRootActor()
 298 {
 299   return *mRootLayer;
 300 }
 301
 302 CameraActor& Stage::GetDefaultCameraActor()
 303 {
 304   return *mDefaultCamera;
 305 }
 306
 307 unsigned int Stage::GetLayerCount() const
 308 {
 309   return mLayerList->GetLayerCount();
 310 }
 311
 312 Dali::Layer Stage::GetLayer( unsigned int depth ) const
 313 {
 314   return Dali::Layer(mLayerList->GetLayer( depth ));
 315 }
 316
 317 Dali::Layer Stage::GetRootLayer() const
 318 {
 319   return Dali::Layer( mRootLayer.Get() );
 320 }
 321
 322 LayerList& Stage::GetLayerList()
 323 {
 324   return *mLayerList;
 325 }
 326
 327 Integration::SystemOverlay& Stage::GetSystemOverlay()
 328 {
 329   // Lazily create system-level if requested
 330   if( !mSystemOverlay )
 331   {
 332     mSystemOverlay = new Integration::SystemOverlay( SystemOverlay::New( *this ) );
 333     DALI_ASSERT_ALWAYS( NULL != mSystemOverlay && "Failed to create system overlay" );
 334
 335     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 336   }
 337
 338   return *mSystemOverlay;
 339 }
 340
 341 SystemOverlay* Stage::GetSystemOverlayInternal()
 342 {
 343   SystemOverlay* overlay( NULL );
 344
 345   if( mSystemOverlay )
 346   {
 347     overlay = mSystemOverlay->GetImpl();
 348   }
 349
 350   return overlay;
 351 }
 352
 353 void Stage::SetViewMode( ViewMode viewMode )
 354 {
 355   if( mViewMode != viewMode )
 356   {
 357     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "View mode changed from %d to %d\n", mViewMode, viewMode);
 358
 359     if( mViewMode == MONO )
 360     {
 361       mDefaultCamera->SetOrientation( Dali::ANGLE_180, Vector3::YAXIS );
 362       mRenderTaskList->GetTask(0).SetSourceActor( Dali::Actor() );
 363
 364       //Create camera and RenderTask for left eye
 365       mLeftCamera = CameraActor::New( Size::ZERO );
 366       mLeftCamera->SetParentOrigin( ParentOrigin::CENTER );
 367       mDefaultCamera->Add( *mLeftCamera.Get() );
 368       mLeftRenderTask = mRenderTaskList->CreateTask();
 369       mLeftRenderTask.SetCameraActor( Dali::CameraActor( mLeftCamera.Get() ) );
 370       mLeftCamera->SetType( Dali::Camera::FREE_LOOK );
 371
 372       //Create camera and RenderTask for right eye
 373       mRightCamera = CameraActor::New( Size::ZERO );
 374       mRightCamera->SetParentOrigin( ParentOrigin::CENTER );
 375       mDefaultCamera->Add( *mRightCamera.Get() );
 376       mRightRenderTask = mRenderTaskList->CreateTask();
 377       mRightRenderTask.SetClearColor( Vector4( 1.0f,0.0f,0.0f,1.0f));
 378
 379       mRightRenderTask.SetCameraActor( Dali::CameraActor( mRightCamera.Get() ) );
 380       mRightCamera->SetType( Dali::Camera::FREE_LOOK );
 381     }
 382
 383     // save new mode
 384     mViewMode = viewMode;
 385
 386     switch( viewMode )
 387     {
 388       case MONO:
 389       {
 390         // delete extra stereoscopic render tasks and cameras
 391         mRenderTaskList->RemoveTask( mLeftRenderTask );
 392         mDefaultCamera->Remove( *mLeftCamera.Get() );
 393         mLeftRenderTask.Reset();
 394         mLeftCamera.Reset();
 395         mRenderTaskList->RemoveTask( mRightRenderTask );
 396         mDefaultCamera->Remove( *mRightCamera.Get() );
 397         mRightRenderTask.Reset();
 398         mRightCamera.Reset();
 399         mDefaultCamera->SetOrientation( Dali::ANGLE_0, Vector3::YAXIS );
 400         mDefaultCamera->SetType( Dali::Camera::LOOK_AT_TARGET );
 401         mRenderTaskList->GetTask(0).SetSourceActor( Dali::Layer(mRootLayer.Get()) );
 402
 403         break;
 404       }
 405       case STEREO_HORIZONTAL:
 406       {
 407         //Stereo mode with horizontal split is for landscape mode. That's the reason for the cameras being rotated
 408         //Top camera renders the scene as seen from the right eye and bottom camera as seen from left.
 409
 410         //Calculate separation in pixels along vertical axis ( mStereoBase is defined in millimetres )
 411         const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().y ) * 0.5f );
 412
 413         //Calculate aspect ratio
 414         float aspect = mSize.width / (mSize.height * 0.5f);
 415
 416         mLeftCamera->SetPerspectiveProjection( mSize, Vector2( 0.0f,stereoBase) );
 417         mLeftCamera->SetAspectRatio( aspect );
 418
 419         mLeftCamera->SetOrientation( -Dali::ANGLE_90, Vector3::ZAXIS );
 420         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 421         mLeftRenderTask.SetViewport( Viewport(0, mSize.height * 0.5f, mSize.width, mSize.height * 0.5f) );
 422
 423         mRightCamera->SetPerspectiveProjection( mSize, Vector2( 0.0,  -stereoBase) );
 424         mRightCamera->SetAspectRatio( aspect );
 425         mRightCamera->SetOrientation( -Dali::ANGLE_90, Vector3::ZAXIS );
 426         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 427         mRightRenderTask.SetViewport( Viewport(0, 0, mSize.width, mSize.height * 0.5f ) );
 428
 429         break;
 430       }
 431       case STEREO_VERTICAL:
 432       {
 433         //Calculate separation in pixels along horizontal axis
 434         const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().x ) * 0.5f );
 435
 436         //Recalculate fov based on viewport size
 437         const float fov = 2.0f * std::atan(  mSize.y / (2.0f * std::max( mSize.x*0.5f, mSize.y )) );
 438
 439         mLeftCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(stereoBase,0.0f) );
 440         mLeftCamera->SetFieldOfView( fov );
 441         mLeftCamera->SetOrientation( Dali::ANGLE_0, Vector3::ZAXIS );
 442         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 443         mLeftRenderTask.SetViewport( Viewport(0, 0, mSize.width * 0.5f, mSize.height ) );
 444
 445         mRightCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(-stereoBase,0.0f) );
 446         mRightCamera->SetFieldOfView( fov );
 447         mRightCamera->SetOrientation( Dali::ANGLE_0, Vector3::ZAXIS );
 448         mRightCamera->SetPosition( Vector3( -stereoBase, 0.0f, 0.0f ) );
 449         mRightRenderTask.SetViewport( Viewport(mSize.width * 0.5f, 0, mSize.width * 0.5f, mSize.height ) );
 450
 451         break;
 452       }
 453       case STEREO_INTERLACED:
 454       {
 455         break;
 456       }
 457     }
 458   }
 459 }
 460
 461 ViewMode Stage::GetViewMode() const
 462 {
 463   return mViewMode;
 464 }
 465
 466 void Stage::SetStereoBase( float stereoBase )
 467 {
 468   if( ! Equals( mStereoBase, stereoBase ) )
 469   {
 470     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)\n", mStereoBase, stereoBase );
 471     mStereoBase = stereoBase;
 472
 473     switch( mViewMode  )
 474     {
 475       case STEREO_HORIZONTAL:
 476       {
 477         stereoBase = mStereoBase / 25.4f * GetDpi().y * 0.5f;
 478         float aspect = mSize.width / (mSize.height * 0.5f);
 479
 480         mLeftCamera->SetPerspectiveProjection( mSize, Vector2( 0.0, stereoBase) );
 481         mLeftCamera->SetAspectRatio( aspect );
 482         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 483
 484         mRightCamera->SetPerspectiveProjection( mSize, Vector2( 0.0, -stereoBase) );
 485         mRightCamera->SetAspectRatio( aspect );
 486         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 487
 488         break;
 489       }
 490       case STEREO_VERTICAL:
 491       {
 492         stereoBase = mStereoBase / 25.4f * GetDpi().x * 0.5f;
 493         const float fov = 2.0f * std::atan(  mSize.y / (2.0f * std::max( mSize.x*0.5f, mSize.y )) );
 494
 495         mLeftCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(stereoBase,0.0f) );
 496         mLeftCamera->SetFieldOfView( fov );
 497         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 498
 499         mRightCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(-stereoBase,0.0f) );
 500         mRightCamera->SetFieldOfView( fov );
 501         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 502
 503         break;
 504       }
 505       default:
 506         break;
 507     }
 508   }
 509 }
 510
 511 float Stage::GetStereoBase() const
 512 {
 513   return mStereoBase;
 514 }
 515
 516 void Stage::SetBackgroundColor(Vector4 color)
 517 {
 518   // Cache for public GetBackgroundColor()
 519   mBackgroundColor = color;
 520
 521   // Send message to change color in next frame
 522   SetBackgroundColorMessage( mUpdateManager, color );
 523 }
 524
 525 Vector4 Stage::GetBackgroundColor() const
 526 {
 527   return mBackgroundColor;
 528 }
 529
 530 Vector2 Stage::GetDpi() const
 531 {
 532   return mDpi;
 533 }
 534
 535 void Stage::SetDpi(Vector2 dpi)
 536 {
 537   mDpi = dpi;
 538 }
 539
 540 void Stage::KeepRendering( float durationSeconds )
 541 {
 542   // Send message to keep rendering
 543   KeepRenderingMessage( mUpdateManager, durationSeconds );
 544 }
 545
 546 bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 547 {
 548   bool connected( true );
 549   Stage* stage = static_cast< Stage* >(object); // TypeRegistry guarantees that this is the correct type.
 550
 551   if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
 552   {
 553     stage->KeyEventSignal().Connect( tracker, functor );
 554   }
 555   else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT_GENERATED ) )
 556   {
 557     stage->KeyEventGeneratedSignal().Connect( tracker, functor );
 558   }
 559   else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) )
 560   {
 561     stage->EventProcessingFinishedSignal().Connect( tracker, functor );
 562   }
 563   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) )
 564   {
 565     stage->TouchedSignal().Connect( tracker, functor );
 566   }
 567   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCH ) )
 568   {
 569     stage->TouchSignal().Connect( tracker, functor );
 570   }
 571   else if( 0 == strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) )
 572   {
 573     stage->WheelEventSignal().Connect( tracker, functor );
 574   }
 575   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
 576   {
 577     stage->ContextLostSignal().Connect( tracker, functor );
 578   }
 579   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_REGAINED ) )
 580   {
 581     stage->ContextRegainedSignal().Connect( tracker, functor );
 582   }
 583   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCENE_CREATED ) )
 584   {
 585     stage->SceneCreatedSignal().Connect( tracker, functor );
 586   }
 587   else
 588   {
 589     // signalName does not match any signal
 590     connected = false;
 591   }
 592
 593   return connected;
 594 }
 595
 596 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 597 {
 598   // Emit the key event signal when no actor in the stage has gained the key input focus
 599
 600   mKeyEventSignal.Emit( event );
 601 }
 602
 603 bool Stage::EmitKeyEventGeneratedSignal(const KeyEvent& event)
 604 {
 605   // Emit the KeyEventGenerated signal when KeyEvent is generated
 606
 607   return mKeyEventGeneratedSignal.Emit( event );
 608 }
 609
 610 void Stage::EmitEventProcessingFinishedSignal()
 611 {
 612    mEventProcessingFinishedSignal.Emit();
 613 }
 614
 615 void Stage::EmitTouchedSignal( const TouchEvent& touchEvent, const Dali::TouchData& touch )
 616 {
 617   mTouchedSignal.Emit( touchEvent );
 618   mTouchSignal.Emit( touch );
 619 }
 620
 621 void Stage::EmitWheelEventSignal(const WheelEvent& event)
 622 {
 623   // Emit the wheel event signal when no actor in the stage has gained the wheel input focus
 624
 625   mWheelEventSignal.Emit( event );
 626 }
 627
 628 void Stage::EmitSceneCreatedSignal()
 629 {
 630   mSceneCreatedSignal.Emit();
 631 }
 632
 633 Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal()
 634 {
 635   return mKeyEventSignal;
 636 }
 637
 638 Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal()
 639 {
 640   return mKeyEventGeneratedSignal;
 641 }
 642
 643 Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
 644 {
 645   return mEventProcessingFinishedSignal;
 646 }
 647
 648 Dali::Stage::TouchedSignalType& Stage::TouchedSignal()
 649 {
 650   DALI_LOG_WARNING( "Deprecated. Use TouchSignal() instead.\n" );
 651   return mTouchedSignal;
 652 }
 653
 654 Dali::Stage::TouchSignalType& Stage::TouchSignal()
 655 {
 656   return mTouchSignal;
 657 }
 658
 659 Dali::Stage::WheelEventSignalType& Stage::WheelEventSignal()
 660 {
 661   return mWheelEventSignal;
 662 }
 663
 664 Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
 665 {
 666   return mContextLostSignal;
 667 }
 668
 669 Dali::Stage::ContextStatusSignal& Stage::ContextRegainedSignal()
 670 {
 671   return mContextRegainedSignal;
 672 }
 673
 674 Dali::Stage::SceneCreatedSignalType& Stage::SceneCreatedSignal()
 675 {
 676   return mSceneCreatedSignal;
 677 }
 678
 679 void Stage::NotifyContextLost()
 680 {
 681   mContextLostSignal.Emit();
 682 }
 683
 684 void Stage::NotifyContextRegained()
 685 {
 686   mContextRegainedSignal.Emit();
 687 }
 688
 689
 690 void Stage::RequestRebuildDepthTree()
 691 {
 692   DALI_LOG_INFO(gLogFilter, Debug::General, "RequestRebuildDepthTree()\n");
 693   mDepthTreeDirty = true;
 694 }
 695
 696 void Stage::RebuildDepthTree()
 697 {
 698   // If the depth tree needs rebuilding, do it in this frame only.
 699   if( mDepthTreeDirty )
 700   {
 701     DALI_LOG_INFO(gLogFilter, Debug::Concise, "RebuildDepthTree() dirty:T\n");
 702
 703     ActorPtr actor( mRootLayer.Get() );
 704     actor->RebuildDepthTree();
 705     mDepthTreeDirty = false;
 706   }
 707 }
 708
 709
 710 Stage::Stage( AnimationPlaylist& playlist,
 711               PropertyNotificationManager& propertyNotificationManager,
 712               SceneGraph::UpdateManager& updateManager,
 713               NotificationManager& notificationManager,
 714               Integration::RenderController& renderController )
 715 : mAnimationPlaylist( playlist ),
 716   mPropertyNotificationManager( propertyNotificationManager ),
 717   mUpdateManager( updateManager ),
 718   mNotificationManager( notificationManager ),
 719   mRenderController( renderController ),
 720   mSize( Vector2::ZERO ),
 721   mSurfaceSize( Vector2::ZERO ),
 722   mBackgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
 723   mViewMode( MONO ),
 724   mStereoBase( DEFAULT_STEREO_BASE ),
 725   mTopMargin( 0 ),
 726   mDpi( Vector2::ZERO ),
 727   mRightRenderTask(),
 728   mLeftRenderTask(),
 729   mSystemOverlay( NULL ),
 730   mKeyEventSignal(),
 731   mKeyEventGeneratedSignal(),
 732   mEventProcessingFinishedSignal(),
 733   mTouchedSignal(),
 734   mTouchSignal(),
 735   mWheelEventSignal(),
 736   mContextLostSignal(),
 737   mContextRegainedSignal(),
 738   mSceneCreatedSignal(),
 739   mDepthTreeDirty( false ),
 740   mForceNextUpdate( false ),
 741   mRenderToFbo( false )
 742 {
 743 }
 744
 745 SceneGraph::UpdateManager& Stage::GetUpdateManager()
 746 {
 747   return mUpdateManager;
 748 }
 749
 750 Integration::RenderController& Stage::GetRenderController()
 751 {
 752   return mRenderController;
 753 }
 754
 755 unsigned int* Stage::ReserveMessageSlot( std::size_t size, bool updateScene )
 756 {
 757   return mUpdateManager.ReserveMessageSlot( size, updateScene );
 758 }
 759
 760 BufferIndex Stage::GetEventBufferIndex() const
 761 {
 762   return mUpdateManager.GetEventBufferIndex();
 763 }
 764
 765 void Stage::ForceNextUpdate()
 766 {
 767   mForceNextUpdate = true;
 768 }
 769
 770 bool Stage::IsNextUpdateForced()
 771 {
 772   bool nextUpdateForced = mForceNextUpdate;
 773   mForceNextUpdate = false;
 774   return nextUpdateForced;
 775 }
 776
 777 Stage::~Stage()
 778 {
 779   delete mSystemOverlay;
 780
 781   mObjectRegistry.Reset();
 782 }
 783
 784 } // namespace Internal
 785
 786 } // namespace Dali