X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fwindow-system%2Ftizen-wayland%2Fecore-wl2%2Fwindow-base-ecore-wl2.cpp;h=21a8b6411263b2cc634da5a5133131895c7202cb;hb=f630a2249ff1cc1b39faf6dba7355ba2ac8a9898;hp=c95ba100330b2e041d73c3fa521b9334d06c4771;hpb=3b0387df2e30a60ba820bd77f2fc89a2a8bc579d;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git

diff --git a/dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.cpp b/dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.cpp
index c95ba10..21a8b64 100755
--- a/dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.cpp
+++ b/dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.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.
@@ -63,6 +63,13 @@ const char* BUS = "org.enlightenment.wm-screen-reader";
 const char* INTERFACE = "org.tizen.GestureNavigation";
 const char* PATH = "/org/tizen/GestureNavigation";
 
+struct KeyCodeMap
+{
+  xkb_keysym_t keySym;
+  xkb_keycode_t keyCode;
+  bool isKeyCode;
+};
+
 /**
  * Get the device name from the provided ecore key event
  */
@@ -180,7 +187,6 @@ void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subcl
       deviceSubclass = Device::Subclass::TRACKBALL;
       break;
     }
-#ifdef OVER_TIZEN_VERSION_4
     case ECORE_DEVICE_SUBCLASS_REMOCON:
     {
       deviceSubclass = Device::Subclass::REMOCON;
@@ -191,7 +197,6 @@ void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subcl
       deviceSubclass = Device::Subclass::VIRTUAL_KEYBOARD;
       break;
     }
-#endif
     default:
     {
       deviceSubclass = Device::Subclass::NONE;
@@ -200,6 +205,31 @@ void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subcl
   }
 }
 
+
+void FindKeyCode( struct xkb_keymap* keyMap, xkb_keycode_t key, void* data )
+{
+  KeyCodeMap* foundKeyCode = static_cast< KeyCodeMap* >( data );
+  if( foundKeyCode->isKeyCode )
+  {
+    return;
+  }
+
+  xkb_keysym_t keySym = foundKeyCode->keySym;
+  int nsyms = 0;
+  const xkb_keysym_t* symsOut = NULL;
+
+  nsyms = xkb_keymap_key_get_syms_by_level( keyMap, key, 0, 0, &symsOut );
+
+  if( nsyms && symsOut )
+  {
+    if( *symsOut == keySym )
+    {
+      foundKeyCode->keyCode = key;
+      foundKeyCode->isKeyCode = true;
+    }
+  }
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Window Callbacks
 /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -272,11 +302,25 @@ static Eina_Bool EcoreEventRotate( void* data, int type, void* event )
   WindowBaseEcoreWl2* windowBase = static_cast< WindowBaseEcoreWl2* >( data );
   if( windowBase )
   {
+    DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::EcoreEventRotate\n" );
     windowBase->OnRotation( data, type, event );
   }
   return ECORE_CALLBACK_PASS_ON;
 }
 
