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 static constexpr std::string_view SIGNAL_KEY_EVENT                 = "keyEvent";
  66 static constexpr std::string_view SIGNAL_KEY_EVENT_GENERATED       = "keyEventGenerated";
  67 static constexpr std::string_view SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished";
  68 static constexpr std::string_view SIGNAL_TOUCHED                   = "touched";
  69 static constexpr std::string_view SIGNAL_WHEEL_EVENT               = "wheelEvent";
  70 static constexpr std::string_view SIGNAL_CONTEXT_LOST              = "contextLost";
  71 static constexpr std::string_view SIGNAL_CONTEXT_REGAINED          = "contextRegained";
  72 static constexpr std::string_view SIGNAL_SCENE_CREATED             = "sceneCreated";
  73
  74 TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), nullptr );
  75
  76 SignalConnectorType signalConnector1(mType, std::string(SIGNAL_KEY_EVENT), &Stage::DoConnectSignal);
  77 SignalConnectorType signalConnector2(mType, std::string(SIGNAL_EVENT_PROCESSING_FINISHED), &Stage::DoConnectSignal);
  78 SignalConnectorType signalConnector4(mType, std::string(SIGNAL_WHEEL_EVENT), &Stage::DoConnectSignal);
  79 SignalConnectorType signalConnector5(mType, std::string(SIGNAL_CONTEXT_LOST), &Stage::DoConnectSignal);
  80 SignalConnectorType signalConnector6(mType, std::string(SIGNAL_CONTEXT_REGAINED), &Stage::DoConnectSignal);
  81 SignalConnectorType signalConnector7(mType, std::string(SIGNAL_SCENE_CREATED), &Stage::DoConnectSignal);
  82 SignalConnectorType signalConnector8(mType, std::string(SIGNAL_KEY_EVENT_GENERATED), &Stage::DoConnectSignal);
  83 SignalConnectorType signalConnector9(mType, std::string(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   std::string_view name(signalName);
 222
 223   if(name == SIGNAL_KEY_EVENT)
 224   {
 225     stage->KeyEventSignal().Connect( tracker, functor );
 226   }
 227   else if(name == SIGNAL_KEY_EVENT_GENERATED)
 228   {
 229     stage->KeyEventGeneratedSignal().Connect( tracker, functor );
 230   }
 231   else if(name == SIGNAL_EVENT_PROCESSING_FINISHED)
 232   {
 233     stage->EventProcessingFinishedSignal().Connect( tracker, functor );
 234   }
 235   else if(name == SIGNAL_TOUCHED)
 236   {
 237     stage->TouchedSignal().Connect( tracker, functor );
 238   }
 239   else if(name == SIGNAL_WHEEL_EVENT)
 240   {
 241     stage->WheelEventSignal().Connect( tracker, functor );
 242   }
 243   else if(name == SIGNAL_CONTEXT_LOST)
 244   {
 245     stage->ContextLostSignal().Connect( tracker, functor );
 246   }
 247   else if(name == SIGNAL_CONTEXT_REGAINED)
 248   {
 249     stage->ContextRegainedSignal().Connect( tracker, functor );
 250   }
 251   else if(name == SIGNAL_SCENE_CREATED)
 252   {
 253     stage->SceneCreatedSignal().Connect( tracker, functor );
 254   }
 255   else
 256   {
 257     // signalName does not match any signal
 258     connected = false;
 259   }
 260
 261   return connected;
 262 }
 263
 264 void Stage::OnEventProcessingFinished()
 265 {
 266   EmitEventProcessingFinishedSignal();
 267 }
 268
 269 void Stage::OnKeyEvent( const Dali::KeyEvent& event )
 270 {
 271   bool consumed = EmitKeyEventGeneratedSignal( event );
 272   if( !consumed )
 273   {
 274     EmitKeyEventSignal( event );
 275   }
 276 }
 277
 278 void Stage::OnTouchEvent( const Dali::TouchEvent& touch )
 279 {
 280   EmitTouchedSignal( touch );
 281 }
 282
 283 void Stage::OnWheelEvent( const Dali::WheelEvent& event )
 284 {
 285   EmitWheelEventSignal( event );
 286 }
 287
 288 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 289 {
 290   // Emit the key event signal when no actor in the stage has gained the key input focus
 291
 292   mKeyEventSignal.Emit( event );
 293 }
 294
 295 bool Stage::EmitKeyEventGeneratedSignal(const KeyEvent& event)
 296 {
 297   // Emit the KeyEventGenerated signal when KeyEvent is generated
 298
 299   return mKeyEventGeneratedSignal.Emit( event );
 300 }
 301
 302 void Stage::EmitEventProcessingFinishedSignal()
 303 {
 304   mEventProcessingFinishedSignal.Emit();
 305 }
 306
 307 void Stage::EmitTouchedSignal( const Dali::TouchEvent& touch )
 308 {
 309   mTouchedSignal.Emit( touch );
 310 }
 311
 312 void Stage::EmitWheelEventSignal( const WheelEvent& event )
 313 {
 314   // Emit the wheel event signal when no actor in the stage has gained the wheel input focus
 315
 316   mWheelEventSignal.Emit( event );
 317 }
 318
 319 void Stage::EmitSceneCreatedSignal()
 320 {
 321   mSceneCreatedSignal.Emit();
 322 }
 323
 324 Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal()
 325 {
 326   return mKeyEventSignal;
 327 }
 328
 329 Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal()
 330 {
 331   return mKeyEventGeneratedSignal;
 332 }
 333
 334 void Stage::AddFrameCallback( FrameCallbackInterface& frameCallback, Actor& rootActor )
 335 {
 336   DALI_ASSERT_ALWAYS( ( ! FrameCallbackInterface::Impl::Get( frameCallback ).IsConnectedToSceneGraph() )
 337                       && "FrameCallbackInterface implementation already added" );
 338
 339   // Create scene-graph object and transfer to UpdateManager
 340   OwnerPointer< SceneGraph::FrameCallback > transferOwnership( SceneGraph::FrameCallback::New( frameCallback ) );
 341   AddFrameCallbackMessage( mUpdateManager, transferOwnership, rootActor.GetNode() );
 342 }
 343
 344 void Stage::RemoveFrameCallback( FrameCallbackInterface& frameCallback )
 345 {
 346   FrameCallbackInterface::Impl::Get( frameCallback ).Invalidate();
 347   RemoveFrameCallbackMessage( mUpdateManager, frameCallback );
 348 }
 349
 350 Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
 351 {
 352   return mEventProcessingFinishedSignal;
 353 }
 354
 355 Dali::Stage::TouchEventSignalType& Stage::TouchedSignal()
 356 {
 357   return mTouchedSignal;
 358 }
 359
 360 Dali::Stage::WheelEventSignalType& Stage::WheelEventSignal()
 361 {
 362   return mWheelEventSignal;
 363 }
 364
 365 Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
 366 {
 367   return mContextLostSignal;
 368 }
 369
 370 Dali::Stage::ContextStatusSignal& Stage::ContextRegainedSignal()
 371 {
 372   return mContextRegainedSignal;
 373 }
 374
 375 Dali::Stage::SceneCreatedSignalType& Stage::SceneCreatedSignal()
 376 {
 377   return mSceneCreatedSignal;
 378 }
 379
 380 void Stage::NotifyContextLost()
 381 {
 382   mContextLostSignal.Emit();
 383 }
 384
 385 void Stage::NotifyContextRegained()
 386 {
 387   mContextRegainedSignal.Emit();
 388 }
 389
 390 Stage::Stage( SceneGraph::UpdateManager& updateManager )
 391 : mUpdateManager( updateManager ),
 392   mKeyEventSignal(),
 393   mKeyEventGeneratedSignal(),
 394   mEventProcessingFinishedSignal(),
 395   mTouchedSignal(),
 396   mWheelEventSignal(),
 397   mContextLostSignal(),
 398   mContextRegainedSignal(),
 399   mSceneCreatedSignal(),
 400   mRenderingBehavior( DevelStage::Rendering::IF_REQUIRED )
 401 {
 402 }
 403
 404 Stage::~Stage() = default;
 405
 406 } // namespace Internal
 407
 408 } // namespace Dali