Revert "[4.0] update tizen_policy version and add functions for tizen_policy_listener"

[platform/core/uifw/dali-adaptor.git] / adaptors / ecore / wayland / window-impl-ecore-wl.cpp

diff --git a/adaptors/ecore/wayland/window-impl-ecore-wl.cpp b/adaptors/ecore/wayland/window-impl-ecore-wl.cpp
index 6f9b2a7..d4265b4 100644 (file)
--- a/adaptors/ecore/wayland/window-impl-ecore-wl.cpp
+++ b/adaptors/ecore/wayland/window-impl-ecore-wl.cpp
@@ -77,9 +77,9 @@ struct Window::EventHandler
     mNotificationLevel( -1 ),
     mNotificationChangeState( 0 ),
     mNotificationLevelChangeDone( true ),
-    mScreenMode( 0 ),
-    mScreenModeChangeState( 0 ),
-    mScreenModeChangeDone( true ),
+    mScreenOffMode( 0 ),
+    mScreenOffModeChangeState( 0 ),
+    mScreenOffModeChangeDone( true ),
     mBrightness( 0 ),
     mBrightnessChangeState( 0 ),
     mBrightnessChangeDone( true )
@@ -95,7 +95,6 @@ struct Window::EventHandler
     if( mWindow->mEcoreEventHander )
     {
       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) );
-      mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, EcoreEventWindowVisibilityChanged, this ) );
       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this ) );
       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this ) );
       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this) );
@@ -156,41 +155,20 @@ struct Window::EventHandler
       {
         if( iconifyChangedEvent->iconified == EINA_TRUE )
         {
-          observer->OnWindowHidden();
+          handler->mWindow->mIconified = true;
+          if( handler->mWindow->mVisible )
+          {
+            observer->OnWindowHidden();
+          }
           DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Iconfied\n", handler->mEcoreWindow );
         }
         else
         {
-          observer->OnWindowShown();
-          DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow );
-        }
-        handled = ECORE_CALLBACK_DONE;
-      }
-    }
-
-    return handled;
-  }
-
-  /// Called when the window visibility is changed.
-  static Eina_Bool EcoreEventWindowVisibilityChanged( void* data, int type, void* event )
-  {
-    Ecore_Wl_Event_Window_Visibility_Change* visibilityChangedEvent( static_cast< Ecore_Wl_Event_Window_Visibility_Change* >( event ) );
-    EventHandler* handler( static_cast< EventHandler* >( data ) );
-    Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
-
-    if ( handler && handler->mWindow )
-    {
-      WindowVisibilityObserver* observer( handler->mWindow->mAdaptor );
-      if ( observer && ( visibilityChangedEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( handler->mEcoreWindow ) ) ) )
-      {
-        if( visibilityChangedEvent->fully_obscured == 1 )
-        {
-          observer->OnWindowHidden();
-          DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) full obscured\n", handler->mEcoreWindow );
-        }
-        else
-        {
-          observer->OnWindowShown();
+          handler->mWindow->mIconified = false;
+          if( handler->mWindow->mVisible )
+          {
+            observer->OnWindowShown();
+          }
           DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow );
         }
         handled = ECORE_CALLBACK_DONE;
@@ -240,8 +218,17 @@ struct Window::EventHandler
 
     if ( handler && handler->mWindow && transformEvent->output == ecore_wl_window_output_find( handler->mEcoreWindow ) )
     {
+      DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) EcoreEventOutputTransform\n", handler->mEcoreWindow );
+
       ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) );
-      wlSurface->OutputTransformed();
+      if( wlSurface )
+      {
+        wlSurface->OutputTransformed();
+
+        PositionSize positionSize = wlSurface->GetPositionSize();
+        handler->mWindow->mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+        handler->mWindow->mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+      }
     }
 
     return ECORE_CALLBACK_PASS_ON;
