Add Overlay Layer in scene

[platform/core/uifw/dali-core.git] / dali / internal / event / common / scene-impl.cpp

diff --git a/dali/internal/event/common/scene-impl.cpp b/dali/internal/event/common/scene-impl.cpp
index 5c54f76..56ed507 100644 (file)
--- a/dali/internal/event/common/scene-impl.cpp
+++ b/dali/internal/event/common/scene-impl.cpp
@@ -41,12 +41,12 @@ namespace Dali
 {
 namespace Internal
 {
-ScenePtr Scene::New(Size size, int32_t orientation)
+ScenePtr Scene::New(Size size, int32_t windowOrientation, int32_t screenOrientation)
 {
   ScenePtr scene = new Scene;
 
   // Second-phase construction
-  scene->Initialize(size, orientation);
+  scene->Initialize(size, windowOrientation, screenOrientation);
 
   return scene;
 }
@@ -58,7 +58,8 @@ Scene::Scene()
   mBackgroundColor(DEFAULT_BACKGROUND_COLOR),
   mDepthTreeDirty(false),
   mEventProcessor(*this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor()),
-  mSurfaceOrientation(0)
+  mSurfaceOrientation(0),
+  mScreenOrientation(0)
 {
 }
 
@@ -84,6 +85,11 @@ Scene::~Scene()
     mRootLayer.Reset();
   }
 
+  if(mOverlayLayer)
+  {
+    mOverlayLayer.Reset();
+  }
+
   if(mRenderTaskList)
   {
     mRenderTaskList.Reset();
@@ -93,7 +99,7 @@ Scene::~Scene()
   // When this destructor is called, the scene has either already been removed from Core or Core has already been destroyed
 }
 
-void Scene::Initialize(Size size, int32_t orientation)
+void Scene::Initialize(Size size, int32_t windowOrientation, int32_t screenOrientation)
 {
   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 
@@ -135,7 +141,7 @@ void Scene::Initialize(Size size, int32_t orientation)
   OwnerPointer<SceneGraph::Scene> transferOwnership(const_cast<SceneGraph::Scene*>(mSceneObject));
   AddSceneMessage(updateManager, transferOwnership);
 
-  SurfaceRotated(size.width, size.height, orientation);
+  SurfaceRotated(size.width, size.height, windowOrientation, screenOrientation);
 }
 
 void Scene::Add(Actor& actor)
@@ -173,6 +179,26 @@ Dali::Layer Scene::GetRootLayer() const
   return Dali::Layer(mRootLayer.Get());
 }
 
+Dali::Layer Scene::GetOverlayLayer()
+{
+  if(!mOverlayLayer)
+  {
+    // Creates overlay layer.
+    mOverlayLayer = Layer::New();
+    mOverlayLayer->SetName("OverlayLayer");
+    mOverlayLayer->SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+    mOverlayLayer->SetParentOrigin(Dali::ParentOrigin::TOP_LEFT);
+    mOverlayLayer->SetAnchorPoint(Dali::AnchorPoint::TOP_LEFT);
+    mRootLayer->Add(*mOverlayLayer);
+
+    // Create the overlay render-task and set exclusive to true.
+    RenderTaskPtr renderTask = mRenderTaskList->CreateOverlayTask(mOverlayLayer.Get(), mDefaultCamera.Get());
+    renderTask->SetExclusive(true);
+    renderTask->SetInputEnabled(true);
+  }
+  return Dali::Layer(mOverlayLayer.Get());
+}
+
 LayerList& Scene::GetLayerList() const
 {
   return *mLayerList;
@@ -202,7 +228,7 @@ void Scene::SurfaceResized(float width, float height)
 {
   if((fabsf(mSize.width - width) > Math::MACHINE_EPSILON_1) || (fabsf(mSize.height - height) > Math::MACHINE_EPSILON_1))
   {
-    ChangedSurface(width, height, mSurfaceOrientation);
+    ChangedSurface(width, height, mSurfaceOrientation, mScreenOrientation);
   }
 }
 
@@ -277,10 +303,9 @@ void Scene::EmitKeyEventSignal(const Dali::KeyEvent& event)
   }
 }
 
