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