Revert "[Tizen] Revert "Support multiple window rendering""

[platform/core/uifw/dali-adaptor.git] / dali / internal / window-system / common / window-impl.cpp

diff --git a/dali/internal/window-system/common/window-impl.cpp b/dali/internal/window-system/common/window-impl.cpp
index 715861e..fd9d99a 100644 (file)
--- a/dali/internal/window-system/common/window-impl.cpp
+++ b/dali/internal/window-system/common/window-impl.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.

  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.


@@ -20,18 +20,21 @@
 
 // EXTERNAL HEADERS
 #include <dali/integration-api/core.h>
 
 // EXTERNAL HEADERS
 #include <dali/integration-api/core.h>

-#include <dali/integration-api/system-overlay.h>
+#include <dali/integration-api/render-task-list-integ.h>
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/actors/camera-actor.h>

 #include <dali/public-api/render-tasks/render-task.h>
 #include <dali/public-api/render-tasks/render-task-list.h>
 #include <dali/public-api/render-tasks/render-task.h>
 #include <dali/public-api/render-tasks/render-task-list.h>

+#include <dali/public-api/rendering/frame-buffer.h>

 #include <dali/devel-api/adaptor-framework/orientation.h>
 
 // INTERNAL HEADERS
 #include <dali/internal/input/common/drag-and-drop-detector-impl.h>
 #include <dali/devel-api/adaptor-framework/orientation.h>
 
 // INTERNAL HEADERS
 #include <dali/internal/input/common/drag-and-drop-detector-impl.h>

-#include <dali/internal/window-system/common/ecore-indicator-impl.h>

 #include <dali/internal/window-system/common/window-visibility-observer.h>
 #include <dali/internal/window-system/common/orientation-impl.h>
 #include <dali/internal/window-system/common/render-surface-factory.h>
 #include <dali/internal/window-system/common/window-visibility-observer.h>
 #include <dali/internal/window-system/common/orientation-impl.h>
 #include <dali/internal/window-system/common/render-surface-factory.h>

-#include <dali/internal/window-system/common/window-base-factory.h>
+#include <dali/internal/window-system/common/window-factory.h>

 #include <dali/internal/window-system/common/window-base.h>
 #include <dali/internal/window-system/common/window-render-surface.h>
 
 #include <dali/internal/window-system/common/window-base.h>
 #include <dali/internal/window-system/common/window-render-surface.h>
 


