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

   1 /*
   2  * Copyright (c) 2018 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/event/update/frame-callback-interface-impl.h>
  36 #include <dali/internal/update/nodes/node.h>
  37 #include <dali/internal/update/manager/scene-graph-frame-callback.h>
  38 #include <dali/internal/event/common/object-registry-impl.h>
  39 #include <dali/integration-api/platform-abstraction.h>
  40 #include <dali/public-api/common/constants.h>
  41 #include <dali/public-api/events/touch-data.h>
  42 #include <dali/public-api/object/type-registry.h>
  43 #include <dali/public-api/render-tasks/render-task-list.h>
  44 #include <dali/public-api/rendering/frame-buffer.h>
  45
  46 using Dali::Internal::SceneGraph::Node;
  47
  48 namespace
  49 {
  50 #if defined(DEBUG_ENABLED)
  51 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_DEPTH_TIMER" );
  52 #endif
  53 }
  54
  55 namespace Dali
  56 {
  57
  58 namespace Internal
  59 {
  60
  61 namespace
  62 {
  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 );
 106
 107   // The stage owns the default layer
 108   mRootLayer = Layer::NewRoot( *mLayerList, mUpdateManager );
 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();
 120
 121   // Create the default render-task (don't need the returned handle)
 122   mRenderTaskList->CreateTask( mRootLayer.Get(), mDefaultCamera.Get() );
 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   if( mRenderTaskList )
 146   {
 147     mRenderTaskList.Reset();
 148   }
 149 }
 150
 151 StagePtr Stage::GetCurrent()
 152 {
 153   StagePtr stage( NULL );
 154   // no checking in this version
 155   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 156   if( tls )
 157   {
 158     stage = tls->GetCurrentStage();
 159   }
 160   return stage;
 161 }
 162
 163 bool Stage::IsInstalled()
 164 {
 165   return ThreadLocalStorage::Created();
 166 }
 167
 168 ObjectRegistry& Stage::GetObjectRegistry()
 169 {
 170   return *mObjectRegistry;
 171 }
 172
 173 void Stage::RegisterObject( Dali::BaseObject* object )
 174 {
 175   mObjectRegistry->RegisterObject( object );
 176 }
 177
 178 void Stage::UnregisterObject( Dali::BaseObject* object )
 179 {
 180   mObjectRegistry->UnregisterObject( object );
 181 }
 182
 183 Layer& Stage::GetRootActor()
 184 {
 185   return *mRootLayer;
 186 }
 187
 188 AnimationPlaylist& Stage::GetAnimationPlaylist()
 189 {
 190   return mAnimationPlaylist;
 191 }
 192
 193 PropertyNotificationManager& Stage::GetPropertyNotificationManager()
 194 {
 195   return mPropertyNotificationManager;
 196 }
 197
 198 void Stage::Add( Actor& actor )
 199 {
 200   mRootLayer->Add( actor );
 201 }
 202
 203 void Stage::Remove( Actor& actor )
 204 {
 205   mRootLayer->Remove( actor );
 206 }
 207
 208 void Stage::SurfaceResized( float width, float height )
 209 {
 210   if( ( fabsf( width - mSurfaceSize.width ) > Math::MACHINE_EPSILON_1000 ) || ( fabsf( height - mSurfaceSize.height ) > Math::MACHINE_EPSILON_1000 ) )
 211   {
 212     mSurfaceSize.width = width;
 213     mSurfaceSize.height = height;
 214
 215     // Internally we want to report the actual size of the stage.
 216     mSize.width = width;
 217     mSize.height = height - static_cast<float>( mTopMargin );
 218
 219     // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 220     mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
 221
 222     // Adjust the camera height to allow for top-margin
 223     SetDefaultCameraPosition();
 224
 225     mRootLayer->SetSize( mSize.width, mSize.height );
 226
 227     // Repeat for SystemOverlay actors
 228     if( mSystemOverlay )
 229     {
 230       // Note that the SystemOverlay has a separate camera, configured for the full surface-size.
 231       // This will remain unaffected by changes in SetDefaultCameraPosition()
 232       mSystemOverlay->GetImpl()->SetSize( width, height );
 233     }
 234
 235     SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int32_t>( 0, 0, static_cast<int32_t>( width ), static_cast<int32_t>( height ) ) ); // truncated
 236
 237     // if single render task to screen then set its viewport parameters
 238     if( 1 == mRenderTaskList->GetTaskCount() )
 239     {
 240       Dali::RenderTask defaultRenderTask = mRenderTaskList->GetTask( 0u );
 241
 242       if(!defaultRenderTask.GetTargetFrameBuffer())
 243       {
 244         defaultRenderTask.SetViewport( Viewport( 0, 0, static_cast<int32_t>( width ), static_cast<int32_t>( height ) ) ); // truncated
 245       }
 246     }
 247
 248     if( mRenderToFbo )
 249     {
 250       Dali::FrameBuffer frameBuffer = Dali::FrameBuffer::New( static_cast<uint32_t>( width ), static_cast<uint32_t>( height ), Dali::FrameBuffer::Attachment::NONE );
 251       Dali::Texture texture = Dali::Texture::New( Dali::TextureType::TEXTURE_2D, Dali::Pixel::RGB888, static_cast<uint32_t>( width ), static_cast<uint32_t>( height ) );
 252       frameBuffer.AttachColorTexture( texture );
 253
 254       Dali::RenderTask defaultRenderTask = mRenderTaskList->GetTask( 0u );
 255       defaultRenderTask.SetFrameBuffer( frameBuffer );
 256     }
 257   }
 258 }
 259
 260 Vector2 Stage::GetSize() const
 261 {
 262   return mSize;
 263 }
 264
 265 void Stage::SetTopMargin( uint32_t margin )
 266 {
 267   if (mTopMargin == margin)
 268   {
 269     return;
 270   }
 271   mTopMargin = margin;
 272
 273   mSize.width = mSurfaceSize.width;
 274   mSize.height = mSurfaceSize.height - static_cast<float>( mTopMargin );
 275
 276   // Adjust the camera height to allow for top-margin
 277   SetDefaultCameraPosition();
 278
 279   mRootLayer->SetSize( mSize.width, mSize.height );
 280 }
 281
 282 RenderTaskList& Stage::GetRenderTaskList() const
 283 {
 284   return *mRenderTaskList;
 285 }
 286
 287 void Stage::CreateDefaultCameraActor()
 288 {
 289   // The default camera attributes and position is such that
 290   // children of the default layer, can be positioned at (0,0) and
 291   // be at the top-left of the viewport.
 292   mDefaultCamera = CameraActor::New( Size::ZERO );
 293   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 294   Add(*(mDefaultCamera.Get()));
 295 }
 296
 297 void Stage::SetDefaultCameraPosition()
 298 {
 299   mDefaultCamera->SetY( -(static_cast<float>(mTopMargin) * 0.5f) );
 300 }
 301
 302 Actor& Stage::GetDefaultRootActor()
 303 {
 304   return *mRootLayer;
 305 }
 306
 307 CameraActor& Stage::GetDefaultCameraActor()
 308 {
 309   return *mDefaultCamera;
 310 }
 311
 312 uint32_t Stage::GetLayerCount() const
 313 {
 314   return mLayerList->GetLayerCount();
 315 }
 316
 317 Dali::Layer Stage::GetLayer( uint32_t depth ) const
 318 {
 319   return Dali::Layer(mLayerList->GetLayer( depth ));
 320 }
 321
 322 Dali::Layer Stage::GetRootLayer() const
 323 {
 324   return Dali::Layer( mRootLayer.Get() );
 325 }
 326
 327 LayerList& Stage::GetLayerList()
 328 {
 329   return *mLayerList;
 330 }
 331
 332 Integration::SystemOverlay& Stage::GetSystemOverlay()
 333 {
 334   // Lazily create system-level if requested
 335   if( !mSystemOverlay )
 336   {
 337     mSystemOverlay = new Integration::SystemOverlay( SystemOverlay::New( *this ) );
 338     DALI_ASSERT_ALWAYS( NULL != mSystemOverlay && "Failed to create system overlay" );
 339
 340     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 341   }
 342
 343   return *mSystemOverlay;
 344 }
 345
 346 SystemOverlay* Stage::GetSystemOverlayInternal()
 347 {
 348   SystemOverlay* overlay( NULL );
 349
 350   if( mSystemOverlay )
 351   {
 352     overlay = mSystemOverlay->GetImpl();
 353   }
 354
 355   return overlay;
 356 }
 357
 358 void Stage::SetBackgroundColor(Vector4 color)
 359 {
 360   // Cache for public GetBackgroundColor()
 361   mBackgroundColor = color;
 362
 363   // Send message to change color in next frame
 364   SetBackgroundColorMessage( mUpdateManager, color );
 365 }
 366
 367 Vector4 Stage::GetBackgroundColor() const
 368 {
 369   return mBackgroundColor;
 370 }
 371
 372 Vector2 Stage::GetDpi() const
 373 {
 374   return mDpi;
 375 }
 376
 377 void Stage::SetDpi(Vector2 dpi)
 378 {
 379   mDpi = dpi;
 380 }
 381
 382 void Stage::KeepRendering( float durationSeconds )
 383 {
 384   // Send message to keep rendering
 385   KeepRenderingMessage( mUpdateManager, durationSeconds );
 386 }
 387
 388 void Stage::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
 389 {
 390   if( mRenderingBehavior != renderingBehavior )
 391   {
 392     // Send message to change the rendering behavior
 393     SetRenderingBehaviorMessage( mUpdateManager, renderingBehavior );
 394
 395     mRenderingBehavior = renderingBehavior;
 396   }
 397 }
 398
 399 DevelStage::Rendering Stage::GetRenderingBehavior() const
 400 {
 401   return mRenderingBehavior;
 402 }
 403
 404 bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 405 {
 406   bool connected( true );
 407   Stage* stage = static_cast< Stage* >(object); // TypeRegistry guarantees that this is the correct type.
 408
 409   if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
 410   {
 411     stage->KeyEventSignal().Connect( tracker, functor );
 412   }
 413   else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT_GENERATED ) )
 414   {
 415     stage->KeyEventGeneratedSignal().Connect( tracker, functor );
 416   }
 417   else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) )
 418   {
 419     stage->EventProcessingFinishedSignal().Connect( tracker, functor );
 420   }
 421   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) )
 422   {
 423     stage->TouchedSignal().Connect( tracker, functor );
 424   }
 425   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCH ) )
 426   {
 427     stage->TouchSignal().Connect( tracker, functor );
 428   }
 429   else if( 0 == strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) )
 430   {
 431     stage->WheelEventSignal().Connect( tracker, functor );
 432   }
 433   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
 434   {
 435     stage->ContextLostSignal().Connect( tracker, functor );
 436   }
 437   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_REGAINED ) )
 438   {
 439     stage->ContextRegainedSignal().Connect( tracker, functor );
 440   }
 441   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCENE_CREATED ) )
 442   {
 443     stage->SceneCreatedSignal().Connect( tracker, functor );
 444   }
 445   else
 446   {
 447     // signalName does not match any signal
 448     connected = false;
 449   }
 450
 451   return connected;
 452 }
 453
 454 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 455 {
 456   // Emit the key event signal when no actor in the stage has gained the key input focus
 457
 458   mKeyEventSignal.Emit( event );
 459 }
 460
 461 bool Stage::EmitKeyEventGeneratedSignal(const KeyEvent& event)
 462 {
 463   // Emit the KeyEventGenerated signal when KeyEvent is generated
 464
 465   return mKeyEventGeneratedSignal.Emit( event );
 466 }
 467
 468 void Stage::EmitEventProcessingFinishedSignal()
 469 {
 470    mEventProcessingFinishedSignal.Emit();
 471 }
 472
 473 void Stage::EmitTouchedSignal( const TouchEvent& touchEvent, const Dali::TouchData& touch )
 474 {
 475   mTouchedSignal.Emit( touchEvent );
 476   mTouchSignal.Emit( touch );
 477 }
 478
 479 void Stage::EmitWheelEventSignal(const WheelEvent& event)
 480 {
 481   // Emit the wheel event signal when no actor in the stage has gained the wheel input focus
 482
 483   mWheelEventSignal.Emit( event );
 484 }
 485
 486 void Stage::EmitSceneCreatedSignal()
 487 {
 488   mSceneCreatedSignal.Emit();
 489 }
 490
 491 Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal()
 492 {
 493   return mKeyEventSignal;
 494 }
 495
 496 Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal()
 497 {
 498   return mKeyEventGeneratedSignal;
 499 }
 500
 501 void Stage::AddFrameCallback( FrameCallbackInterface& frameCallback, Actor& rootActor )
 502 {
 503   DALI_ASSERT_ALWAYS( ( ! FrameCallbackInterface::Impl::Get( frameCallback ).IsConnectedToSceneGraph() )
 504                       && "FrameCallbackInterface implementation already added" );
 505
 506   // Create scene-graph object and transfer to UpdateManager
 507   OwnerPointer< SceneGraph::FrameCallback > transferOwnership( SceneGraph::FrameCallback::New( frameCallback ) );
 508   AddFrameCallbackMessage( mUpdateManager, transferOwnership, rootActor.GetNode() );
 509 }
 510
 511 void Stage::RemoveFrameCallback( FrameCallbackInterface& frameCallback )
 512 {
 513   FrameCallbackInterface::Impl::Get( frameCallback ).Invalidate();
 514   RemoveFrameCallbackMessage( mUpdateManager, frameCallback );
 515 }
 516
 517 Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
 518 {
 519   return mEventProcessingFinishedSignal;
 520 }
 521
 522 Dali::Stage::TouchedSignalType& Stage::TouchedSignal()
 523 {
 524   DALI_LOG_WARNING( "Deprecated. Use TouchSignal() instead.\n" );
 525   return mTouchedSignal;
 526 }
 527
 528 Dali::Stage::TouchSignalType& Stage::TouchSignal()
 529 {
 530   return mTouchSignal;
 531 }
 532
 533 Dali::Stage::WheelEventSignalType& Stage::WheelEventSignal()
 534 {
 535   return mWheelEventSignal;
 536 }
 537
 538 Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
 539 {
 540   return mContextLostSignal;
 541 }
 542
 543 Dali::Stage::ContextStatusSignal& Stage::ContextRegainedSignal()
 544 {
 545   return mContextRegainedSignal;
 546 }
 547
 548 Dali::Stage::SceneCreatedSignalType& Stage::SceneCreatedSignal()
 549 {
 550   return mSceneCreatedSignal;
 551 }
 552
 553 void Stage::NotifyContextLost()
 554 {
 555   mContextLostSignal.Emit();
 556 }
 557
 558 void Stage::NotifyContextRegained()
 559 {
 560   mContextRegainedSignal.Emit();
 561 }
 562
 563
 564 void Stage::RequestRebuildDepthTree()
 565 {
 566   DALI_LOG_INFO(gLogFilter, Debug::General, "RequestRebuildDepthTree()\n");
 567   mDepthTreeDirty = true;
 568 }
 569
 570 void Stage::RebuildDepthTree()
 571 {
 572   // If the depth tree needs rebuilding, do it in this frame only.
 573   if( mDepthTreeDirty )
 574   {
 575     DALI_LOG_INFO(gLogFilter, Debug::Concise, "RebuildDepthTree() dirty:T\n");
 576
 577     ActorPtr actor( mRootLayer.Get() );
 578     actor->RebuildDepthTree();
 579     mDepthTreeDirty = false;
 580   }
 581 }
 582
 583
 584 Stage::Stage( AnimationPlaylist& playlist,
 585               PropertyNotificationManager& propertyNotificationManager,
 586               SceneGraph::UpdateManager& updateManager,
 587               NotificationManager& notificationManager,
 588               Integration::RenderController& renderController )
 589 : mAnimationPlaylist( playlist ),
 590   mPropertyNotificationManager( propertyNotificationManager ),
 591   mUpdateManager( updateManager ),
 592   mNotificationManager( notificationManager ),
 593   mRenderController( renderController ),
 594   mSize( Vector2::ZERO ),
 595   mSurfaceSize( Vector2::ZERO ),
 596   mBackgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
 597   mTopMargin( 0 ),
 598   mDpi( Vector2::ZERO ),
 599   mSystemOverlay( NULL ),
 600   mKeyEventSignal(),
 601   mKeyEventGeneratedSignal(),
 602   mEventProcessingFinishedSignal(),
 603   mTouchedSignal(),
 604   mTouchSignal(),
 605   mWheelEventSignal(),
 606   mContextLostSignal(),
 607   mContextRegainedSignal(),
 608   mSceneCreatedSignal(),
 609   mRenderingBehavior( DevelStage::Rendering::IF_REQUIRED ),
 610   mDepthTreeDirty( false ),
 611   mForceNextUpdate( false ),
 612   mRenderToFbo( false )
 613 {
 614 }
 615
 616 SceneGraph::UpdateManager& Stage::GetUpdateManager()
 617 {
 618   return mUpdateManager;
 619 }
 620
 621 Integration::RenderController& Stage::GetRenderController()
 622 {
 623   return mRenderController;
 624 }
 625
 626 uint32_t* Stage::ReserveMessageSlot( uint32_t size, bool updateScene )
 627 {
 628   return mUpdateManager.ReserveMessageSlot( size, updateScene );
 629 }
 630
 631 BufferIndex Stage::GetEventBufferIndex() const
 632 {
 633   return mUpdateManager.GetEventBufferIndex();
 634 }
 635
 636 void Stage::ForceNextUpdate()
 637 {
 638   mForceNextUpdate = true;
 639 }
 640
 641 bool Stage::IsNextUpdateForced()
 642 {
 643   bool nextUpdateForced = mForceNextUpdate;
 644   mForceNextUpdate = false;
 645   return nextUpdateForced;
 646 }
 647
 648 Stage::~Stage()
 649 {
 650   delete mSystemOverlay;
 651
 652   mObjectRegistry.Reset();
 653 }
 654
 655 } // namespace Internal
 656
 657 } // namespace Dali