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

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