+/**
+ * Called when configure event is recevied.
+ */
+static Eina_Bool EcoreEventConfigure( void* data, int type, void* event )
+{
+  WindowBaseEcoreWl2* windowBase = static_cast< WindowBaseEcoreWl2* >( data );
+  if( windowBase )
+  {
+    windowBase->OnConfiguration( data, type, event );
+  }
+  return ECORE_CALLBACK_PASS_ON;
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Touch Callbacks
 /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -421,23 +465,59 @@ static Eina_Bool EcoreEventDataReceive( void* data, int type, void* event )
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
-// Indicator Callbacks
+// Effect Start/End Callbacks
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
-#if defined (DALI_PROFILE_MOBILE)
-  /**
-   * Called when the Ecore indicator event is received.
-   */
-  static Eina_Bool EcoreEventIndicator( void* data, int type, void* event )
+/**
+ * Called when transition animation of the window's shown/hidden is started by window manager.
+ */
+static Eina_Bool EcoreEventEffectStart(void *data, int type, void *event)
+{
+  WindowBaseEcoreWl2* windowBase = static_cast< WindowBaseEcoreWl2* >( data );
+  Ecore_Wl2_Event_Effect_Start *effectStart = static_cast<Ecore_Wl2_Event_Effect_Start*>( event );
+  DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventEffectStart, effect type[ %d ]\n", effectStart->type );
+  if( windowBase )
+  {
+    if( effectStart->type < 3 ) // only under restack
+    {
+      windowBase->OnTransitionEffectEvent( DevelWindow::EffectState::START, static_cast<DevelWindow::EffectType>( effectStart->type ) );
+    }
+  }
+  return ECORE_CALLBACK_PASS_ON;
+}
+
+/**
+ * Called when transition animation of the window's shown/hidden is ended by window manager.
+ */
+static Eina_Bool EcoreEventEffectEnd(void *data, int type, void *event)
+{
+  Ecore_Wl2_Event_Effect_Start *effectEnd = static_cast<Ecore_Wl2_Event_Effect_Start*>( event );
+  WindowBaseEcoreWl2* windowBase = static_cast< WindowBaseEcoreWl2* >( data );
+  DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventEffectEnd, effect type[ %d ]\n", effectEnd->type );
+  if( windowBase )
   {
-    WindowBaseEcoreWl2* windowBase = static_cast< WindowBaseEcoreWl2* >( data );
-    if( windowBase )
+    if( effectEnd->type < 3 ) // only under restack
     {
-      windowBase->OnIndicatorFlicked( data, type, event );
+      windowBase->OnTransitionEffectEvent( DevelWindow::EffectState::END, static_cast<DevelWindow::EffectType>( effectEnd->type ) );
     }
-    return ECORE_CALLBACK_PASS_ON;
   }
-#endif // DALI_PROFILE_MOBILE
+  return ECORE_CALLBACK_PASS_ON;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Keymap Changed Callbacks
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static Eina_Bool EcoreEventSeatKeymapChanged(void *data, int type, void *event)
+{
+  WindowBaseEcoreWl2* windowBase = static_cast< WindowBaseEcoreWl2* >( data );
+  if( windowBase )
+  {
+    windowBase->KeymapChanged( data, type, event );
+  }
+
+  return ECORE_CALLBACK_RENEW;
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Font Callbacks
@@ -596,6 +676,7 @@ WindowBaseEcoreWl2::WindowBaseEcoreWl2( Dali::PositionSize positionSize, Any sur
   mEventQueue( NULL ),
   mTizenPolicy( NULL ),
   mTizenDisplayPolicy( NULL ),
+  mKeyMap( NULL ),
   mSupportedAuxiliaryHints(),
   mAuxiliaryHints(),
   mNotificationLevel( -1 ),
@@ -689,6 +770,9 @@ void WindowBaseEcoreWl2::Initialize( PositionSize positionSize, Any surface, boo
   // Register Rotate event
   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_ROTATE,               EcoreEventRotate,                    this ) );
 
+  // Register Configure event
+  mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_CONFIGURE,            EcoreEventConfigure,                 this ) );
+
   // Register Touch events
   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,               EcoreEventMouseButtonDown,           this ) );
   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,                 EcoreEventMouseButtonUp,             this ) );
@@ -709,10 +793,9 @@ void WindowBaseEcoreWl2::Initialize( PositionSize positionSize, Any surface, boo
   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_DATA_SOURCE_SEND,            EcoreEventDataSend,                  this ) );
   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SELECTION_DATA_READY,        EcoreEventDataReceive,               this ) );
 
-#if defined (DALI_PROFILE_MOBILE)
-  // Register indicator event
-  mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_INDICATOR_FLICK,             EcoreEventIndicator,                 this ) );
-#endif
+  // Register Effect Start/End event
+  mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_EFFECT_START,                EcoreEventEffectStart,               this ) );
+  mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_EFFECT_END,                  EcoreEventEffectEnd,                 this ) );
 
   // Register Vconf notify - font name and size
   vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this );