@@ -255,8 +242,17 @@ struct Window::EventHandler
 
     if ( handler && handler->mWindow && ignoreTransformEvent->win == handler->mEcoreWindow )
     {
+      DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) EcoreEventIgnoreOutputTransform\n", handler->mEcoreWindow );
+
       ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) );
-      wlSurface->OutputTransformed();
+      if( wlSurface )
+      {
+        wlSurface->OutputTransformed();
+
+        PositionSize positionSize = wlSurface->GetPositionSize();
+        handler->mWindow->mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+        handler->mWindow->mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+      }
     }
 
     return ECORE_CALLBACK_PASS_ON;
@@ -316,9 +312,9 @@ struct Window::EventHandler
   {
     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 
-    eventHandler->mScreenMode = mode;
-    eventHandler->mScreenModeChangeState = state;
-    eventHandler->mScreenModeChangeDone = true;
+    eventHandler->mScreenOffMode = mode;
+    eventHandler->mScreenOffModeChangeState = state;
+    eventHandler->mScreenOffModeChangeDone = true;
 
     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
   }
@@ -372,9 +368,9 @@ struct Window::EventHandler
   uint32_t mNotificationChangeState;
   bool mNotificationLevelChangeDone;
 
-  int mScreenMode;
-  uint32_t mScreenModeChangeState;
-  bool mScreenModeChangeDone;
+  int mScreenOffMode;
+  uint32_t mScreenOffModeChangeState;
+  bool mScreenOffModeChangeDone;
 
   int mBrightness;
   uint32_t mBrightnessChangeState;
@@ -509,6 +505,7 @@ Window::Window()
   mEcoreEventHander( true ),
   mIsFocusAcceptable( true ),
   mVisible( true ),
+  mIconified( false ),
   mOpaqueState( false ),
   mResizeEnabled( false ),
   mIndicator( NULL ),
@@ -517,7 +514,7 @@ Window::Window()
   mIndicatorOpacityMode( Dali::Window::OPAQUE ),
   mOverlay( NULL ),
   mAdaptor( NULL ),
-  mType( Dali::DevelWindow::NORMAL ),
+  mType( Dali::Window::NORMAL ),
   mEventHandler( NULL ),
   mPreferredOrientation( Dali::Window::PORTRAIT ),
   mSupportedAuxiliaryHints(),
@@ -742,7 +739,8 @@ void Window::SetIndicatorActorRotation()
 
 void Window::Raise()
 {
-  ecore_wl_window_raise( mEventHandler->mEcoreWindow );
+  // Use ecore_wl_window_activate to prevent the window shown without rendering
+  ecore_wl_window_activate( mEventHandler->mEcoreWindow );
 }
 
 void Window::Lower()
@@ -876,7 +874,7 @@ void Window::SetAcceptFocus( bool accept )
   ecore_wl_window_focus_skip_set( mEventHandler->mEcoreWindow, !accept );
 }
 
-bool Window::IsFocusAcceptable()
+bool Window::IsFocusAcceptable() const
 {
   return mIsFocusAcceptable;
 }
@@ -886,10 +884,13 @@ void Window::Show()
   mVisible = true;
   ecore_wl_window_show( mEventHandler->mEcoreWindow );
 
-  // Need an update request
-  if( mAdaptor )
+  if( !mIconified )
   {
-    mAdaptor->RequestUpdateOnce();
+    if( mAdaptor )
+    {
+      WindowVisibilityObserver* observer( mAdaptor );
+      observer->OnWindowShown();
+    }
   }
 }
 
@@ -897,6 +898,15 @@ void Window::Hide()
 {
   mVisible = false;
   ecore_wl_window_hide( mEventHandler->mEcoreWindow );
+
+  if( !mIconified )
+  {
+    if( mAdaptor )
+    {
+      WindowVisibilityObserver* observer( mAdaptor );
+      observer->OnWindowHidden();
+    }
+  }
 }
 
 bool Window::IsVisible() const