@@ -42,6 +45,8 @@ namespace Internal
 namespace Adaptor
 {
 
 namespace Adaptor
 {
 

+uint32_t Window::mWindowCounter = 0;
+

 namespace
 {
 
 namespace
 {
 


@@ -60,23 +65,22 @@ Window* Window::New( const PositionSize& positionSize, const std::string& name,
 }
 
 Window::Window()
 }
 
 Window::Window()

-: mSurface( NULL ),
+: mId( mWindowCounter++ ),
+  mSurface( nullptr ),

   mWindowBase(),
   mWindowBase(),

-  mIndicatorVisible( Dali::Window::VISIBLE ),
+  mIndicatorVisible( Dali::Window::INVISIBLE ),   // TODO: Enable this after indicator implementation based on tizen 5.

   mIndicatorIsShown( false ),
   mShowRotatedIndicatorOnClose( false ),
   mStarted( false ),
   mIndicatorIsShown( false ),
   mShowRotatedIndicatorOnClose( false ),
   mStarted( false ),

-  mIsTransparent( false ),

   mIsFocusAcceptable( true ),
   mVisible( true ),
   mIconified( false ),
   mOpaqueState( false ),
   mResizeEnabled( false ),
   mIsFocusAcceptable( true ),
   mVisible( true ),
   mIconified( false ),
   mOpaqueState( false ),
   mResizeEnabled( false ),

-  mIndicator( NULL ),
+  mIndicator(),

   mIndicatorOrientation( Dali::Window::PORTRAIT ),
   mNextIndicatorOrientation( Dali::Window::PORTRAIT ),
   mIndicatorOpacityMode( Dali::Window::OPAQUE ),
   mIndicatorOrientation( Dali::Window::PORTRAIT ),
   mNextIndicatorOrientation( Dali::Window::PORTRAIT ),
   mIndicatorOpacityMode( Dali::Window::OPAQUE ),

-  mOverlay( NULL ),

   mAdaptor( NULL ),
   mType( Dali::Window::NORMAL ),
   mPreferredOrientation( Dali::Window::PORTRAIT ),
   mAdaptor( NULL ),
   mType( Dali::Window::NORMAL ),
   mPreferredOrientation( Dali::Window::PORTRAIT ),


@@ -91,37 +95,37 @@ Window::~Window()
 {
   if( mIndicator )
   {
 {
   if( mIndicator )
   {

-    mOverlay->Remove( mIndicator->GetActor() );
-    Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
-    Dali::RenderTask indicatorTask = taskList.GetTask(0);
-    mOverlay->GetOverlayRenderTasks().RemoveTask(indicatorTask);

     mIndicator->Close();
     mIndicator->Close();

-    delete mIndicator;

   }
 
   if ( mAdaptor )
   {
     mAdaptor->RemoveObserver( *this );
     mAdaptor->SetDragAndDropDetector( NULL );
   }
 
   if ( mAdaptor )
   {
     mAdaptor->RemoveObserver( *this );
     mAdaptor->SetDragAndDropDetector( NULL );

+    mAdaptor->RemoveWindow( this );

     mAdaptor = NULL;
   }
 
     mAdaptor = NULL;
   }
 

-  delete mSurface;
+  mSurface.reset( nullptr );

 }
 
 void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className)
 {
 }
 
 void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className)
 {

-  // create a window render surface
+  // Create a window render surface

   Any surface;
   auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
   Any surface;
   auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();

-  auto windowRenderSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, name, className, mIsTransparent );
-  mSurface = windowRenderSurface.release();
+  mSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, mIsTransparent );
+
+  // Get a window base
+  mWindowBase = mSurface->GetWindowBase();

 
 

-  // create a window base
-  auto windowBaseFactory = Dali::Internal::Adaptor::GetWindowBaseFactory();
-  mWindowBase = windowBaseFactory->CreateWindowBase( this, mSurface );
+  // Connect signals
+  mWindowBase->IconifyChangedSignal().Connect( this, &Window::OnIconifyChanged );
+  mWindowBase->FocusChangedSignal().Connect( this, &Window::OnFocusChanged );
+  mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest );
+  mWindowBase->IndicatorFlickedSignal().Connect( this, &Window::OnIndicatorFlicked );

 
 

-  mWindowBase->Initialize();
+  mSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );

 
   if( !positionSize.IsEmpty() )
   {
 
   if( !positionSize.IsEmpty() )
   {


@@ -141,14 +145,18 @@ void Window::SetAdaptor(Dali::Adaptor& adaptor)
   DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
   mStarted = true;
 
   DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
   mStarted = true;
 

-  // Only create one overlay per window
-  Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
-  Integration::Core& core = adaptorImpl.GetCore();
-  mOverlay = &core.GetSystemOverlay();
+  PositionSize positionSize = mSurface->GetPositionSize();
+  mScene = Dali::Integration::Scene::New( Vector2(positionSize.width, positionSize.height) );
+  mScene.SetSurface( *mSurface.get() );
+
+  unsigned int dpiHorizontal, dpiVertical;
+  dpiHorizontal = dpiVertical = 0;

 
 

-  Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
-  taskList.CreateTask();
+  mSurface->GetDpi( dpiHorizontal, dpiVertical );
+  mScene.SetDpi( Vector2( static_cast<float>( dpiHorizontal ), static_cast<float>( dpiVertical ) ) );

 
 

+  // Create one overlay for the main window only
+  Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);

   mAdaptor = &adaptorImpl;
   mAdaptor->AddObserver( *this );
 
   mAdaptor = &adaptorImpl;
   mAdaptor->AddObserver( *this );
 


@@ -165,16 +173,19 @@ void Window::SetAdaptor(Dali::Adaptor& adaptor)
   {
     mIndicator->SetAdaptor(mAdaptor);
   }
   {
     mIndicator->SetAdaptor(mAdaptor);
   }

+
+  mSurface->SetAdaptor( *mAdaptor );

 }
 
 WindowRenderSurface* Window::GetSurface()
 {
 }
 
 WindowRenderSurface* Window::GetSurface()
 {

-  return mSurface;
+  return mSurface.get();

 }
 
 void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
 {
 }
 
 void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
 {

-  mIndicatorVisible = visibleMode;
+  // TODO: Enable this after indicator implementation based on tizen 5.
+//  mIndicatorVisible = visibleMode;

 
   mWindowBase->ShowIndicator( mIndicatorVisible, mIndicatorOpacityMode );
 
 
   mWindowBase->ShowIndicator( mIndicatorVisible, mIndicatorOpacityMode );
 


@@ -193,7 +204,8 @@ void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode
 
 void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
 {
 
 void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
 {

-  mIndicatorVisible = mode;
+  // TODO: Enable this after indicator implementation based on tizen 5.
+//  mIndicatorVisible = mode;

 }
 
 void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )
 }
 
 void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )


