adaptors/ecore/wayland/window-impl-ecore-wl.cpp

   1 /*
   2  * Copyright (c) 2017 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 <window-impl.h>
  20
  21 // EXTERNAL HEADERS
  22 // Ecore is littered with C style cast
  23 #pragma GCC diagnostic push
  24 #pragma GCC diagnostic ignored "-Wold-style-cast"
  25 #include <Ecore.h>
  26 #include <Ecore_Wayland.h>
  27 #include <tizen-extension-client-protocol.h>
  28
  29 #include <dali/integration-api/core.h>
  30 #include <dali/integration-api/system-overlay.h>
  31 #include <dali/public-api/render-tasks/render-task.h>
  32 #include <dali/public-api/render-tasks/render-task-list.h>
  33 #include <orientation.h>
  34
  35 // INTERNAL HEADERS
  36 #include <window-render-surface.h>
  37 #include <drag-and-drop-detector-impl.h>
  38 #include <ecore-indicator-impl.h>
  39 #include <window-visibility-observer.h>
  40 #include <orientation-impl.h>
  41
  42 namespace
  43 {
  44
  45 const float INDICATOR_ANIMATION_DURATION( 0.18f ); // 180 milli seconds
  46 const float INDICATOR_SHOW_Y_POSITION( 0.0f );
  47 const float INDICATOR_HIDE_Y_POSITION( -52.0f );
  48
  49 const uint32_t MAX_TIZEN_CLIENT_VERSION = 7;
  50
  51 }
  52
  53 namespace Dali
  54 {
  55 namespace Internal
  56 {
  57 namespace Adaptor
  58 {
  59
  60 #if defined(DEBUG_ENABLED)
  61 Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW");
  62 #endif
  63
  64 /**
  65  * TODO: Abstract Window class out and move this into a window implementation for Ecore
  66  */
  67 struct Window::EventHandler
  68 {
  69   /**
  70    * Constructor
  71    * @param[in]  window  A pointer to the window class.
  72    */
  73   EventHandler( Window* window )
  74   : mWindow( window ),
  75     mEcoreEventHandler(),
  76     mEcoreWindow( 0 ),
  77     mDisplay( NULL ),
  78     mEventQueue( NULL ),
  79     mTizenPolicy( NULL ),
  80     mTizenDisplayPolicy( NULL ),
  81     mNotificationLevel( -1 ),
  82     mNotificationChangeState( 0 ),
  83     mNotificationLevelChangeDone( true ),
  84     mScreenOffMode( 0 ),
  85     mScreenOffModeChangeState( 0 ),
  86     mScreenOffModeChangeDone( true ),
  87     mBrightness( 0 ),
  88     mBrightnessChangeState( 0 ),
  89     mBrightnessChangeDone( true )
  90   {
  91     // store ecore window handle
  92     ECore::WindowRenderSurface* wlWindow( dynamic_cast< ECore::WindowRenderSurface * >( mWindow->mSurface ) );
  93     if( wlWindow )
  94     {
  95       mEcoreWindow = wlWindow->GetWlWindow();
  96     }
  97     DALI_ASSERT_ALWAYS( mEcoreWindow != 0 && "There is no ecore Wl window");
  98
  99     if( mWindow->mEcoreEventHander )
 100     {
 101       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) );
 102       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this ) );
 103       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this ) );
 104       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this) );
 105       mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM, EcoreEventIgnoreOutputTransform, this) );
 106     }
 107
 108     mDisplay = ecore_wl_display_get();
 109
 110     if( mDisplay )
 111     {
 112       wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) );
 113       if( displayWrapper )
 114       {
 115         mEventQueue = wl_display_create_queue( mDisplay );
 116         if( mEventQueue )
 117         {
 118           wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue );
 119
 120           wl_registry* registry = wl_display_get_registry( displayWrapper );
 121           wl_registry_add_listener( registry, &mRegistryListener, this );
 122         }
 123
 124         wl_proxy_wrapper_destroy( displayWrapper );
 125       }
 126     }
 127   }
 128
 129   /**
 130    * Destructor
 131    */
 132   ~EventHandler()
 133   {
 134     for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter )
 135     {
 136       ecore_event_handler_del( *iter );
 137     }
 138     mEcoreEventHandler.Clear();
 139
 140     if( mEventQueue )
 141     {
 142       wl_event_queue_destroy( mEventQueue );
 143     }
 144   }
 145
 146   // Static methods
 147
 148   /// Called when the window iconify state is changed.
 149   static Eina_Bool EcoreEventWindowIconifyStateChanged( void* data, int type, void* event )
 150   {
 151     Ecore_Wl_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl_Event_Window_Iconify_State_Change* >( event ) );
 152     EventHandler* handler( static_cast< EventHandler* >( data ) );
 153     Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 154
 155     if ( handler && handler->mWindow )
 156     {
 157       WindowVisibilityObserver* observer( handler->mWindow->mAdaptor );
 158       if ( observer && ( iconifyChangedEvent->win == static_cast< unsigned int> ( ecore_wl_window_id_get( handler->mEcoreWindow ) ) ) )
 159       {
 160         if( iconifyChangedEvent->iconified == EINA_TRUE )
 161         {
 162           handler->mWindow->mIconified = true;
 163           if( handler->mWindow->mVisible )
 164           {
 165             observer->OnWindowHidden();
 166           }
 167           DALI_LOG_RELEASE_INFO( "EcoreEventWindowIconifyStateChanged: Iconified, mVisible [%d]\n", handler->mWindow->mVisible );
 168         }
 169         else
 170         {
 171           handler->mWindow->mIconified = false;
 172           if( handler->mWindow->mVisible )
 173           {
 174             observer->OnWindowShown();
 175           }
 176           DALI_LOG_RELEASE_INFO( "EcoreEventWindowIconifyStateChanged: Deiconified, mVisible [%d]\n", handler->mWindow->mVisible );
 177         }
 178         handled = ECORE_CALLBACK_DONE;
 179       }
 180     }
 181
 182     return handled;
 183   }
 184
 185   /// Called when the window gains focus
 186   static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
 187   {
 188     Ecore_Wl_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl_Event_Focus_In* >( event ) );
 189     EventHandler* handler( static_cast< EventHandler* >( data ) );
 190
 191     if ( handler && handler->mWindow && focusInEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( handler->mEcoreWindow ) ) )
 192     {
 193       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
 194
 195       handler->mWindow->mFocusChangedSignal.Emit( true );
 196     }
 197
 198     return ECORE_CALLBACK_PASS_ON;
 199   }
 200
 201   /// Called when the window loses focus
 202   static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
 203   {
 204     Ecore_Wl_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl_Event_Focus_Out* >( event ) );
 205     EventHandler* handler( static_cast< EventHandler* >( data ) );
 206
 207     if ( handler && handler->mWindow && focusOutEvent->win == static_cast< unsigned int >(ecore_wl_window_id_get( handler->mEcoreWindow ) ) )
 208     {
 209       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
 210
 211       handler->mWindow->mFocusChangedSignal.Emit( false );
 212     }
 213
 214     return ECORE_CALLBACK_PASS_ON;
 215   }
 216
 217   /// Called when the output is transformed
 218   static Eina_Bool EcoreEventOutputTransform( void* data, int type, void* event )
 219   {
 220     Ecore_Wl_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl_Event_Output_Transform* >( event ) );
 221     EventHandler* handler( static_cast< EventHandler* >( data ) );
 222
 223     if ( handler && handler->mWindow && transformEvent->output == ecore_wl_window_output_find( handler->mEcoreWindow ) )
 224     {
 225       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", handler->mEcoreWindow );
 226
 227       ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) );
 228       if( wlSurface )
 229       {
 230         wlSurface->OutputTransformed();
 231
 232         PositionSize positionSize = wlSurface->GetPositionSize();
 233         handler->mWindow->mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
 234         handler->mWindow->mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
 235       }
 236     }
 237
 238     return ECORE_CALLBACK_PASS_ON;
 239   }
 240
 241   /// Called when the output transform should be ignored
 242   static Eina_Bool EcoreEventIgnoreOutputTransform( void* data, int type, void* event )
 243   {
 244     Ecore_Wl_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl_Event_Ignore_Output_Transform* >( event ) );
 245     EventHandler* handler( static_cast< EventHandler* >( data ) );
 246
 247     if ( handler && handler->mWindow && ignoreTransformEvent->win == handler->mEcoreWindow )
 248     {
 249       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", handler->mEcoreWindow );
 250
 251       ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) );
 252       if( wlSurface )
 253       {
 254         wlSurface->OutputTransformed();
 255
 256         PositionSize positionSize = wlSurface->GetPositionSize();
 257         handler->mWindow->mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
 258         handler->mWindow->mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
 259       }
 260     }
 261
 262     return ECORE_CALLBACK_PASS_ON;
 263   }
 264
 265   static void RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
 266   {
 267     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 268
 269     if( strcmp( interface, tizen_policy_interface.name ) == 0 )
 270     {
 271       uint32_t clientVersion = std::min( version, MAX_TIZEN_CLIENT_VERSION );
 272
 273       eventHandler->mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, clientVersion ) );
 274       if( !eventHandler->mTizenPolicy )
 275       {
 276         DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" );
 277         return;
 278       }
 279
 280       tizen_policy_add_listener( eventHandler->mTizenPolicy, &eventHandler->mTizenPolicyListener, data );
 281
 282       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" );
 283     }
 284     else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 )
 285     {
 286       eventHandler->mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) );
 287       if( !eventHandler->mTizenDisplayPolicy )
 288       {
 289         DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" );
 290         return;
 291       }
 292
 293       tizen_display_policy_add_listener( eventHandler->mTizenDisplayPolicy, &eventHandler->mTizenDisplayPolicyListener, data );
 294
 295       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" );
 296     }
 297   }
 298
 299   static void RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
 300   {
 301     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 302     eventHandler->mTizenPolicy = NULL;
 303     eventHandler->mTizenDisplayPolicy = NULL;
 304   }
 305
 306   static void TizenPolicyConformant( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t isConformant )
 307   {
 308   }
 309
 310   static void TizenPolicyConformantArea( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h )
 311   {
 312   }
 313
 314   static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
 315   {
 316     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 317
 318     eventHandler->mNotificationLevel = level;
 319     eventHandler->mNotificationChangeState = state;
 320     eventHandler->mNotificationLevelChangeDone = true;
 321
 322     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state );
 323   }
 324
 325   static void TizenPolicyTransientForDone( void* data, struct tizen_policy* tizenPolicy, uint32_t childId )
 326   {
 327   }
 328
 329   static void TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
 330   {
 331     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 332
 333     eventHandler->mScreenOffMode = mode;
 334     eventHandler->mScreenOffModeChangeState = state;
 335     eventHandler->mScreenOffModeChangeDone = true;
 336
 337     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
 338   }
 339
 340   static void TizenPolicyIconifyStateChanged( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t iconified, uint32_t force )
 341   {
 342   }
 343
 344   static void TizenPolicySupportedAuxiliaryHints( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, struct wl_array* hints, uint32_t numNints )
 345   {
 346   }
 347
 348   static void TizenPolicyAllowedAuxiliaryHint( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int id )
 349   {
 350   }
 351
 352   static void TizenPolicyAuxiliaryMessage( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, const char* key, const char* val, struct wl_array* options )
 353   {
 354   }
 355
 356   static void TizenPolicyConformantRegion( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial )
 357   {
 358   }
 359
 360   static void DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
 361   {
 362     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 363
 364     eventHandler->mBrightness = brightness;
 365     eventHandler->mBrightnessChangeState = state;
 366     eventHandler->mBrightnessChangeDone = true;
 367
 368     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
 369   }
 370
 371   const struct wl_registry_listener mRegistryListener =
 372   {
 373      RegistryGlobalCallback,
 374      RegistryGlobalCallbackRemove
 375   };
 376
 377   const struct tizen_policy_listener mTizenPolicyListener =
 378   {
 379      TizenPolicyConformant,
 380      TizenPolicyConformantArea,
 381      TizenPolicyNotificationChangeDone,
 382      TizenPolicyTransientForDone,
 383      TizenPolicyScreenModeChangeDone,
 384      TizenPolicyIconifyStateChanged,
 385      TizenPolicySupportedAuxiliaryHints,
 386      TizenPolicyAllowedAuxiliaryHint,
 387      TizenPolicyAuxiliaryMessage,
 388      TizenPolicyConformantRegion
 389   };
 390
 391   const struct tizen_display_policy_listener mTizenDisplayPolicyListener =
 392   {
 393     DisplayPolicyBrightnessChangeDone
 394   };
 395
 396   // Data
 397   Window* mWindow;
 398   Dali::Vector< Ecore_Event_Handler* > mEcoreEventHandler;
 399   Ecore_Wl_Window* mEcoreWindow;
 400
 401   wl_display* mDisplay;
 402   wl_event_queue* mEventQueue;
 403   tizen_policy* mTizenPolicy;
 404   tizen_display_policy* mTizenDisplayPolicy;
 405
 406   int mNotificationLevel;
 407   uint32_t mNotificationChangeState;
 408   bool mNotificationLevelChangeDone;
 409
 410   int mScreenOffMode;
 411   uint32_t mScreenOffModeChangeState;
 412   bool mScreenOffModeChangeDone;
 413
 414   int mBrightness;
 415   uint32_t mBrightnessChangeState;
 416   bool mBrightnessChangeDone;
 417 };
 418
 419 Window* Window::New( const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent )
 420 {
 421   Window* window = new Window();
 422   window->mIsTransparent = isTransparent;
 423   window->Initialize( positionSize, name, className );
 424   return window;
 425 }
 426
 427 void Window::SetAdaptor(Dali::Adaptor& adaptor)
 428 {
 429   DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
 430   mStarted = true;
 431
 432   // Only create one overlay per window
 433   Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
 434   Integration::Core& core = adaptorImpl.GetCore();
 435   mOverlay = &core.GetSystemOverlay();
 436
 437   Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
 438   taskList.CreateTask();
 439
 440   mAdaptor = &adaptorImpl;
 441   mAdaptor->AddObserver( *this );
 442
 443   // Can only create the detector when we know the Core has been instantiated.
 444   mDragAndDropDetector = DragAndDropDetector::New();
 445   mAdaptor->SetDragAndDropDetector( &GetImplementation( mDragAndDropDetector ) );
 446
 447   if( mOrientation )
 448   {
 449     mOrientation->SetAdaptor(adaptor);
 450   }
 451
 452   if( mIndicator != NULL )
 453   {
 454     mIndicator->SetAdaptor(mAdaptor);
 455   }
 456 }
 457
 458 RenderSurface* Window::GetSurface()
 459 {
 460   return mSurface;
 461 }
 462
 463 void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
 464 {
 465   DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "visible : %d\n", visibleMode );
 466   DALI_ASSERT_DEBUG(mOverlay);
 467
 468   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 469   DALI_ASSERT_DEBUG(wlSurface);
 470
 471   if( wlSurface )
 472   {
 473     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 474
 475     mIndicatorVisible = visibleMode;
 476
 477     if ( mIndicatorVisible == Dali::Window::VISIBLE )
 478     {
 479       // when the indicator is visible, set proper mode for indicator server according to bg mode
 480       if ( mIndicatorOpacityMode == Dali::Window::OPAQUE )
 481       {
 482         ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
 483       }
 484       else if ( mIndicatorOpacityMode == Dali::Window::TRANSLUCENT )
 485       {
 486         ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSLUCENT);
 487       }
 488       else if ( mIndicatorOpacityMode == Dali::Window::TRANSPARENT )
 489       {
 490         ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
 491       }
 492     }
 493     else
 494     {
 495       // when the indicator is not visible, set TRANSPARENT mode for indicator server
 496       ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSPARENT); // it means hidden indicator
 497     }
 498   }
 499
 500   DoShowIndicator( mIndicatorOrientation );
 501 }
 502
 503 void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )
 504 {
 505   DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "Orientation: %d\n", orientation );
 506
 507   DoRotateIndicator( orientation );
 508 }
 509
 510 void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode )
 511 {
 512   mIndicatorOpacityMode = opacityMode;
 513
 514   if( mIndicator != NULL )
 515   {
 516     mIndicator->SetOpacityMode( opacityMode );
 517   }
 518 }
 519
 520 void Window::SetClass(std::string name, std::string klass)
 521 {
 522   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 523
 524   if( wlSurface )
 525   {
 526     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 527     ecore_wl_window_title_set( wlWindow, name.c_str() );
 528     ecore_wl_window_class_name_set( wlWindow, klass.c_str() );
 529   }
 530   else
 531   {
 532     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window has no surface\n" );
 533   }
 534 }
 535
 536 Window::Window()
 537 : mSurface( NULL ),
 538   mIndicatorVisible( Dali::Window::VISIBLE ),
 539   mIndicatorIsShown( false ),
 540   mShowRotatedIndicatorOnClose( false ),
 541   mStarted( false ),
 542   mIsTransparent( false ),
 543   mWMRotationAppSet( false ),
 544   mEcoreEventHander( true ),
 545   mIsFocusAcceptable( true ),
 546   mVisible( true ),
 547   mIconified( false ),
 548   mOpaqueState( false ),
 549   mResizeEnabled( false ),
 550   mIndicator( NULL ),
 551   mIndicatorOrientation( Dali::Window::PORTRAIT ),
 552   mNextIndicatorOrientation( Dali::Window::PORTRAIT ),
 553   mIndicatorOpacityMode( Dali::Window::OPAQUE ),
 554   mOverlay( NULL ),
 555   mAdaptor( NULL ),
 556   mType( Dali::Window::NORMAL ),
 557   mEventHandler( NULL ),
 558   mPreferredOrientation( Dali::Window::PORTRAIT ),
 559   mSupportedAuxiliaryHints(),
 560   mAuxiliaryHints(),
 561   mIndicatorVisibilityChangedSignal(),
 562   mFocusChangedSignal(),
 563   mResizedSignal(),
 564   mDeleteRequestSignal()
 565 {
 566 }
 567
 568 Window::~Window()
 569 {
 570   delete mEventHandler;
 571
 572   if( mIndicator )
 573   {
 574     mIndicator->Close();
 575     delete mIndicator;
 576   }
 577
 578   if ( mAdaptor )
 579   {
 580     mAdaptor->RemoveObserver( *this );
 581     mAdaptor->SetDragAndDropDetector( NULL );
 582     mAdaptor = NULL;
 583   }
 584
 585   delete mSurface;
 586
 587   mSupportedAuxiliaryHints.clear();
 588   mAuxiliaryHints.clear();
 589 }
 590
 591 void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className)
 592 {
 593   // create an Wayland window by default
 594   Any surface;
 595   ECore::WindowRenderSurface* windowSurface = new ECore::WindowRenderSurface( positionSize, surface, name, mIsTransparent );
 596
 597   mSurface = windowSurface;
 598
 599   // create event handler for Wayland window
 600   mEventHandler = new EventHandler( this );
 601
 602   // get auxiliary hint
 603   Eina_List* hints = ecore_wl_window_aux_hints_supported_get( mEventHandler->mEcoreWindow );
 604   if( hints )
 605   {
 606     Eina_List* l = NULL;
 607     char* hint = NULL;
 608
 609     for( l = hints, ( hint =  static_cast< char* >( eina_list_data_get(l) ) ); l; l = eina_list_next(l), ( hint = static_cast< char* >( eina_list_data_get(l) ) ) )
 610     {
 611       mSupportedAuxiliaryHints.push_back( hint );
 612
 613       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::Initialize: %s\n", hint );
 614     }
 615   }
 616
 617   if( !positionSize.IsEmpty() )
 618   {
 619     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
 620     mResizeEnabled = true;
 621   }
 622
 623   SetClass( name, className );
 624   windowSurface->Map();
 625
 626   mOrientation = Orientation::New(this);
 627 }
 628
 629 void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
 630 {
 631   if( mIndicator == NULL )
 632   {
 633     if( mIndicatorVisible != Dali::Window::INVISIBLE )
 634     {
 635       mIndicator = new Indicator( mAdaptor, mIndicatorOrientation, this );
 636       mIndicator->SetOpacityMode( mIndicatorOpacityMode );
 637       Dali::Actor actor = mIndicator->GetActor();
 638       SetIndicatorActorRotation();
 639       mOverlay->Add(actor);
 640     }
 641     // else don't create a hidden indicator
 642   }
 643   else // Already have indicator
 644   {
 645     if( mIndicatorVisible == Dali::Window::VISIBLE )
 646     {
 647       // If we are resuming, and rotation has changed,
 648       if( mIndicatorIsShown == false && mIndicatorOrientation != mNextIndicatorOrientation )
 649       {
 650         // then close current indicator and open new one
 651         mShowRotatedIndicatorOnClose = true;
 652         mIndicator->Close(); // May synchronously call IndicatorClosed() callback & 1 level of recursion
 653         // Don't show actor - will contain indicator for old orientation.
 654       }
 655     }
 656   }
 657
 658   // set indicator visible mode
 659   if( mIndicator != NULL )
 660   {
 661     mIndicator->SetVisible( mIndicatorVisible );
 662   }
 663
 664   bool show = (mIndicatorVisible != Dali::Window::INVISIBLE );
 665   SetIndicatorProperties( show, lastOrientation );
 666   mIndicatorIsShown = show;
 667 }
 668
 669 void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation )
 670 {
 671   if( mIndicatorIsShown )
 672   {
 673     mShowRotatedIndicatorOnClose = true;
 674     mNextIndicatorOrientation = orientation;
 675     mIndicator->Close(); // May synchronously call IndicatorClosed() callback
 676   }
 677   else
 678   {
 679     // Save orientation for when the indicator is next shown
 680     mShowRotatedIndicatorOnClose = false;
 681     mNextIndicatorOrientation = orientation;
 682   }
 683 }
 684
 685 void Window::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation )
 686 {
 687   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 688
 689   if( wlSurface )
 690   {
 691     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 692     if ( isShow )
 693     {
 694       ecore_wl_window_indicator_state_set(wlWindow, ECORE_WL_INDICATOR_STATE_ON);
 695     }
 696     else
 697     {
 698       ecore_wl_window_indicator_state_set(wlWindow, ECORE_WL_INDICATOR_STATE_OFF);
 699     }
 700   }
 701 }
 702
 703 void Window::IndicatorTypeChanged(Indicator::Type type)
 704 {
 705 #if defined(DALI_PROFILE_MOBILE)
 706   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 707
 708   if( wlSurface )
 709   {
 710     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 711     switch(type)
 712     {
 713       case Indicator::INDICATOR_TYPE_1:
 714         ecore_wl_indicator_visible_type_set(wlWindow, ECORE_WL_INDICATOR_VISIBLE_TYPE_SHOWN);
 715         break;
 716
 717       case Indicator::INDICATOR_TYPE_2:
 718         ecore_wl_indicator_visible_type_set(wlWindow, ECORE_WL_INDICATOR_VISIBLE_TYPE_HIDDEN);
 719         break;
 720
 721       case Indicator::INDICATOR_TYPE_UNKNOWN:
 722       default:
 723         break;
 724     }
 725   }
 726 #endif //MOBILE
 727 }
 728
 729 void Window::IndicatorClosed( IndicatorInterface* indicator )
 730 {
 731   DALI_LOG_TRACE_METHOD( gWindowLogFilter );
 732
 733   if( mShowRotatedIndicatorOnClose )
 734   {
 735     Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation;
 736     mIndicator->Open(mNextIndicatorOrientation);
 737     mIndicatorOrientation = mNextIndicatorOrientation;
 738     SetIndicatorActorRotation();
 739     DoShowIndicator(currentOrientation);
 740   }
 741 }
 742
 743 void Window::IndicatorVisibilityChanged(bool isVisible)
 744 {
 745   mIndicatorVisibilityChangedSignal.Emit(isVisible);
 746 }
 747
 748 void Window::SetIndicatorActorRotation()
 749 {
 750   DALI_LOG_TRACE_METHOD( gWindowLogFilter );
 751   DALI_ASSERT_DEBUG( mIndicator != NULL );
 752
 753   Dali::Actor actor = mIndicator->GetActor();
 754   switch( mIndicatorOrientation )
 755   {
 756     case Dali::Window::PORTRAIT:
 757       actor.SetParentOrigin( ParentOrigin::TOP_CENTER );
 758       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 759       actor.SetOrientation( Degree(0), Vector3::ZAXIS );
 760       break;
 761     case Dali::Window::PORTRAIT_INVERSE:
 762       actor.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
 763       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 764       actor.SetOrientation( Degree(180), Vector3::ZAXIS );
 765       break;
 766     case Dali::Window::LANDSCAPE:
 767       actor.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 768       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 769       actor.SetOrientation( Degree(270), Vector3::ZAXIS );
 770       break;
 771     case Dali::Window::LANDSCAPE_INVERSE:
 772       actor.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
 773       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 774       actor.SetOrientation( Degree(90), Vector3::ZAXIS );
 775       break;
 776   }
 777 }
 778
 779 void Window::Raise()
 780 {
 781   // Use ecore_wl_window_activate to prevent the window shown without rendering
 782   ecore_wl_window_activate( mEventHandler->mEcoreWindow );
 783 }
 784
 785 void Window::Lower()
 786 {
 787   ecore_wl_window_lower( mEventHandler->mEcoreWindow );
 788 }
 789
 790 void Window::Activate()
 791 {
 792   ecore_wl_window_activate( mEventHandler->mEcoreWindow );
 793 }
 794
 795 Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
 796 {
 797   return mDragAndDropDetector;
 798 }
 799
 800 Dali::Any Window::GetNativeHandle() const
 801 {
 802   if(mEventHandler)
 803   {
 804     return mEventHandler->mEcoreWindow;
 805   }
 806   else
 807   {
 808     return Dali::Any();
 809   }
 810 }
 811
 812 void Window::OnStart()
 813 {
 814   DoShowIndicator( mIndicatorOrientation );
 815 }
 816
 817 void Window::OnPause()
 818 {
 819 }
 820
 821 void Window::OnResume()
 822 {
 823   // resume indicator status
 824   if( mIndicator != NULL )
 825   {
 826     // Restore own indicator opacity
 827     // Send opacity mode to indicator service when app resumed
 828     mIndicator->SetOpacityMode( mIndicatorOpacityMode );
 829   }
 830 }
 831
 832 void Window::OnStop()
 833 {
 834   if( mIndicator )
 835   {
 836     mIndicator->Close();
 837   }
 838
 839   delete mIndicator;
 840   mIndicator = NULL;
 841 }
 842
 843 void Window::OnDestroy()
 844 {
 845   mAdaptor = NULL;
 846 }
 847
 848 void Window::AddAvailableOrientation(Dali::Window::WindowOrientation orientation)
 849 {
 850   bool found = false;
 851
 852   if ( orientation <= Dali::Window::LANDSCAPE_INVERSE )
 853   {
 854     for( std::size_t i = 0; i < mAvailableOrientations.size(); i++ )
 855     {
 856       if( mAvailableOrientations[i] == orientation )
 857       {
 858         found = true;
 859         break;
 860       }
 861     }
 862
 863     if( ! found )
 864     {
 865       mAvailableOrientations.push_back(orientation);
 866       SetAvailableOrientations( mAvailableOrientations );
 867     }
 868   }
 869 }
 870
 871 void Window::RemoveAvailableOrientation(Dali::Window::WindowOrientation orientation)
 872 {
 873   for( std::vector<Dali::Window::WindowOrientation>::iterator iter = mAvailableOrientations.begin();
 874        iter != mAvailableOrientations.end(); ++iter )
 875   {
 876     if( *iter == orientation )
 877     {
 878       mAvailableOrientations.erase( iter );
 879       break;
 880     }
 881   }
 882   SetAvailableOrientations( mAvailableOrientations );
 883 }
 884
 885 void Window::SetAvailableOrientations(const std::vector<Dali::Window::WindowOrientation>& orientations)
 886 {
 887   int rotations[4];
 888   for( std::size_t i = 0; i < mAvailableOrientations.size(); ++i )
 889   {
 890     rotations[i] = static_cast< int >( mAvailableOrientations[i] );
 891   }
 892   ecore_wl_window_rotation_available_rotations_set( mEventHandler->mEcoreWindow, rotations, mAvailableOrientations.size() );
 893 }
 894
 895 const std::vector<Dali::Window::WindowOrientation>& Window::GetAvailableOrientations()
 896 {
 897   return mAvailableOrientations;
 898 }
 899
 900 void Window::SetPreferredOrientation(Dali::Window::WindowOrientation orientation)
 901 {
 902   mPreferredOrientation = orientation;
 903
 904   ecore_wl_window_rotation_preferred_rotation_set( mEventHandler->mEcoreWindow, orientation );
 905 }
 906
 907 Dali::Window::WindowOrientation Window::GetPreferredOrientation()
 908 {
 909   return mPreferredOrientation;
 910 }
 911
 912 void Window::SetAcceptFocus( bool accept )
 913 {
 914   mIsFocusAcceptable = accept;
 915
 916   ecore_wl_window_focus_skip_set( mEventHandler->mEcoreWindow, !accept );
 917 }
 918
 919 bool Window::IsFocusAcceptable() const
 920 {
 921   return mIsFocusAcceptable;
 922 }
 923
 924 void Window::Show()
 925 {
 926   mVisible = true;
 927   ecore_wl_window_show( mEventHandler->mEcoreWindow );
 928
 929   DALI_LOG_RELEASE_INFO( "Window::Show: mIconified [%d]\n", mIconified );
 930
 931   if( !mIconified )
 932   {
 933     if( mAdaptor )
 934     {
 935       WindowVisibilityObserver* observer( mAdaptor );
 936       observer->OnWindowShown();
 937     }
 938   }
 939 }
 940
 941 void Window::Hide()
 942 {
 943   mVisible = false;
 944   ecore_wl_window_hide( mEventHandler->mEcoreWindow );
 945
 946   DALI_LOG_RELEASE_INFO( "Window::Hide: mIconified [%d]\n", mIconified );
 947
 948   if( !mIconified )
 949   {
 950     if( mAdaptor )
 951     {
 952       WindowVisibilityObserver* observer( mAdaptor );
 953       observer->OnWindowHidden();
 954     }
 955   }
 956 }
 957
 958 bool Window::IsVisible() const
 959 {
 960   return mVisible;
 961 }
 962
 963 void Window::RotationDone( int orientation, int width, int height )
 964 {
 965   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 966   if( wlSurface )
 967   {
 968     wlSurface->RequestRotation( orientation, width, height );
 969   }
 970
 971   mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) );
 972
 973   // Emit signal
 974   mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
 975
 976   mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) );
 977 }
 978
 979 void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
 980 {
 981   mIndicatorVisible = mode;
 982 }
 983
 984 unsigned int Window::GetSupportedAuxiliaryHintCount() const
 985 {
 986   return mSupportedAuxiliaryHints.size();
 987 }
 988
 989 std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const
 990 {
 991   if( index >= GetSupportedAuxiliaryHintCount() )
 992   {
 993     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
 994   }
 995
 996   return mSupportedAuxiliaryHints[index];
 997 }
 998
 999 unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