-void Scene::SurfaceRotated(float width, float height, int32_t orientation)
+void Scene::SurfaceRotated(float width, float height, int32_t windowOrientation, int32_t screenOrientation)
 {
-  mSurfaceOrientation = orientation;
-  ChangedSurface(width, height, orientation);
+  ChangedSurface(width, height, windowOrientation, screenOrientation);
 }
 
 int32_t Scene::GetCurrentSurfaceOrientation() const
@@ -288,32 +313,61 @@ int32_t Scene::GetCurrentSurfaceOrientation() const
   return mSceneObject->GetSurfaceOrientation();
 }
 
+int32_t Scene::GetCurrentScreenOrientation() const
+{
+  return mSceneObject->GetScreenOrientation();
+}
+
 const Rect<int32_t>& Scene::GetCurrentSurfaceRect() const
 {
   return mSceneObject->GetSurfaceRect();
 }
 
-void Scene::ChangedSurface(float width, float height, int32_t orientation)
+void Scene::ChangedSurface(float width, float height, int32_t windowOrientation, int32_t screenOrientation)
 {
+  bool changedOrientation = false;
   Rect<int32_t> newSize(0, 0, static_cast<int32_t>(width), static_cast<int32_t>(height)); // truncated
   mSize.width  = width;
   mSize.height = height;
 
+  if(mSurfaceOrientation != windowOrientation || mScreenOrientation != screenOrientation)
+  {
+    changedOrientation = true;
+  }
+
+  mSurfaceOrientation = windowOrientation;
+  mScreenOrientation = screenOrientation;
+
   // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
   mDefaultCamera->SetPerspectiveProjection(mSize);
   // Set the surface orientation to Default camera for window/screen rotation
-  mDefaultCamera->RotateProjection(orientation);
+  if(changedOrientation)
+  {
+    int32_t orientation = (windowOrientation + screenOrientation) % 360;
+    mDefaultCamera->RotateProjection(orientation);
+  }
 
   mRootLayer->SetSize(width, height);
 
   // Send the surface rectangle/orientation to SceneGraph::Scene for calculating glViewport/Scissor
   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+  DALI_LOG_RELEASE_INFO("Send Surface Rect Message, width[%d], height[%d]\n", newSize.width, newSize.height);
   SetSurfaceRectMessage(tls->GetEventThreadServices(), *mSceneObject, newSize);
-  SetSurfaceOrientationMessage(tls->GetEventThreadServices(), *mSceneObject, static_cast<int32_t>(orientation));
+  if(changedOrientation)
+  {
+    DALI_LOG_RELEASE_INFO("Send Surface Orientation Message, surface orientation[%d], screen orientation[%d]\n", mSurfaceOrientation, mScreenOrientation);
+    SetSurfaceOrientationsMessage(tls->GetEventThreadServices(), *mSceneObject, mSurfaceOrientation, mScreenOrientation);
+  }
 
   // set default render-task viewport parameters
   RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask(0u);
   defaultRenderTask->SetViewport(newSize);
+  // set overlay render-task viewport parameters
+  RenderTaskPtr overlayRenderTask = mRenderTaskList->GetOverlayTask();
+  if(overlayRenderTask)
+  {
+    overlayRenderTask->SetViewport(newSize);
+  }
 }
 
 bool Scene::IsSurfaceRectChanged() const
@@ -346,6 +400,13 @@ bool Scene::EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event)
   return mKeyEventGeneratedSignal.Emit(event);
 }
 
+bool Scene::EmitInterceptKeyEventSignal(const Dali::KeyEvent& event)
+{
+  // Emit the InterceptKeyEvent signal
+  Dali::Integration::Scene handle(this);
+  return mInterceptKeyEventSignal.Emit(event);
+}
+
 void Scene::EmitEventProcessingFinishedSignal()
 {
   if(!mEventProcessingFinishedSignal.Empty())
@@ -412,6 +473,11 @@ Integration::Scene::KeyEventGeneratedSignalType& Scene::KeyEventGeneratedSignal(
   return mKeyEventGeneratedSignal;
 }
 
+Integration::Scene::KeyEventGeneratedSignalType& Scene::InterceptKeyEventSignal()
+{
+  return mInterceptKeyEventSignal;
+}
+
 Integration::Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
 {
   return mEventProcessingFinishedSignal;