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

   1 /*
   2  * Copyright (c) 2016 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
  43 using Dali::Internal::SceneGraph::Node;
  44
  45 namespace Dali
  46 {
  47
  48 namespace Internal
  49 {
  50
  51 namespace
  52 {
  53
  54 const float DEFAULT_STEREO_BASE( 65.0f );
  55
  56 // Signals
  57
  58 const char* const SIGNAL_KEY_EVENT =                 "keyEvent";
  59 const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished";
  60 const char* const SIGNAL_TOUCHED =                   "touched";
  61 const char* const SIGNAL_WHEEL_EVENT =               "wheelEvent";
  62 const char* const SIGNAL_CONTEXT_LOST =              "contextLost";
  63 const char* const SIGNAL_CONTEXT_REGAINED =          "contextRegained";
  64 const char* const SIGNAL_SCENE_CREATED =             "sceneCreated";
  65
  66 TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
  67
  68 SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT,                 &Stage::DoConnectSignal );
  69 SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
  70 SignalConnectorType signalConnector3( mType, SIGNAL_TOUCHED,                   &Stage::DoConnectSignal );
  71 SignalConnectorType signalConnector4( mType, SIGNAL_WHEEL_EVENT,               &Stage::DoConnectSignal );
  72 SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_LOST,              &Stage::DoConnectSignal );
  73 SignalConnectorType signalConnector6( mType, SIGNAL_CONTEXT_REGAINED,          &Stage::DoConnectSignal );
  74 SignalConnectorType signalConnector7( mType, SIGNAL_SCENE_CREATED,             &Stage::DoConnectSignal );
  75
  76 } // unnamed namespace
  77
  78 StagePtr Stage::New( AnimationPlaylist& playlist,
  79                      PropertyNotificationManager& propertyNotificationManager,
  80                      SceneGraph::UpdateManager& updateManager,
  81                      NotificationManager& notificationManager )
  82 {
  83   return StagePtr( new Stage( playlist, propertyNotificationManager, updateManager, notificationManager ) );
  84 }
  85
  86 void Stage::Initialize()
  87 {
  88   mObjectRegistry = ObjectRegistry::New();
  89
  90   // Create the ordered list of layers
  91   mLayerList = LayerList::New( mUpdateManager, false/*not system-level*/ );
  92
  93   // The stage owns the default layer
  94   mRootLayer = Layer::NewRoot( *mLayerList, mUpdateManager, false/*not system-level*/ );
  95   mRootLayer->SetName("RootLayer");
  96   // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
  97   // This stops actors parented to the stage having their relayout requests propagating
  98   // up to the root layer, and down through other children unnecessarily.
  99   mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 100
 101   // Create the default camera actor first; this is needed by the RenderTaskList
 102   CreateDefaultCameraActor();
 103
 104   // Create the list of render-tasks
 105   mRenderTaskList = RenderTaskList::New( *this, *this, false/*not system-level*/ );
 106
 107   // Create the default render-task
 108   Dali::RenderTask defaultRenderTask = mRenderTaskList->CreateTask();
 109 }
 110
 111 void Stage::Uninitialize()
 112 {
 113   // Remove actors added to SystemOverlay
 114   delete mSystemOverlay;
 115   mSystemOverlay = NULL;
 116
 117   if( mDefaultCamera )
 118   {
 119     // its enough to release the handle so the object is released
 120     // don't need to remove it from root actor as root actor will delete the object
 121     mDefaultCamera.Reset();
 122   }
 123
 124   if( mRootLayer )
 125   {
 126     // we are closing down so just delete the root, no point emit disconnect
 127     // signals or send messages to update
 128     mRootLayer.Reset();
 129   }
 130 }
 131
 132 StagePtr Stage::GetCurrent()
 133 {
 134   StagePtr stage( NULL );
 135   // no checking in this version
 136   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 137   if( tls )
 138   {
 139     stage = tls->GetCurrentStage();
 140   }
 141   return stage;
 142 }
 143
 144 bool Stage::IsInstalled()
 145 {
 146   return ThreadLocalStorage::Created();
 147 }
 148
 149 ObjectRegistry& Stage::GetObjectRegistry()
 150 {
 151   return *mObjectRegistry;
 152 }
 153
 154 void Stage::RegisterObject( Dali::BaseObject* object )
 155 {
 156   mObjectRegistry->RegisterObject( object );
 157 }
 158
 159 void Stage::UnregisterObject( Dali::BaseObject* object )
 160 {
 161   mObjectRegistry->UnregisterObject( object );
 162 }
 163
 164 Layer& Stage::GetRootActor()
 165 {
 166   return *mRootLayer;
 167 }
 168
 169 AnimationPlaylist& Stage::GetAnimationPlaylist()
 170 {
 171   return mAnimationPlaylist;
 172 }
 173
 174 PropertyNotificationManager& Stage::GetPropertyNotificationManager()
 175 {
 176   return mPropertyNotificationManager;
 177 }
 178
 179 void Stage::Add( Actor& actor )
 180 {
 181   mRootLayer->Add( actor );
 182 }
 183
 184 void Stage::Remove( Actor& actor )
 185 {
 186   mRootLayer->Remove( actor );
 187 }
 188
 189 void Stage::SetSize(float width, float height)
 190 {
 191   // Internally we want to report the actual size of the stage.
 192   mSize.width  = width;
 193   mSize.height = height;
 194
 195   // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 196   mDefaultCamera->SetPerspectiveProjection( mSize );
 197
 198   // The depth of the stage gets set to the maximun of these values
 199   mRootLayer->SetSize( mSize );
 200
 201   // Repeat for SystemOverlay actors
 202   if( mSystemOverlay )
 203   {
 204     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 205   }
 206
 207   SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int>( 0, 0, width, height ) );
 208
 209   // if single render task to screen then set its viewport parameters
 210   if( 1 == mRenderTaskList->GetTaskCount() )
 211   {
 212     Dali::RenderTask mDefaultRenderTask = mRenderTaskList->GetTask(0);
 213
 214     if(!mDefaultRenderTask.GetTargetFrameBuffer())
 215     {
 216       mDefaultRenderTask.SetViewport( Viewport(0, 0, width, height) );
 217     }
 218   }
 219
 220 }
 221
 222 Vector2 Stage::GetSize() const
 223 {
 224   return mSize;
 225 }
 226
 227 RenderTaskList& Stage::GetRenderTaskList() const
 228 {
 229   return *mRenderTaskList;
 230 }
 231
 232 void Stage::CreateDefaultCameraActor()
 233 {
 234   // The default camera attributes and position is such that
 235   // children of the default layer, can be positioned at (0,0) and
 236   // be at the top-left of the viewport.
 237   mDefaultCamera = CameraActor::New( Size::ZERO );
 238   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 239   Add(*(mDefaultCamera.Get()));
 240 }
 241
 242 Actor& Stage::GetDefaultRootActor()
 243 {
 244   return *mRootLayer;
 245 }
 246
 247 CameraActor& Stage::GetDefaultCameraActor()
 248 {
 249   return *mDefaultCamera;
 250 }
 251
 252 unsigned int Stage::GetLayerCount() const
 253 {
 254   return mLayerList->GetLayerCount();
 255 }
 256
 257 Dali::Layer Stage::GetLayer( unsigned int depth ) const
 258 {
 259   return Dali::Layer(mLayerList->GetLayer( depth ));
 260 }
 261
 262 Dali::Layer Stage::GetRootLayer() const
 263 {
 264   return Dali::Layer( mRootLayer.Get() );
 265 }
 266
 267 LayerList& Stage::GetLayerList()
 268 {
 269   return *mLayerList;
 270 }
 271
 272 Integration::SystemOverlay& Stage::GetSystemOverlay()
 273 {
 274   // Lazily create system-level if requested
 275   if( !mSystemOverlay )
 276   {
 277     mSystemOverlay = new Integration::SystemOverlay( SystemOverlay::New( *this ) );
 278     DALI_ASSERT_ALWAYS( NULL != mSystemOverlay && "Failed to create system overlay" );
 279
 280     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 281   }
 282
 283   return *mSystemOverlay;
 284 }
 285
 286 SystemOverlay* Stage::GetSystemOverlayInternal()
 287 {
 288   SystemOverlay* overlay( NULL );
 289
 290   if( mSystemOverlay )
 291   {
 292     overlay = mSystemOverlay->GetImpl();
 293   }
 294
 295   return overlay;
 296 }
 297
 298 void Stage::SetViewMode( ViewMode viewMode )
 299 {
 300   if( mViewMode != viewMode )
 301   {
 302     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "View mode changed from %d to %d\n", mViewMode, viewMode);
 303
 304     if( mViewMode == MONO )
 305     {
 306       mDefaultCamera->SetOrientation( Dali::ANGLE_180, Vector3::YAXIS );
 307       mRenderTaskList->GetTask(0).SetSourceActor( Dali::Actor() );
 308
 309       //Create camera and RenderTask for left eye
 310       mLeftCamera = CameraActor::New( Size::ZERO );
 311       mLeftCamera->SetParentOrigin( ParentOrigin::CENTER );
 312       mDefaultCamera->Add( *mLeftCamera.Get() );
 313       mLeftRenderTask = mRenderTaskList->CreateTask();
 314       mLeftRenderTask.SetCameraActor( Dali::CameraActor( mLeftCamera.Get() ) );
 315       mLeftCamera->SetType( Dali::Camera::FREE_LOOK );
 316
 317       //Create camera and RenderTask for right eye
 318       mRightCamera = CameraActor::New( Size::ZERO );
 319       mRightCamera->SetParentOrigin( ParentOrigin::CENTER );
 320       mDefaultCamera->Add( *mRightCamera.Get() );
 321       mRightRenderTask = mRenderTaskList->CreateTask();
 322       mRightRenderTask.SetClearColor( Vector4( 1.0f,0.0f,0.0f,1.0f));
 323
 324       mRightRenderTask.SetCameraActor( Dali::CameraActor( mRightCamera.Get() ) );
 325       mRightCamera->SetType( Dali::Camera::FREE_LOOK );
 326     }
 327
 328     // save new mode
 329     mViewMode = viewMode;
 330
 331     switch( viewMode )
 332     {
 333       case MONO:
 334       {
 335         // delete extra stereoscopic render tasks and cameras
 336         mRenderTaskList->RemoveTask( mLeftRenderTask );
 337         mDefaultCamera->Remove( *mLeftCamera.Get() );
 338         mLeftRenderTask.Reset();
 339         mLeftCamera.Reset();
 340         mRenderTaskList->RemoveTask( mRightRenderTask );
 341         mDefaultCamera->Remove( *mRightCamera.Get() );
 342         mRightRenderTask.Reset();
 343         mRightCamera.Reset();
 344         mDefaultCamera->SetOrientation( Dali::ANGLE_0, Vector3::YAXIS );
 345         mDefaultCamera->SetType( Dali::Camera::LOOK_AT_TARGET );
 346         mRenderTaskList->GetTask(0).SetSourceActor( Dali::Layer(mRootLayer.Get()) );
 347
 348         break;
 349       }
 350       case STEREO_HORIZONTAL:
 351       {
 352         //Stereo mode with horizontal split is for landscape mode. That's the reason for the cameras being rotated
 353         //Top camera renders the scene as seen from the right eye and bottom camera as seen from left.
 354
 355         //Calculate separation in pixels along vertical axis ( mStereoBase is defined in millimetres )
 356         const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().y ) * 0.5f );
 357
 358         //Calculate aspect ratio
 359         float aspect = mSize.width / (mSize.height * 0.5f);
 360
 361         mLeftCamera->SetPerspectiveProjection( mSize, Vector2( 0.0f,stereoBase) );
 362         mLeftCamera->SetAspectRatio( aspect );
 363
 364         mLeftCamera->SetOrientation( -Dali::ANGLE_90, Vector3::ZAXIS );
 365         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 366         mLeftRenderTask.SetViewport( Viewport(0, mSize.height * 0.5f, mSize.width, mSize.height * 0.5f) );
 367
 368         mRightCamera->SetPerspectiveProjection( mSize, Vector2( 0.0,  -stereoBase) );
 369         mRightCamera->SetAspectRatio( aspect );
 370         mRightCamera->SetOrientation( -Dali::ANGLE_90, Vector3::ZAXIS );
 371         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 372         mRightRenderTask.SetViewport( Viewport(0, 0, mSize.width, mSize.height * 0.5f ) );
 373
 374         break;
 375       }
 376       case STEREO_VERTICAL:
 377       {
 378         //Calculate separation in pixels along horizontal axis
 379         const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().x ) * 0.5f );
 380
 381         //Recalculate fov based on viewport size
 382         const float fov = 2.0f * std::atan(  mSize.y / (2.0f * std::max( mSize.x*0.5f, mSize.y )) );
 383
 384         mLeftCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(stereoBase,0.0f) );
 385         mLeftCamera->SetFieldOfView( fov );
 386         mLeftCamera->SetOrientation( Dali::ANGLE_0, Vector3::ZAXIS );
 387         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 388         mLeftRenderTask.SetViewport( Viewport(0, 0, mSize.width * 0.5f, mSize.height ) );
 389
 390         mRightCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(-stereoBase,0.0f) );
 391         mRightCamera->SetFieldOfView( fov );
 392         mRightCamera->SetOrientation( Dali::ANGLE_0, Vector3::ZAXIS );
 393         mRightCamera->SetPosition( Vector3( -stereoBase, 0.0f, 0.0f ) );
 394         mRightRenderTask.SetViewport( Viewport(mSize.width * 0.5f, 0, mSize.width * 0.5f, mSize.height ) );
 395
 396         break;
 397       }
 398       case STEREO_INTERLACED:
 399       {
 400         break;
 401       }
 402     }
 403   }
 404 }
 405
 406 ViewMode Stage::GetViewMode() const
 407 {
 408   return mViewMode;
 409 }
 410
 411 void Stage::SetStereoBase( float stereoBase )
 412 {
 413   if( ! Equals( mStereoBase, stereoBase ) )
 414   {
 415     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)\n", mStereoBase, stereoBase );
 416     mStereoBase = stereoBase;
 417
 418     switch( mViewMode  )
 419     {
 420       case STEREO_HORIZONTAL:
 421       {
 422         stereoBase = mStereoBase / 25.4f * GetDpi().y * 0.5f;
 423         float aspect = mSize.width / (mSize.height * 0.5f);
 424
 425         mLeftCamera->SetPerspectiveProjection( mSize, Vector2( 0.0, stereoBase) );
 426         mLeftCamera->SetAspectRatio( aspect );
 427         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 428
 429         mRightCamera->SetPerspectiveProjection( mSize, Vector2( 0.0, -stereoBase) );
 430         mRightCamera->SetAspectRatio( aspect );
 431         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 432
 433         break;
 434       }
 435       case STEREO_VERTICAL:
 436       {
 437         stereoBase = mStereoBase / 25.4f * GetDpi().x * 0.5f;
 438         const float fov = 2.0f * std::atan(  mSize.y / (2.0f * std::max( mSize.x*0.5f, mSize.y )) );
 439
 440         mLeftCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(stereoBase,0.0f) );
 441         mLeftCamera->SetFieldOfView( fov );
 442         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 443
 444         mRightCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(-stereoBase,0.0f) );
 445         mRightCamera->SetFieldOfView( fov );
 446         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 447
 448         break;
 449       }
 450       default:
 451         break;
 452     }
 453   }
 454 }
 455
 456 float Stage::GetStereoBase() const
 457 {
 458   return mStereoBase;
 459 }
 460
 461 void Stage::SetBackgroundColor(Vector4 color)
 462 {
 463   // Cache for public GetBackgroundColor()
 464   mBackgroundColor = color;
 465
 466   // Send message to change color in next frame
 467   SetBackgroundColorMessage( mUpdateManager, color );
 468 }
 469
 470 Vector4 Stage::GetBackgroundColor() const
 471 {
 472   return mBackgroundColor;
 473 }
 474
 475 Vector2 Stage::GetDpi() const
 476 {
 477   return mDpi;
 478 }
 479
 480 void Stage::SetDpi(Vector2 dpi)
 481 {
 482   mDpi = dpi;
 483 }
 484
 485 void Stage::KeepRendering( float durationSeconds )
 486 {
 487   // Send message to keep rendering
 488   KeepRenderingMessage( mUpdateManager, durationSeconds );
 489 }
 490
 491 bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 492 {
 493   bool connected( true );
 494   Stage* stage = dynamic_cast<Stage*>(object);
 495
 496   if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
 497   {
 498     stage->KeyEventSignal().Connect( tracker, functor );
 499   }
 500   else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) )
 501   {
 502     stage->EventProcessingFinishedSignal().Connect( tracker, functor );
 503   }
 504   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) )
 505   {
 506     stage->TouchedSignal().Connect( tracker, functor );
 507   }
 508   else if( 0 == strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) )
 509   {
 510     stage->WheelEventSignal().Connect( tracker, functor );
 511   }
 512   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
 513   {
 514     stage->ContextLostSignal().Connect( tracker, functor );
 515   }
 516   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_REGAINED ) )
 517   {
 518     stage->ContextRegainedSignal().Connect( tracker, functor );
 519   }
 520   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCENE_CREATED ) )
 521   {
 522     stage->SceneCreatedSignal().Connect( tracker, functor );
 523   }
 524   else
 525   {
 526     // signalName does not match any signal
 527     connected = false;
 528   }
 529
 530   return connected;
 531 }
 532
 533 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 534 {
 535   // Emit the key event signal when no actor in the stage has gained the key input focus
 536
 537   mKeyEventSignal.Emit( event );
 538 }
 539
 540 void Stage::EmitEventProcessingFinishedSignal()
 541 {
 542    mEventProcessingFinishedSignal.Emit();
 543 }
 544
 545 void Stage::EmitTouchedSignal( const TouchEvent& touchEvent, const Dali::TouchData& touch )
 546 {
 547   mTouchedSignal.Emit( touchEvent );
 548   mTouchSignal.Emit( touch );
 549 }
 550
 551 void Stage::EmitWheelEventSignal(const WheelEvent& event)
 552 {
 553   // Emit the wheel event signal when no actor in the stage has gained the wheel input focus
 554
 555   mWheelEventSignal.Emit( event );
 556 }
 557
 558 void Stage::EmitSceneCreatedSignal()
 559 {
 560   mSceneCreatedSignal.Emit();
 561 }
 562
 563 Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal()
 564 {
 565   return mKeyEventSignal;
 566 }
 567
 568 Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
 569 {
 570   return mEventProcessingFinishedSignal;
 571 }
 572
 573 Dali::Stage::TouchedSignalType& Stage::TouchedSignal()
 574 {
 575   DALI_LOG_WARNING( "Deprecated. Use TouchSignal() instead.\n" );
 576   return mTouchedSignal;
 577 }
 578
 579 Dali::Stage::TouchSignalType& Stage::TouchSignal()
 580 {
 581   return mTouchSignal;
 582 }
 583
 584 Dali::Stage::WheelEventSignalType& Stage::WheelEventSignal()
 585 {
 586   return mWheelEventSignal;
 587 }
 588
 589 Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
 590 {
 591   return mContextLostSignal;
 592 }
 593
 594 Dali::Stage::ContextStatusSignal& Stage::ContextRegainedSignal()
 595 {
 596   return mContextRegainedSignal;
 597 }
 598
 599 Dali::Stage::SceneCreatedSignalType& Stage::SceneCreatedSignal()
 600 {
 601   return mSceneCreatedSignal;
 602 }
 603
 604 void Stage::NotifyContextLost()
 605 {
 606   mContextLostSignal.Emit();
 607 }
 608
 609 void Stage::NotifyContextRegained()
 610 {
 611   mContextRegainedSignal.Emit();
 612 }
 613
 614 Stage::Stage( AnimationPlaylist& playlist,
 615               PropertyNotificationManager& propertyNotificationManager,
 616               SceneGraph::UpdateManager& updateManager,
 617               NotificationManager& notificationManager )
 618 : mAnimationPlaylist( playlist ),
 619   mPropertyNotificationManager(propertyNotificationManager),
 620   mUpdateManager(updateManager),
 621   mNotificationManager(notificationManager),
 622   mSize(Vector2::ZERO),
 623   mBackgroundColor(Dali::Stage::DEFAULT_BACKGROUND_COLOR),
 624   mViewMode( MONO ),
 625   mStereoBase( DEFAULT_STEREO_BASE ),
 626   mSystemOverlay(NULL)
 627 {
 628 }
 629
 630 SceneGraph::UpdateManager& Stage::GetUpdateManager()
 631 {
 632   return mUpdateManager;
 633 }
 634
 635 unsigned int* Stage::ReserveMessageSlot( std::size_t size, bool updateScene )
 636 {
 637   return mUpdateManager.ReserveMessageSlot( size, updateScene );
 638 }
 639
 640 BufferIndex Stage::GetEventBufferIndex() const
 641 {
 642   return mUpdateManager.GetEventBufferIndex();
 643 }
 644
 645 Stage::~Stage()
 646 {
 647   delete mSystemOverlay;
 648
 649   mObjectRegistry.Reset();
 650 }
 651
 652 } // namespace Internal
 653
 654 } // namespace Dali