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