@@ -741,6 +824,15 @@ void WindowBaseEcoreWl2::Initialize( PositionSize positionSize, Any surface, boo
     }
   }
 
+  Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get( display );
+
+  if( ecoreWlInput )
+  {
+    mKeyMap = ecore_wl2_input_keymap_get( ecoreWlInput );
+
+    mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this ) );
+  }
+
   // get auxiliary hint
   Eina_List* hints = ecore_wl2_window_aux_hints_supported_get( mEcoreWindow );
   if( hints )
@@ -840,7 +932,7 @@ void WindowBaseEcoreWl2::OnRotation( void* data, int type, void* event )
 
   if( ev->win == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
   {
-    DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::OnRotation\n" );
+    DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h );
 
     RotationEvent rotationEvent;
     rotationEvent.angle = ev->angle;
@@ -861,6 +953,18 @@ void WindowBaseEcoreWl2::OnRotation( void* data, int type, void* event )
   }
 }
 
+void WindowBaseEcoreWl2::OnConfiguration( void* data, int type, void* event )
+{
+  Ecore_Wl2_Event_Window_Configure* ev( static_cast< Ecore_Wl2_Event_Window_Configure* >( event ) );
+
+  if( ev->win == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
+  {
+    // Note: To comply with the wayland protocol, Dali should make an ack_configure
+    // by calling ecore_wl2_window_commit
+    ecore_wl2_window_commit(mEcoreWindow, EINA_FALSE);
+  }
+}
+
 void WindowBaseEcoreWl2::OnMouseButtonDown( void* data, int type, void* event )
 {
   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
@@ -994,7 +1098,7 @@ void WindowBaseEcoreWl2::OnDetentRotation( void* data, int type, void* event )
   int direction = ( detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE ) ? 1 : -1;
   int timeStamp = detentEvent->timestamp;
 
-  WheelEvent wheelEvent( WheelEvent::CUSTOM_WHEEL, 0, 0, Vector2( 0.0f, 0.0f ), direction, timeStamp );
+  WheelEvent wheelEvent( WheelEvent::CUSTOM_WHEEL, direction, 0, Vector2( 0.0f, 0.0f ), 0, timeStamp );
 
   mWheelEventSignal.Emit( wheelEvent );
 }
@@ -1008,6 +1112,7 @@ void WindowBaseEcoreWl2::OnKeyDown( void* data, int type, void* event )
     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyDown\n" );
 
     std::string keyName( keyEvent->keyname );
+    std::string logicalKey( "" );
     std::string keyString( "" );
     std::string compose( "" );
 
@@ -1017,7 +1122,21 @@ void WindowBaseEcoreWl2::OnKeyDown( void* data, int type, void* event )
       compose = keyEvent->compose;
     }
 
-    int keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
+    // Ensure key symbol is not NULL as keys like SHIFT have a null string.
+    if( keyEvent->key )
+    {
+      logicalKey = keyEvent->key;
+    }
+
+    int keyCode = 0;
+    GetKeyCode( keyName, keyCode ); // Get key code dynamically.
+
+    if( keyCode == 0 )
+    {
+      // Get a specific key code from dali key look up table.
+      keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
+    }
+
     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
     int modifier( keyEvent->modifiers );
     unsigned long time = keyEvent->timestamp;
@@ -1040,7 +1159,7 @@ void WindowBaseEcoreWl2::OnKeyDown( void* data, int type, void* event )
     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
 
-    Integration::KeyEvent keyEvent( keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, compose, deviceName, deviceClass, deviceSubclass );
+    Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, compose, deviceName, deviceClass, deviceSubclass );
 
      mKeyEventSignal.Emit( keyEvent );
   }