@@ -907,22 +917,30 @@ bool Window::IsVisible() const
 void Window::RotationDone( int orientation, int width, int height )
 {
   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
-  wlSurface->RequestRotation( orientation, width, height );
+  if( wlSurface )
+  {
+    wlSurface->RequestRotation( orientation, width, height );
+  }
 
-  mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( width, height ) );
+  mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) );
 
   // Emit signal
-  mResizedSignal.Emit( Dali::DevelWindow::WindowSize( width, height ) );
+  mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
 
-  mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( width, height ) );
+  mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) );
 }
 
-unsigned int Window::GetSupportedAuxiliaryHintCount()
+void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
+{
+  mIndicatorVisible = mode;
+}
+
+unsigned int Window::GetSupportedAuxiliaryHintCount() const
 {
   return mSupportedAuxiliaryHints.size();
 }
 
-std::string Window::GetSupportedAuxiliaryHint( unsigned int index )
+std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const
 {
   if( index >= GetSupportedAuxiliaryHintCount() )
   {
@@ -1048,7 +1066,7 @@ void Window::SetInputRegion( const Rect< int >& inputRegion )
   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetInputRegion: x = %d, y = %d, w = %d, h = %d\n", inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
 }
 
-void Window::SetType( Dali::DevelWindow::Type type )
+void Window::SetType( Dali::Window::Type type )
 {
   Ecore_Wl_Window_Type windowType;
 
@@ -1056,22 +1074,22 @@ void Window::SetType( Dali::DevelWindow::Type type )
   {
     switch( type )
     {
-      case Dali::DevelWindow::NORMAL:
+      case Dali::Window::NORMAL:
       {
         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
         break;
       }
-      case Dali::DevelWindow::NOTIFICATION:
+      case Dali::Window::NOTIFICATION:
       {
         windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
         break;
       }
-      case Dali::DevelWindow::UTILITY:
+      case Dali::Window::UTILITY:
       {
         windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
         break;
       }
-      case Dali::DevelWindow::DIALOG:
+      case Dali::Window::DIALOG:
       {
         windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
         break;
@@ -1089,14 +1107,14 @@ void Window::SetType( Dali::DevelWindow::Type type )
   mType = type;
 }
 
-Dali::DevelWindow::Type Window::GetType() const
+Dali::Window::Type Window::GetType() const
 {
   return mType;
 }
 
-bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level )
+bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
 {
-  if( mType != Dali::DevelWindow::NOTIFICATION )
+  if( mType != Dali::Window::NOTIFICATION )
   {
     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType );
     return false;
@@ -1111,27 +1129,27 @@ bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type le
 
   switch( level )
   {
-    case Dali::DevelWindow::NotificationLevel::NONE:
+    case Dali::Window::NotificationLevel::NONE:
     {
       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
       break;
     }
-    case Dali::DevelWindow::NotificationLevel::BASE:
+    case Dali::Window::NotificationLevel::BASE:
     {
       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
       break;
     }
-    case Dali::DevelWindow::NotificationLevel::MEDIUM:
+    case Dali::Window::NotificationLevel::MEDIUM:
     {
       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
       break;
     }
-    case Dali::DevelWindow::NotificationLevel::HIGH:
+    case Dali::Window::NotificationLevel::HIGH:
     {
       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
       break;
     }
-    case Dali::DevelWindow::NotificationLevel::TOP:
+    case Dali::Window::NotificationLevel::TOP:
     {
       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
       break;
@@ -1174,12 +1192,12 @@ bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type le
   return true;
 }
 
-Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel()
+Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const
 {
-  if( mType != Dali::DevelWindow::NOTIFICATION )
+  if( mType != Dali::Window::NOTIFICATION )
   {
     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType );
-    return Dali::DevelWindow::NotificationLevel::NONE;
+    return Dali::Window::NotificationLevel::NONE;
   }
 
   while( !mEventHandler->mTizenPolicy )
@@ -1199,42 +1217,42 @@ Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel()
   if( !mEventHandler->mNotificationLevelChangeDone )
   {
     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState );
-    return Dali::DevelWindow::NotificationLevel::NONE;
+    return Dali::Window::NotificationLevel::NONE;
   }
 
-  Dali::DevelWindow::NotificationLevel::Type level;
+  Dali::Window::NotificationLevel::Type level;
 
   switch( mEventHandler->mNotificationLevel )
   {
     case TIZEN_POLICY_LEVEL_NONE:
     {
-      level = Dali::DevelWindow::NotificationLevel::NONE;
+      level = Dali::Window::NotificationLevel::NONE;
       break;
     }
     case TIZEN_POLICY_LEVEL_DEFAULT:
     {
-      level = Dali::DevelWindow::NotificationLevel::BASE;
+      level = Dali::Window::NotificationLevel::BASE;
       break;
     }
     case TIZEN_POLICY_LEVEL_MEDIUM:
     {
-      level = Dali::DevelWindow::NotificationLevel::MEDIUM;
+      level = Dali::Window::NotificationLevel::MEDIUM;
       break;
     }
     case TIZEN_POLICY_LEVEL_HIGH:
     {
-      level = Dali::DevelWindow::NotificationLevel::HIGH;
+      level = Dali::Window::NotificationLevel::HIGH;
       break;
     }
     case TIZEN_POLICY_LEVEL_TOP:
     {
-      level = Dali::DevelWindow::NotificationLevel::TOP;
+      level = Dali::Window::NotificationLevel::TOP;
       break;
     }
     default:
     {
       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel );
-      level = Dali::DevelWindow::NotificationLevel::NONE;
+      level = Dali::Window::NotificationLevel::NONE;
       break;
     }
   }
@@ -1258,31 +1276,31 @@ void Window::SetOpaqueState( bool opaque )
   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque );
 }
 
-bool Window::IsOpaqueState()
+bool Window::IsOpaqueState() const
 {
   return mOpaqueState;
 }
 
-bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode )
+bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
 {
   while( !mEventHandler->mTizenPolicy )
   {
     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
   }
 
-  mEventHandler->mScreenModeChangeDone = false;
-  mEventHandler->mScreenModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
+  mEventHandler->mScreenOffModeChangeDone = false;
+  mEventHandler->mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
 
   unsigned int mode = 0;
 
-  switch( screenMode )
+  switch( screenOffMode )
   {
-    case Dali::DevelWindow::ScreenMode::DEFAULT:
+    case Dali::Window::ScreenOffMode::TIMEOUT:
     {
       mode = 0;
       break;
     }
-    case Dali::DevelWindow::ScreenMode::ALWAYS_ON:
+    case Dali::Window::ScreenOffMode::NEVER:
     {
       mode = 1;
       break;
@@ -1293,30 +1311,30 @@ bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode )
 
   int count = 0;
 
-  while( !mEventHandler->mScreenModeChangeDone && count < 3 )
+  while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
   {
     ecore_wl_flush();
     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
     count++;
   }
 
-  if( !mEventHandler->mScreenModeChangeDone )
+  if( !mEventHandler->mScreenOffModeChangeDone )
   {
-    DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode change is failed [%d, %d]\n", screenMode, mEventHandler->mScreenModeChangeState );
+    DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mEventHandler->mScreenOffModeChangeState );
     return false;
   }
-  else if( mEventHandler->mScreenModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
+  else if( mEventHandler->mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
   {
-    DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Permission denied! [%d]\n", screenMode );
+    DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
     return false;
   }
 
-  DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode is changed [%d]\n", mEventHandler->mScreenMode );
+  DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode is changed [%d]\n", mEventHandler->mScreenOffMode );
 
   return true;
 }
 
-Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode()
+Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const
 {
   while( !mEventHandler->mTizenPolicy )
   {
@@ -1325,36 +1343,36 @@ Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode()
 
   int count = 0;
 
-  while( !mEventHandler->mScreenModeChangeDone && count < 3 )
+  while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
   {
     ecore_wl_flush();
     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
     count++;
   }
 
-  if( !mEventHandler->mScreenModeChangeDone )
+  if( !mEventHandler->mScreenOffModeChangeDone )
   {
-    DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: Error! [%d]\n", mEventHandler->mScreenModeChangeState );
-    return Dali::DevelWindow::ScreenMode::DEFAULT;
+    DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: Error! [%d]\n", mEventHandler->mScreenOffModeChangeState );
+    return Dali::Window::ScreenOffMode::TIMEOUT;
   }
 
-  Dali::DevelWindow::ScreenMode::Type screenMode = Dali::DevelWindow::ScreenMode::DEFAULT;
+  Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
 
-  switch( mEventHandler->mScreenMode )
+  switch( mEventHandler->mScreenOffMode )
   {
     case 0:
     {
-      screenMode = Dali::DevelWindow::ScreenMode::DEFAULT;
+      screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
       break;
     }
     case 1:
     {
-      screenMode = Dali::DevelWindow::ScreenMode::ALWAYS_ON;
+      screenMode = Dali::Window::ScreenOffMode::NEVER;
       break;
     }
   }
 
-  DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: screen mode [%d]\n", mEventHandler->mScreenMode );
+  DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: screen mode [%d]\n", mEventHandler->mScreenOffMode );
 
   return screenMode;
 }
@@ -1402,7 +1420,7 @@ bool Window::SetBrightness( int brightness )
   return true;
 }
 
-int Window::GetBrightness()
+int Window::GetBrightness() const
 {
   while( !mEventHandler->mTizenDisplayPolicy )
   {
@@ -1429,7 +1447,7 @@ int Window::GetBrightness()
   return mEventHandler->mBrightness;
 }
 
-void Window::SetSize( Dali::DevelWindow::WindowSize size )
+void Window::SetSize( Dali::Window::WindowSize size )
 {
   if( !mResizeEnabled )
   {
@@ -1446,23 +1464,23 @@ void Window::SetSize( Dali::DevelWindow::WindowSize size )
 
     mSurface->MoveResize( positionSize );
 
-    mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+    mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
 
     // Emit signal
-    mResizedSignal.Emit( Dali::DevelWindow::WindowSize( positionSize.width, positionSize.height ) );
+    mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) );
 
-    mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+    mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
   }
 }
 
-Dali::DevelWindow::WindowSize Window::GetSize()
+Dali::Window::WindowSize Window::GetSize() const
 {
   PositionSize positionSize = mSurface->GetPositionSize();
 
-  return Dali::DevelWindow::WindowSize( positionSize.width, positionSize.height );
+  return Dali::Window::WindowSize( positionSize.width, positionSize.height );
 }
 
-void Window::SetPosition( Dali::DevelWindow::WindowPosition position )
+void Window::SetPosition( Dali::Window::WindowPosition position )
 {
   if( !mResizeEnabled )
   {
@@ -1481,17 +1499,20 @@ void Window::SetPosition( Dali::DevelWindow::WindowPosition position )
   }
 }
 
-Dali::DevelWindow::WindowPosition Window::GetPosition()
+Dali::Window::WindowPosition Window::GetPosition() const
 {
   PositionSize positionSize = mSurface->GetPositionSize();
 
-  return Dali::DevelWindow::WindowPosition( positionSize.x, positionSize.y );
+  return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
 }
 
 void Window::SetTransparency( bool transparent )
 {
   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
-  wlSurface->SetTransparency( transparent );
+  if( wlSurface )
+  {
+    wlSurface->SetTransparency( transparent );
+  }
 }
 
 } // Adaptor