1000 {
1001   bool supported = false;
1002
1003   // Check if the hint is suppported
1004   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1005   {
1006     if( *iter == hint )
1007     {
1008       supported = true;
1009       break;
1010     }
1011   }
1012
1013   if( !supported )
1014   {
1015     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1016     return 0;
1017   }
1018
1019   // Check if the hint is already added
1020   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1021   {
1022     if( mAuxiliaryHints[i].first == hint )
1023     {
1024       // Just change the value
1025       mAuxiliaryHints[i].second = value;
1026
1027       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1028
1029       return i + 1;   // id is index + 1
1030     }
1031   }
1032
1033   // Add the hint
1034   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1035
1036   unsigned int id = mAuxiliaryHints.size();
1037
1038   ecore_wl_window_aux_hint_add( mEventHandler->mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1039
1040   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1041
1042   return id;
1043 }
1044
1045 bool Window::RemoveAuxiliaryHint( unsigned int id )
1046 {
1047   if( id == 0 || id > mAuxiliaryHints.size() )
1048   {
1049     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1050     return false;
1051   }
1052
1053   mAuxiliaryHints[id - 1].second = std::string();
1054
1055   ecore_wl_window_aux_hint_del( mEventHandler->mEcoreWindow, static_cast< int >( id ) );
1056
1057   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1058
1059   return true;
1060 }
1061
1062 bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1063 {
1064   if( id == 0 || id > mAuxiliaryHints.size() )
1065   {
1066     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1067     return false;
1068   }
1069
1070   mAuxiliaryHints[id - 1].second = value;
1071
1072   ecore_wl_window_aux_hint_change( mEventHandler->mEcoreWindow, static_cast< int >( id ), value.c_str() );
1073
1074   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str() );
1075
1076   return true;
1077 }
1078
1079 std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
1080 {
1081   if( id == 0 || id > mAuxiliaryHints.size() )
1082   {
1083     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1084     return std::string();
1085   }
1086
1087   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str() );
1088
1089   return mAuxiliaryHints[id - 1].second;
1090 }
1091
1092 unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
1093 {
1094   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1095   {
1096     if( mAuxiliaryHints[i].first == hint )
1097     {
1098       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1099       return i + 1;
1100     }
1101   }
1102
1103   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1104
1105   return 0;
1106 }
1107
1108 void Window::SetInputRegion( const Rect< int >& inputRegion )
1109 {
1110   ecore_wl_window_input_region_set( mEventHandler->mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1111
1112   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 );
1113 }
1114
1115 void Window::SetType( Dali::Window::Type type )
1116 {
1117   Ecore_Wl_Window_Type windowType;
1118
1119   if( type != mType )
1120   {
1121     switch( type )
1122     {
1123       case Dali::Window::NORMAL:
1124       {
1125         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1126         break;
1127       }
1128       case Dali::Window::NOTIFICATION:
1129       {
1130         windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1131         break;
1132       }
1133       case Dali::Window::UTILITY:
1134       {
1135         windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1136         break;
1137       }
1138       case Dali::Window::DIALOG:
1139       {
1140         windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1141         break;
1142       }
1143       default:
1144       {
1145         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1146         break;
1147       }
1148     }
1149
1150     ecore_wl_window_type_set( mEventHandler->mEcoreWindow, windowType );
1151   }
1152
1153   mType = type;
1154 }
1155
1156 Dali::Window::Type Window::GetType() const
1157 {
1158   return mType;
1159 }
1160
1161 bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1162 {
1163   if( mType != Dali::Window::NOTIFICATION )
1164   {
1165     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType );
1166     return false;
1167   }
1168
1169   while( !mEventHandler->mTizenPolicy )
1170   {
1171     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1172   }
1173
1174   int notificationLevel;
1175
1176   switch( level )
1177   {
1178     case Dali::Window::NotificationLevel::NONE:
1179     {
1180       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1181       break;
1182     }
1183     case Dali::Window::NotificationLevel::BASE:
1184     {
1185       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1186       break;
1187     }
1188     case Dali::Window::NotificationLevel::MEDIUM:
1189     {
1190       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1191       break;
1192     }
1193     case Dali::Window::NotificationLevel::HIGH:
1194     {
1195       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1196       break;
1197     }
1198     case Dali::Window::NotificationLevel::TOP:
1199     {
1200       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1201       break;
1202     }
1203     default:
1204     {
1205       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: invalid level [%d]\n", level );
1206       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1207       break;
1208     }
1209   }
1210
1211   mEventHandler->mNotificationLevelChangeDone = false;
1212   mEventHandler->mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1213
1214   tizen_policy_set_notification_level( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), notificationLevel );
1215
1216   int count = 0;
1217
1218   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1219   {
1220     ecore_wl_flush();
1221     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1222     count++;
1223   }
1224
1225   if( !mEventHandler->mNotificationLevelChangeDone )
1226   {
1227     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mEventHandler->mNotificationChangeState );
1228     return false;
1229   }
1230   else if( mEventHandler->mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1231   {
1232     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Permission denied! [%d]\n", level );
1233     return false;
1234   }
1235
1236   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level is changed [%d]\n", mEventHandler->mNotificationLevel );
1237
1238   return true;
1239 }
1240
1241 Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const
1242 {
1243   if( mType != Dali::Window::NOTIFICATION )
1244   {
1245     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType );
1246     return Dali::Window::NotificationLevel::NONE;
1247   }
1248
1249   while( !mEventHandler->mTizenPolicy )
1250   {
1251     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1252   }
1253
1254   int count = 0;
1255
1256   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1257   {
1258     ecore_wl_flush();
1259     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1260     count++;
1261   }
1262
1263   if( !mEventHandler->mNotificationLevelChangeDone )
1264   {
1265     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState );
1266     return Dali::Window::NotificationLevel::NONE;
1267   }
1268
1269   Dali::Window::NotificationLevel::Type level;
1270
1271   switch( mEventHandler->mNotificationLevel )
1272   {
1273     case TIZEN_POLICY_LEVEL_NONE:
1274     {
1275       level = Dali::Window::NotificationLevel::NONE;
1276       break;
1277     }
1278     case TIZEN_POLICY_LEVEL_DEFAULT:
1279     {
1280       level = Dali::Window::NotificationLevel::BASE;
1281       break;
1282     }
1283     case TIZEN_POLICY_LEVEL_MEDIUM:
1284     {
1285       level = Dali::Window::NotificationLevel::MEDIUM;
1286       break;
1287     }
1288     case TIZEN_POLICY_LEVEL_HIGH:
1289     {
1290       level = Dali::Window::NotificationLevel::HIGH;
1291       break;
1292     }
1293     case TIZEN_POLICY_LEVEL_TOP:
1294     {
1295       level = Dali::Window::NotificationLevel::TOP;
1296       break;
1297     }
1298     default:
1299     {
1300       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel );
1301       level = Dali::Window::NotificationLevel::NONE;
1302       break;
1303     }
1304   }
1305
1306   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: level [%d]\n", mEventHandler->mNotificationLevel );
1307
1308   return level;
1309 }
1310
1311 void Window::SetOpaqueState( bool opaque )
1312 {
1313   while( !mEventHandler->mTizenPolicy )
1314   {
1315     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1316   }
1317
1318   tizen_policy_set_opaque_state( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), ( opaque ? 1 : 0 ) );
1319
1320   mOpaqueState = opaque;
1321
1322   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque );
1323 }
1324
1325 bool Window::IsOpaqueState() const
1326 {
1327   return mOpaqueState;
1328 }
1329
1330 bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1331 {
1332   while( !mEventHandler->mTizenPolicy )
1333   {
1334     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1335   }
1336
1337   mEventHandler->mScreenOffModeChangeDone = false;
1338   mEventHandler->mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1339
1340   unsigned int mode = 0;
1341
1342   switch( screenOffMode )
1343   {
1344     case Dali::Window::ScreenOffMode::TIMEOUT:
1345     {
1346       mode = 0;
1347       break;
1348     }
1349     case Dali::Window::ScreenOffMode::NEVER:
1350     {
1351       mode = 1;
1352       break;
1353     }
1354   }
1355
1356   tizen_policy_set_window_screen_mode( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), mode );
1357
1358   int count = 0;
1359
1360   while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
1361   {
1362     ecore_wl_flush();
1363     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1364     count++;
1365   }
1366
1367   if( !mEventHandler->mScreenOffModeChangeDone )
1368   {
1369     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mEventHandler->mScreenOffModeChangeState );
1370     return false;
1371   }
1372   else if( mEventHandler->mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1373   {
1374     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
1375     return false;
1376   }
1377
1378   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode is changed [%d]\n", mEventHandler->mScreenOffMode );
1379
1380   return true;
1381 }
1382
1383 Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const
1384 {
1385   while( !mEventHandler->mTizenPolicy )
1386   {
1387     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1388   }
1389
1390   int count = 0;
1391
1392   while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
1393   {
1394     ecore_wl_flush();
1395     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1396     count++;
1397   }
1398
1399   if( !mEventHandler->mScreenOffModeChangeDone )
1400   {
1401     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: Error! [%d]\n", mEventHandler->mScreenOffModeChangeState );
1402     return Dali::Window::ScreenOffMode::TIMEOUT;
1403   }
1404
1405   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1406
1407   switch( mEventHandler->mScreenOffMode )
1408   {
1409     case 0:
1410     {
1411       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1412       break;
1413     }
1414     case 1:
1415     {
1416       screenMode = Dali::Window::ScreenOffMode::NEVER;
1417       break;
1418     }
1419   }
1420
1421   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: screen mode [%d]\n", mEventHandler->mScreenOffMode );
1422
1423   return screenMode;
1424 }
1425
1426 bool Window::SetBrightness( int brightness )
1427 {
1428   if( brightness < 0 || brightness > 100 )
1429   {
1430     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness );
1431     return false;
1432   }
1433
1434   while( !mEventHandler->mTizenDisplayPolicy )
1435   {
1436     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1437   }
1438
1439   mEventHandler->mBrightnessChangeDone = false;
1440   mEventHandler->mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1441
1442   tizen_display_policy_set_window_brightness( mEventHandler->mTizenDisplayPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), brightness );
1443
1444   int count = 0;
1445
1446   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1447   {
1448     ecore_wl_flush();
1449     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1450     count++;
1451   }
1452
1453   if( !mEventHandler->mBrightnessChangeDone )
1454   {
1455     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mEventHandler->mBrightnessChangeState );
1456     return false;
1457   }
1458   else if( mEventHandler->mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1459   {
1460     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Permission denied! [%d]\n", brightness );
1461     return false;
1462   }
1463
1464   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness is changed [%d]\n", mEventHandler->mBrightness );
1465
1466   return true;
1467 }
1468
1469 int Window::GetBrightness() const
1470 {
1471   while( !mEventHandler->mTizenDisplayPolicy )
1472   {
1473     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1474   }
1475
1476   int count = 0;
1477
1478   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1479   {
1480     ecore_wl_flush();
1481     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1482     count++;
1483   }
1484
1485   if( !mEventHandler->mBrightnessChangeDone )
1486   {
1487     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Error! [%d]\n", mEventHandler->mBrightnessChangeState );
1488     return 0;
1489   }
1490
1491   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Brightness [%d]\n", mEventHandler->mBrightness );
1492
1493   return mEventHandler->mBrightness;
1494 }
1495
1496 void Window::SetSize( Dali::Window::WindowSize size )
1497 {
1498   if( !mResizeEnabled )
1499   {
1500     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
1501     mResizeEnabled = true;
1502   }
1503
1504   PositionSize positionSize = mSurface->GetPositionSize();
1505
1506   if( positionSize.width != size.GetWidth() || positionSize.height != size.GetHeight() )
1507   {
1508     positionSize.width = size.GetWidth();
1509     positionSize.height = size.GetHeight();
1510
1511     mSurface->MoveResize( positionSize );
1512
1513     mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
1514
1515     // Emit signal
1516     mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) );
1517
1518     mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
1519   }
1520 }
1521
1522 Dali::Window::WindowSize Window::GetSize() const
1523 {
1524   PositionSize positionSize = mSurface->GetPositionSize();
1525
1526   return Dali::Window::WindowSize( positionSize.width, positionSize.height );
1527 }
1528
1529 void Window::SetPosition( Dali::Window::WindowPosition position )
1530 {
1531   if( !mResizeEnabled )
1532   {
1533     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
1534     mResizeEnabled = true;
1535   }
1536
1537   PositionSize positionSize = mSurface->GetPositionSize();
1538
1539   if( positionSize.x != position.GetX() || positionSize.y != position.GetY() )
1540   {
1541     positionSize.x = position.GetX();
1542     positionSize.y = position.GetY();
1543
1544     mSurface->MoveResize( positionSize );
1545   }
1546 }
1547
1548 Dali::Window::WindowPosition Window::GetPosition() const
1549 {
1550   PositionSize positionSize = mSurface->GetPositionSize();
1551
1552   return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
1553 }
1554
1555 void Window::SetTransparency( bool transparent )
1556 {
1557   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
1558   if( wlSurface )
1559   {
1560     wlSurface->SetTransparency( transparent );
1561   }
1562 }
1563
1564 } // Adaptor
1565
1566 } // Internal
1567
1568 } // Dali
1569
1570 #pragma GCC diagnostic pop