@@ -1054,7 +1173,17 @@ void WindowBaseEcoreWl2::OnKeyUp( void* data, int type, void* event )
   {
     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyUp\n" );
 
+#if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
+    // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
+    if( keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL )
+    {
+      DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp: This event flag indicates the event is canceled. \n" );
+      return;
+    }
+#endif // Since ecore 1.23 version
+
     std::string keyName( keyEvent->keyname );
+    std::string logicalKey( "" );
     std::string keyString( "" );
     std::string compose( "" );
 
@@ -1064,7 +1193,21 @@ void WindowBaseEcoreWl2::OnKeyUp( void* data, int type, void* event )
       compose = keyEvent->compose;
     }
 
-    int keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
+    // Ensure key symbol is not NULL as keys like SHIFT have a null string.
+    if( keyEvent->key )
+    {
+      logicalKey = keyEvent->key;
+    }
+
+    int keyCode = 0;
+    GetKeyCode( keyName, keyCode ); // Get key code dynamically.
+
+    if( keyCode == 0 )
+    {
+      // Get a specific key code from dali key look up table.
+      keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
+    }
+
     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
     int modifier( keyEvent->modifiers );
     unsigned long time = keyEvent->timestamp;
@@ -1087,7 +1230,7 @@ void WindowBaseEcoreWl2::OnKeyUp( void* data, int type, void* event )
     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
 
-    Integration::KeyEvent keyEvent( keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, compose, deviceName, deviceClass, deviceSubclass );
+    Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, compose, deviceName, deviceClass, deviceSubclass );
 
      mKeyEventSignal.Emit( keyEvent );
   }
@@ -1103,11 +1246,6 @@ void WindowBaseEcoreWl2::OnDataReceive( void* data, int type, void* event )
   mSelectionDataReceivedSignal.Emit( event  );
 }
 
-void WindowBaseEcoreWl2::OnIndicatorFlicked( void* data, int type, void* event )
-{
-  mIndicatorFlickedSignal.Emit();
-}
-
 void WindowBaseEcoreWl2::OnFontNameChanged()
 {
   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_CHANGE );
@@ -1133,6 +1271,22 @@ void WindowBaseEcoreWl2::OnEcoreElDBusAccessibilityNotification( void* context,
 #endif
 }
 
+void WindowBaseEcoreWl2::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type )
+{
+  mTransitionEffectEventSignal.Emit( state, type );
+}
+
+void WindowBaseEcoreWl2::KeymapChanged(void *data, int type, void *event)
+{
+  Ecore_Wl2_Event_Seat_Keymap_Changed *changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>( event );
+  DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id );
+  Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get( changed->display );
+  if( ecoreWlInput )
+  {
+    mKeyMap = ecore_wl2_input_keymap_get( ecoreWlInput );
+  }
+}
+
 void WindowBaseEcoreWl2::RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
 {
   if( strcmp( interface, tizen_policy_interface.name ) == 0 )
@@ -1198,6 +1352,24 @@ void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone( void* data, struct t
   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
 }
 
+void WindowBaseEcoreWl2::GetKeyCode( std::string keyName, int32_t& keyCode )
+{
+  xkb_keysym_t sym = XKB_KEY_NoSymbol;
+  KeyCodeMap foundKeyCode;
+
+  sym = xkb_keysym_from_name( keyName.c_str(), XKB_KEYSYM_NO_FLAGS );
+  if( sym == XKB_KEY_NoSymbol )
+  {
+    DALI_LOG_ERROR( "Failed to get keysym in WindowBaseEcoreWl2\n" );
+    return;
+  }
+
+  foundKeyCode.keySym = sym;
+  foundKeyCode.isKeyCode = false;
+  xkb_keymap_key_for_each( mKeyMap, FindKeyCode, &foundKeyCode );
+  keyCode = static_cast< int32_t >( foundKeyCode.keyCode );
+}
+
 Any WindowBaseEcoreWl2::GetNativeWindow()
 {
   return mEcoreWindow;
@@ -1226,38 +1398,38 @@ void WindowBaseEcoreWl2::DestroyEglWindow()
 
 void WindowBaseEcoreWl2::SetEglWindowRotation( int angle )
 {
-  wl_egl_window_rotation rotation;
+  wl_egl_window_tizen_rotation rotation;
 
   switch( angle )
   {
     case 0:
     {
-      rotation = ROTATION_0;
+      rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0 ;
       break;
     }
     case 90:
     {
-      rotation = ROTATION_270;
+      rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
       break;
     }
     case 180:
     {
-      rotation = ROTATION_180;
+      rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
       break;
     }
     case 270:
     {
-      rotation = ROTATION_90;
+      rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
       break;
     }
     default:
     {
-      rotation = ROTATION_0;
+      rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0 ;
       break;
     }
   }
 
-  wl_egl_window_set_rotation( mEglWindow, rotation );
+  wl_egl_window_tizen_set_rotation( mEglWindow, rotation );
 }
 
 void WindowBaseEcoreWl2::SetEglWindowBufferTransform( int angle )
@@ -1293,7 +1465,7 @@ void WindowBaseEcoreWl2::SetEglWindowBufferTransform( int angle )
     }
   }
 