@@ -223,6 +235,44 @@ void Window::Activate()
   mWindowBase->Activate();
 }
 
   mWindowBase->Activate();
 }
 

+void Window::Add( Dali::Actor actor )
+{
+  mScene.Add( actor );
+}
+
+void Window::Remove( Dali::Actor actor )
+{
+  mScene.Remove( actor );
+}
+
+Dali::Layer Window::GetRootLayer() const
+{
+  return mScene.GetRootLayer();
+}
+
+uint32_t Window::GetLayerCount() const
+{
+  return mScene.GetLayerCount();
+}
+
+Dali::Layer Window::GetLayer( uint32_t depth ) const
+{
+  return mScene.GetLayer( depth );
+}
+
+void Window::SetBackgroundColor( Vector4 color )
+{
+  if ( mSurface )
+  {
+    mSurface->SetBackgroundColor( color );
+  }
+}
+
+Vector4 Window::GetBackgroundColor() const
+{
+  return mSurface ? mSurface->GetBackgroundColor() : Vector4();
+}
+

 void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation )
 {
   bool found = false;
 void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation )
 {
   bool found = false;


@@ -297,7 +347,7 @@ Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
 
 Dali::Any Window::GetNativeHandle() const
 {
 
 Dali::Any Window::GetNativeHandle() const
 {

-  return mSurface->GetWindow();
+  return mSurface->GetNativeWindow();

 }
 
 void Window::SetAcceptFocus( bool accept )
 }
 
 void Window::SetAcceptFocus( bool accept )


@@ -472,21 +522,22 @@ void Window::SetSize( Dali::Window::WindowSize size )
     mResizeEnabled = true;
   }
 
     mResizeEnabled = true;
   }
 

-  PositionSize positionSize = mSurface->GetPositionSize();
+  PositionSize oldRect = mSurface->GetPositionSize();

 
 

-  if( positionSize.width != size.GetWidth() || positionSize.height != size.GetHeight() )
-  {
-    positionSize.width = size.GetWidth();
-    positionSize.height = size.GetHeight();
+  mSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) );
+
+  PositionSize newRect = mSurface->GetPositionSize();

 
 

-    mSurface->MoveResize( positionSize );
+  // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
+  if( ( oldRect.width != newRect.width ) || ( oldRect.height != newRect.height ) )
+  {
+    Uint16Pair newSize( newRect.width, newRect.height );

 
 

-    mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+    mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );

 
 

-    // Emit signal
-    mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) );
+    mResizedSignal.Emit( newSize );

 
 

-    mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+    mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );

   }
 }
 
   }
 }
 


@@ -505,15 +556,9 @@ void Window::SetPosition( Dali::Window::WindowPosition position )
     mResizeEnabled = true;
   }
 
     mResizeEnabled = true;
   }
 

-  PositionSize positionSize = mSurface->GetPositionSize();
-
-  if( positionSize.x != position.GetX() || positionSize.y != position.GetY() )
-  {
-    positionSize.x = position.GetX();
-    positionSize.y = position.GetY();
+  PositionSize oldRect = mSurface->GetPositionSize();

 
 

-    mSurface->MoveResize( positionSize );
-  }
+  mSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) );

 }
 
 Dali::Window::WindowPosition Window::GetPosition() const
 }
 
 Dali::Window::WindowPosition Window::GetPosition() const


@@ -523,6 +568,33 @@ Dali::Window::WindowPosition Window::GetPosition() const
   return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
 }
 
   return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
 }
 

