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

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