-  wl_egl_window_set_buffer_transform( mEglWindow, bufferTransform );
+  wl_egl_window_tizen_set_buffer_transform( mEglWindow, bufferTransform );
 }
 
 void WindowBaseEcoreWl2::SetEglWindowTransform( int angle )
@@ -1329,7 +1501,7 @@ void WindowBaseEcoreWl2::SetEglWindowTransform( int angle )
     }
   }
 
-  wl_egl_window_set_window_transform( mEglWindow, windowTransform );
+  wl_egl_window_tizen_set_window_transform( mEglWindow, windowTransform );
 }
 
 void WindowBaseEcoreWl2::ResizeEglWindow( PositionSize positionSize )
@@ -1347,8 +1519,8 @@ void WindowBaseEcoreWl2::ResizeEglWindow( PositionSize positionSize )
 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
 {
   // Check capability
-  wl_egl_window_capability capability = static_cast< wl_egl_window_capability >( wl_egl_window_get_capabilities( mEglWindow ) );
-  if( capability == WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED )
+  wl_egl_window_tizen_capability capability = static_cast< wl_egl_window_tizen_capability >( wl_egl_window_tizen_get_capabilities( mEglWindow ) );
+  if( capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED )
   {
     return true;
   }
@@ -1371,69 +1543,6 @@ void WindowBaseEcoreWl2::MoveResize( PositionSize positionSize )
   ecore_wl2_window_sync_geometry_set( mEcoreWindow, ++mMoveResizeSerial, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
 }
 
-void WindowBaseEcoreWl2::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode, Dali::Window::IndicatorBgOpacity opacityMode )
-{
-  DALI_LOG_TRACE_METHOD_FMT( gWindowBaseLogFilter, "visible : %d\n", visibleMode );
-
-  if( visibleMode == Dali::Window::VISIBLE )
-  {
-    // when the indicator is visible, set proper mode for indicator server according to bg mode
-    if( opacityMode == Dali::Window::OPAQUE )
-    {
-      ecore_wl2_window_indicator_opacity_set( mEcoreWindow, ECORE_WL2_INDICATOR_OPAQUE );
-    }
-    else if( opacityMode == Dali::Window::TRANSLUCENT )
-    {
-      ecore_wl2_window_indicator_opacity_set( mEcoreWindow, ECORE_WL2_INDICATOR_TRANSLUCENT );
-    }
-    else if( opacityMode == Dali::Window::TRANSPARENT )
-    {
-      ecore_wl2_window_indicator_opacity_set( mEcoreWindow, ECORE_WL2_INDICATOR_OPAQUE );
-    }
-  }
-  else
-  {
-    // when the indicator is not visible, set TRANSPARENT mode for indicator server
-    ecore_wl2_window_indicator_opacity_set( mEcoreWindow, ECORE_WL2_INDICATOR_TRANSPARENT); // it means hidden indicator
-  }
-}
-
-void WindowBaseEcoreWl2::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation )
-{
-  if( isShow )
-  {
-    ecore_wl2_window_indicator_state_set( mEcoreWindow, ECORE_WL2_INDICATOR_STATE_ON );
-  }
-  else
-  {
-    ecore_wl2_window_indicator_state_set( mEcoreWindow, ECORE_WL2_INDICATOR_STATE_OFF );
-  }
-}
-
-void WindowBaseEcoreWl2::IndicatorTypeChanged( IndicatorInterface::Type type )
-{
-#if defined(DALI_PROFILE_MOBILE)
-  switch( type )
-  {
-    case IndicatorInterface::INDICATOR_TYPE_1:
-    {
-      ecore_wl2_indicator_visible_type_set( mEcoreWindow, ECORE_WL2_INDICATOR_VISIBLE_TYPE_SHOWN );
-      break;
-    }
-    case IndicatorInterface::INDICATOR_TYPE_2:
-    {
-      ecore_wl2_indicator_visible_type_set( mEcoreWindow, ECORE_WL2_INDICATOR_VISIBLE_TYPE_HIDDEN );
-      break;
-    }
-    case IndicatorInterface::INDICATOR_TYPE_UNKNOWN:
-    default:
-    {
-      break;
-    }
-  }
-#endif //MOBILE
-}
-
 void WindowBaseEcoreWl2::SetClass( const std::string& name, const std::string& className )
 {
   ecore_wl2_window_title_set( mEcoreWindow, name.c_str() );
@@ -1456,19 +1565,21 @@ void WindowBaseEcoreWl2::Activate()
   ecore_wl2_window_activate( mEcoreWindow );
 }
 