+void Window::SetPositionSize( PositionSize positionSize )
+{
+  if( !mResizeEnabled )
+  {
+    AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
+    mResizeEnabled = true;
+  }
+
+  PositionSize oldRect = mSurface->GetPositionSize();
+
+  mSurface->MoveResize( positionSize );
+
+  PositionSize newRect = mSurface->GetPositionSize();
+
+  // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
+  if( ( oldRect.width != newRect.width ) || ( oldRect.height != newRect.height ) )
+  {
+    Uint16Pair newSize( newRect.width, newRect.height );
+
+    mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+
+    mResizedSignal.Emit( newSize );
+
+    mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
+  }
+}
+

 void Window::SetTransparency( bool transparent )
 {
   mSurface->SetTransparency( transparent );
 void Window::SetTransparency( bool transparent )
 {
   mSurface->SetTransparency( transparent );


@@ -552,55 +624,12 @@ void Window::RotationDone( int orientation, int width, int height )
 {
   mSurface->RequestRotation( orientation, width, height );
 
 {
   mSurface->RequestRotation( orientation, width, height );
 

-  mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) );
+  mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( width, height ) );

 
   // Emit signal
   mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
 
 
   // Emit signal
   mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
 

-  mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) );
-}
-
-void Window::OnIconifyChanged( bool iconified )
-{
-  if( iconified )
-  {
-    mIconified = true;
-
-    if( mVisible )
-    {
-      WindowVisibilityObserver* observer( mAdaptor );
-      observer->OnWindowHidden();
-      DALI_LOG_RELEASE_INFO( "Window (%p) Iconified\n", this );
-    }
-  }
-  else
-  {
-    mIconified = false;
-
-    if( mVisible )
-    {
-      WindowVisibilityObserver* observer( mAdaptor );
-      observer->OnWindowShown();
-      DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified\n", this );
-    }
-  }
-}
-
-void Window::OnFocusChanged( bool focusIn )
-{
-  mFocusChangedSignal.Emit( focusIn );
-}
-
-void Window::OnOutputTransformed()
-{
-  PositionSize positionSize = mSurface->GetPositionSize();
-  mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
-  mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
-}
-
-void Window::OnDeleteRequest()
-{
-  mDeleteRequestSignal.Emit();
+  mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( width, height ) );

 }
 
 void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
 }
 
 void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )


@@ -609,11 +638,14 @@ void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
   {
     if( mIndicatorVisible != Dali::Window::INVISIBLE )
     {
   {
     if( mIndicatorVisible != Dali::Window::INVISIBLE )
     {

-      mIndicator = new Indicator( mAdaptor, mIndicatorOrientation, this );
-      mIndicator->SetOpacityMode( mIndicatorOpacityMode );
-      Dali::Actor actor = mIndicator->GetActor();
-      SetIndicatorActorRotation();
-      mOverlay->Add(actor);
+      auto windowFactory = Dali::Internal::Adaptor::GetWindowFactory();
+      mIndicator = windowFactory->CreateIndicator( mAdaptor, mIndicatorOrientation, this );
+      if( mIndicator )
+      {
+        mIndicator->SetOpacityMode( mIndicatorOpacityMode );
+        Dali::Actor actor = mIndicator->GetActor();
+        SetIndicatorActorRotation();
+      }

     }
     // else don't create a hidden indicator
   }
     }
     // else don't create a hidden indicator
   }


