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

   1 /*
   2  * Copyright (c) 2020 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/internal/event/actors/layer-impl.h>
  28 #include <dali/internal/event/actors/layer-list.h>
  29 #include <dali/internal/event/actors/camera-actor-impl.h>
  30 #include <dali/internal/event/common/thread-local-storage.h>
  31 #include <dali/internal/event/common/property-notification-manager.h>
  32 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  33 #include <dali/internal/event/update/frame-callback-interface-impl.h>
  34 #include <dali/internal/update/nodes/node.h>
  35 #include <dali/internal/update/manager/scene-graph-frame-callback.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-event.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 #include <dali/public-api/common/constants.h>
  44
  45 using Dali::Internal::SceneGraph::Node;
  46
  47 namespace
  48 {
  49 #if defined(DEBUG_ENABLED)
  50 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_DEPTH_TIMER" );
  51 #endif
  52 }
  53
  54 namespace Dali
  55 {
  56
  57 namespace Internal
  58 {
  59
  60 namespace
  61 {
  62
  63 // Signals
  64
  65 const char* const SIGNAL_KEY_EVENT =                 "keyEvent";
  66 const char* const SIGNAL_KEY_EVENT_GENERATED =       "keyEventGenerated";
  67 const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished";
  68 const char* const SIGNAL_TOUCHED =                   "touched";
  69 const char* const SIGNAL_WHEEL_EVENT =               "wheelEvent";
  70 const char* const SIGNAL_CONTEXT_LOST =              "contextLost";
  71 const char* const SIGNAL_CONTEXT_REGAINED =          "contextRegained";
  72 const char* const SIGNAL_SCENE_CREATED =             "sceneCreated";
  73
  74 TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), nullptr );
  75
  76 SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT,                 &Stage::DoConnectSignal );
  77 SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
  78 SignalConnectorType signalConnector4( mType, SIGNAL_WHEEL_EVENT,               &Stage::DoConnectSignal );
  79 SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_LOST,              &Stage::DoConnectSignal );
  80 SignalConnectorType signalConnector6( mType, SIGNAL_CONTEXT_REGAINED,          &Stage::DoConnectSignal );
  81 SignalConnectorType signalConnector7( mType, SIGNAL_SCENE_CREATED,             &Stage::DoConnectSignal );
  82 SignalConnectorType signalConnector8( mType, SIGNAL_KEY_EVENT_GENERATED,       &Stage::DoConnectSignal );
  83 SignalConnectorType signalConnector9( mType, SIGNAL_TOUCHED,                   &Stage::DoConnectSignal );
  84
  85 } // unnamed namespace
  86
  87 StagePtr Stage::New( SceneGraph::UpdateManager& updateManager )
  88 {
  89   return StagePtr( new Stage( updateManager ) );
  90 }
  91
  92 void Stage::Initialize( Scene& scene )
  93 {
  94   mScene = &scene;
  95   mScene->SetBackgroundColor( Dali::DEFAULT_BACKGROUND_COLOR );
  96   mScene->EventProcessingFinishedSignal().Connect( this, &Stage::OnEventProcessingFinished );
  97   mScene->KeyEventSignal().Connect( this, &Stage::OnKeyEvent );
  98   mScene->TouchedSignal().Connect( this, &Stage::OnTouchEvent );
  99   mScene->WheelEventSignal().Connect( this, &Stage::OnWheelEvent );
 100 }
 101
 102 StagePtr Stage::GetCurrent()
 103 {
 104   StagePtr stage( nullptr );
 105   // no checking in this version
 106   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 107   if( tls )
 108   {
 109     stage = tls->GetCurrentStage();
 110   }
 111   return stage;
 112 }
 113
 114 bool Stage::IsInstalled()
 115 {
 116   return ThreadLocalStorage::Created();
 117 }
 118
 119 ObjectRegistry& Stage::GetObjectRegistry()
 120 {
 121   return ThreadLocalStorage::Get().GetObjectRegistry();
 122 }
 123
 124 Layer& Stage::GetRootActor()
 125 {
 126   Dali::Layer rootLayer = GetRootLayer();
 127   return GetImplementation( rootLayer );
 128 }
 129
 130 void Stage::Add( Actor& actor )
 131 {
 132   mScene->Add( actor );
 133 }
 134
 135 void Stage::Remove( Actor& actor )
 136 {
 137   mScene->Remove( actor );
 138 }
 139
 140 Vector2 Stage::GetSize() const
 141 {
 142   return mScene->GetSize();
 143 }
 144
 145 RenderTaskList& Stage::GetRenderTaskList() const
 146 {
 147   return mScene->GetRenderTaskList();
 148 }
 149
 150 Actor& Stage::GetDefaultRootActor()
 151 {
 152   return mScene->GetDefaultRootActor();
 153 }
 154
 155 CameraActor& Stage::GetDefaultCameraActor()
 156 {
 157   return mScene->GetDefaultCameraActor();
 158 }
 159
 160 uint32_t Stage::GetLayerCount() const
 161 {
 162   return mScene->GetLayerCount();
 163 }
 164
 165 Dali::Layer Stage::GetLayer( uint32_t depth ) const
 166 {
 167   return mScene->GetLayer( depth );
 168 }
 169
 170 Dali::Layer Stage::GetRootLayer() const
 171 {
 172   return mScene->GetRootLayer();
 173 }
 174
 175 LayerList& Stage::GetLayerList()
 176 {
 177   return mScene->GetLayerList();
 178 }
 179
 180 void Stage::SetBackgroundColor(Vector4 color)
 181 {
 182   mScene->SetBackgroundColor( color );
 183 }
 184
 185 Vector4 Stage::GetBackgroundColor() const
 186 {
 187   return mScene->GetBackgroundColor();
 188 }
 189
 190 Vector2 Stage::GetDpi() const
 191 {
 192   return mScene->GetDpi();
 193 }
 194
 195 void Stage::KeepRendering( float durationSeconds )
 196 {
 197   // Send message to keep rendering
 198   KeepRenderingMessage( mUpdateManager, durationSeconds );
 199 }
 200
 201 void Stage::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
 202 {
 203   if( mRenderingBehavior != renderingBehavior )
 204   {
 205     // Send message to change the rendering behavior
 206     SetRenderingBehaviorMessage( mUpdateManager, renderingBehavior );
 207
 208     mRenderingBehavior = renderingBehavior;
 209   }
 210 }
 211
 212 DevelStage::Rendering Stage::GetRenderingBehavior() const
 213 {
 214   return mRenderingBehavior;
 215 }
 216
 217 bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 218 {
 219   bool connected( true );
 220   Stage* stage = static_cast< Stage* >(object); // TypeRegistry guarantees that this is the correct type.
 221
 222   if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
 223   {
 224     stage->KeyEventSignal().Connect( tracker, functor );
 225   }
 226   else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT_GENERATED ) )
 227   {
 228     stage->KeyEventGeneratedSignal().Connect( tracker, functor );
 229   }
 230   else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) )
 231   {
 232     stage->EventProcessingFinishedSignal().Connect( tracker, functor );
 233   }
 234   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) )
 235   {
 236     stage->TouchedSignal().Connect( tracker, functor );
 237   }
 238   else if( 0 == strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) )
 239   {
 240     stage->WheelEventSignal().Connect( tracker, functor );
 241   }
 242   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
 243   {
 244     stage->ContextLostSignal().Connect( tracker, functor );
 245   }
 246   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_REGAINED ) )
 247   {
 248     stage->ContextRegainedSignal().Connect( tracker, functor );
 249   }
 250   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCENE_CREATED ) )
 251   {
 252     stage->SceneCreatedSignal().Connect( tracker, functor );
 253   }
 254   else
 255   {
 256     // signalName does not match any signal
 257     connected = false;
 258   }
 259
 260   return connected;
 261 }
 262
 263 void Stage::OnEventProcessingFinished()
 264 {
 265   EmitEventProcessingFinishedSignal();
 266 }
 267
 268 void Stage::OnKeyEvent( const Dali::KeyEvent& event )
 269 {
 270   bool consumed = EmitKeyEventGeneratedSignal( event );
 271   if( !consumed )
 272   {
 273     EmitKeyEventSignal( event );
 274   }
 275 }
 276
 277 void Stage::OnTouchEvent( const Dali::TouchEvent& touch )
 278 {
 279   EmitTouchedSignal( touch );
 280 }
 281
 282 void Stage::OnWheelEvent( const Dali::WheelEvent& event )
 283 {
 284   EmitWheelEventSignal( event );
 285 }
 286
 287 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 288 {
 289   // Emit the key event signal when no actor in the stage has gained the key input focus
 290
 291   mKeyEventSignal.Emit( event );
 292 }
 293
 294 bool Stage::EmitKeyEventGeneratedSignal(const KeyEvent& event)
 295 {
 296   // Emit the KeyEventGenerated signal when KeyEvent is generated
 297
 298   return mKeyEventGeneratedSignal.Emit( event );
 299 }
 300
 301 void Stage::EmitEventProcessingFinishedSignal()
 302 {
 303   mEventProcessingFinishedSignal.Emit();
 304 }
 305
 306 void Stage::EmitTouchedSignal( const Dali::TouchEvent& touch )
 307 {
 308   mTouchedSignal.Emit( touch );
 309 }
 310
 311 void Stage::EmitWheelEventSignal( const WheelEvent& event )
 312 {
 313   // Emit the wheel event signal when no actor in the stage has gained the wheel input focus
 314
 315   mWheelEventSignal.Emit( event );
 316 }
 317
 318 void Stage::EmitSceneCreatedSignal()
 319 {
 320   mSceneCreatedSignal.Emit();
 321 }
 322
 323 Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal()
 324 {
 325   return mKeyEventSignal;
 326 }
 327
 328 Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal()
 329 {
 330   return mKeyEventGeneratedSignal;
 331 }
 332
 333 void Stage::AddFrameCallback( FrameCallbackInterface& frameCallback, Actor& rootActor )
 334 {
 335   DALI_ASSERT_ALWAYS( ( ! FrameCallbackInterface::Impl::Get( frameCallback ).IsConnectedToSceneGraph() )
 336                       && "FrameCallbackInterface implementation already added" );
 337
 338   // Create scene-graph object and transfer to UpdateManager
 339   OwnerPointer< SceneGraph::FrameCallback > transferOwnership( SceneGraph::FrameCallback::New( frameCallback ) );
 340   AddFrameCallbackMessage( mUpdateManager, transferOwnership, rootActor.GetNode() );
 341 }
 342
 343 void Stage::RemoveFrameCallback( FrameCallbackInterface& frameCallback )
 344 {
 345   FrameCallbackInterface::Impl::Get( frameCallback ).Invalidate();
 346   RemoveFrameCallbackMessage( mUpdateManager, frameCallback );
 347 }
 348
 349 Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
 350 {
 351   return mEventProcessingFinishedSignal;
 352 }
 353
 354 Dali::Stage::TouchEventSignalType& Stage::TouchedSignal()
 355 {
 356   return mTouchedSignal;
 357 }
 358
 359 Dali::Stage::WheelEventSignalType& Stage::WheelEventSignal()
 360 {
 361   return mWheelEventSignal;
 362 }
 363
 364 Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
 365 {
 366   return mContextLostSignal;
 367 }
 368
 369 Dali::Stage::ContextStatusSignal& Stage::ContextRegainedSignal()
 370 {
 371   return mContextRegainedSignal;
 372 }
 373
 374 Dali::Stage::SceneCreatedSignalType& Stage::SceneCreatedSignal()
 375 {
 376   return mSceneCreatedSignal;
 377 }
 378
 379 void Stage::NotifyContextLost()
 380 {
 381   mContextLostSignal.Emit();
 382 }
 383
 384 void Stage::NotifyContextRegained()
 385 {
 386   mContextRegainedSignal.Emit();
 387 }
 388
 389 Stage::Stage( SceneGraph::UpdateManager& updateManager )
 390 : mUpdateManager( updateManager ),
 391   mKeyEventSignal(),
 392   mKeyEventGeneratedSignal(),
 393   mEventProcessingFinishedSignal(),
 394   mTouchedSignal(),
 395   mWheelEventSignal(),
 396   mContextLostSignal(),
 397   mContextRegainedSignal(),
 398   mSceneCreatedSignal(),
 399   mRenderingBehavior( DevelStage::Rendering::IF_REQUIRED )
 400 {
 401 }
 402
 403 Stage::~Stage()
 404 {
 405 }
 406
 407 } // namespace Internal
 408
 409 } // namespace Dali