-void WindowBaseEcoreWl2::SetAvailableOrientations( const std::vector< Dali::Window::WindowOrientation >& orientations )
+void WindowBaseEcoreWl2::SetAvailableAnlges( const std::vector< int >& angles )
 {
   int rotations[4] = { 0 };
-  for( std::size_t i = 0; i < orientations.size(); ++i )
+  DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size() );
+  for( std::size_t i = 0; i < angles.size(); ++i )
   {
-    rotations[i] = static_cast< int >( orientations[i] );
+    rotations[i] = static_cast< int >( angles[i] );
+    DALI_LOG_RELEASE_INFO( "%d ", rotations[i] );
   }
-  ecore_wl2_window_available_rotations_set( mEcoreWindow, rotations, orientations.size() );
+  ecore_wl2_window_available_rotations_set( mEcoreWindow, rotations, angles.size() );
 }
 
-void WindowBaseEcoreWl2::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
+void WindowBaseEcoreWl2::SetPreferredAngle( int angle )
 {
-  ecore_wl2_window_preferred_rotation_set( mEcoreWindow, orientation );
+  ecore_wl2_window_preferred_rotation_set( mEcoreWindow, angle );
 }
 
 void WindowBaseEcoreWl2::SetAcceptFocus( bool accept )
@@ -2157,10 +2268,6 @@ void WindowBaseEcoreWl2::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiV
   dpiVertical   = int( yres + 0.5f );
 }
 
-void WindowBaseEcoreWl2::SetViewMode( ViewMode viewMode )
-{
-}
-
 int WindowBaseEcoreWl2::GetScreenRotationAngle()
 {
   int transform = 0;
@@ -2243,6 +2350,17 @@ void WindowBaseEcoreWl2::CreateWindow( PositionSize positionSize )
   ecore_wl2_window_type_set( mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL );
 }
 
+void WindowBaseEcoreWl2::SetParent( WindowBase* parentWinBase )
+{
+  Ecore_Wl2_Window* ecoreParent = NULL;
+  if( parentWinBase )
+  {
+    WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>( parentWinBase );
+    ecoreParent = winBaseEcore2->mEcoreWindow;
+  }
+  ecore_wl2_window_parent_set( mEcoreWindow, ecoreParent );
+}
+
 } // namespace Adaptor
 
 } // namespace Internal