@@ -649,7 +681,10 @@ void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation )
   {
     mShowRotatedIndicatorOnClose = true;
     mNextIndicatorOrientation = orientation;
   {
     mShowRotatedIndicatorOnClose = true;
     mNextIndicatorOrientation = orientation;

-    mIndicator->Close(); // May synchronously call IndicatorClosed() callback
+    if( mIndicator )
+    {
+      mIndicator->Close(); // May synchronously call IndicatorClosed() callback
+    }

   }
   else
   {
   }
   else
   {


@@ -662,31 +697,32 @@ void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation )
 void Window::SetIndicatorActorRotation()
 {
   DALI_LOG_TRACE_METHOD( gWindowLogFilter );
 void Window::SetIndicatorActorRotation()
 {
   DALI_LOG_TRACE_METHOD( gWindowLogFilter );

-  DALI_ASSERT_DEBUG( mIndicator != NULL );
-
-  Dali::Actor actor = mIndicator->GetActor();
-  switch( mIndicatorOrientation )
+  if( mIndicator )

   {
   {

-    case Dali::Window::PORTRAIT:
-      actor.SetParentOrigin( ParentOrigin::TOP_CENTER );
-      actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
-      actor.SetOrientation( Degree(0), Vector3::ZAXIS );
-      break;
-    case Dali::Window::PORTRAIT_INVERSE:
-      actor.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
-      actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
-      actor.SetOrientation( Degree(180), Vector3::ZAXIS );
-      break;
-    case Dali::Window::LANDSCAPE:
-      actor.SetParentOrigin( ParentOrigin::CENTER_LEFT );
-      actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
-      actor.SetOrientation( Degree(270), Vector3::ZAXIS );
-      break;
-    case Dali::Window::LANDSCAPE_INVERSE:
-      actor.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
-      actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
-      actor.SetOrientation( Degree(90), Vector3::ZAXIS );
-      break;
+    Dali::Actor actor = mIndicator->GetActor();
+    switch( mIndicatorOrientation )
+    {
+      case Dali::Window::PORTRAIT:
+        actor.SetParentOrigin( ParentOrigin::TOP_CENTER );
+        actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
+        actor.SetOrientation( Degree(0), Vector3::ZAXIS );
+        break;
+      case Dali::Window::PORTRAIT_INVERSE:
+        actor.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
+        actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
+        actor.SetOrientation( Degree(180), Vector3::ZAXIS );
+        break;
+      case Dali::Window::LANDSCAPE:
+        actor.SetParentOrigin( ParentOrigin::CENTER_LEFT );
+        actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
+        actor.SetOrientation( Degree(270), Vector3::ZAXIS );
+        break;
+      case Dali::Window::LANDSCAPE_INVERSE:
+        actor.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
+        actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
+        actor.SetOrientation( Degree(90), Vector3::ZAXIS );
+        break;
+    }

   }
 }
 
   }
 }
 


@@ -695,7 +731,58 @@ void Window::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientatio
   mWindowBase->SetIndicatorProperties( isShow, lastOrientation );
 }
 
   mWindowBase->SetIndicatorProperties( isShow, lastOrientation );
 }
 

-void Window::IndicatorTypeChanged(Indicator::Type type)
+void Window::OnIconifyChanged( bool iconified )
+{
+  if( iconified )
+  {
+    mIconified = true;
+
+    if( mVisible )
+    {
+      WindowVisibilityObserver* observer( mAdaptor );
+      observer->OnWindowHidden();
+      DALI_LOG_RELEASE_INFO( "Window (%p) Iconified\n", this );
+    }
+  }
+  else
+  {
+    mIconified = false;
+
+    if( mVisible )
+    {
+      WindowVisibilityObserver* observer( mAdaptor );
+      observer->OnWindowShown();
+      DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified\n", this );
+    }
+  }
+}
+
+void Window::OnFocusChanged( bool focusIn )
+{
+  mFocusChangedSignal.Emit( focusIn );
+}
+
+void Window::OnOutputTransformed()
+{
+  PositionSize positionSize = mSurface->GetPositionSize();
+  mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+  mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+}
+
+void Window::OnDeleteRequest()
+{
+  mDeleteRequestSignal.Emit();
+}
+
+void Window::OnIndicatorFlicked()
+{
+  if( mIndicator )
+  {
+    mIndicator->Flicked();
+  }
+}
+
+void Window::IndicatorTypeChanged( IndicatorInterface::Type type )

 {
   mWindowBase->IndicatorTypeChanged( type );
 }
 {
   mWindowBase->IndicatorTypeChanged( type );
 }


@@ -707,7 +794,10 @@ void Window::IndicatorClosed( IndicatorInterface* indicator )
   if( mShowRotatedIndicatorOnClose )
   {
     Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation;
   if( mShowRotatedIndicatorOnClose )
   {
     Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation;

-    mIndicator->Open( mNextIndicatorOrientation );
+    if( mIndicator )
+    {
+      mIndicator->Open( mNextIndicatorOrientation );
+    }

     mIndicatorOrientation = mNextIndicatorOrientation;
     SetIndicatorActorRotation();
     DoShowIndicator( currentOrientation );
     mIndicatorOrientation = mNextIndicatorOrientation;
     SetIndicatorActorRotation();
     DoShowIndicator( currentOrientation );


@@ -746,8 +836,7 @@ void Window::OnStop()
     mIndicator->Close();
   }
 
     mIndicator->Close();
   }
 

-  delete mIndicator;
-  mIndicator = NULL;
+  mIndicator.release();

 }
 
 void Window::OnDestroy()
 }
 
 void Window::OnDestroy()


@@ -755,6 +844,11 @@ void Window::OnDestroy()
   mAdaptor = NULL;
 }
 
   mAdaptor = NULL;
 }
 

+uint32_t Window::GetId() const
+{
+  return mId;
+}
+

 } // Adaptor
 
 } // Internal
 } // Adaptor
 
 } // Internal