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