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