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   ecore_wl_window_raise( mEventHandler->mEcoreWindow );
 734 }
 735
 736 void Window::Lower()
 737 {
 738   ecore_wl_window_lower( mEventHandler->mEcoreWindow );
 739 }
 740
 741 void Window::Activate()
 742 {
 743   ecore_wl_window_activate( mEventHandler->mEcoreWindow );
 744 }
 745
 746 Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
 747 {
 748   return mDragAndDropDetector;
 749 }
 750
 751 Dali::Any Window::GetNativeHandle() const
 752 {
 753   if(mEventHandler)
 754   {
 755     return mEventHandler->mEcoreWindow;
 756   }
 757   else
 758   {
 759     return Dali::Any();
 760   }
 761 }
 762
 763 void Window::OnStart()
 764 {
 765   DoShowIndicator( mIndicatorOrientation );
 766 }
 767
 768 void Window::OnPause()
 769 {
 770 }
 771
 772 void Window::OnResume()
 773 {
 774   // resume indicator status
 775   if( mIndicator != NULL )
 776   {
 777     // Restore own indicator opacity
 778     // Send opacity mode to indicator service when app resumed
 779     mIndicator->SetOpacityMode( mIndicatorOpacityMode );
 780   }
 781 }
 782
 783 void Window::OnStop()
 784 {
 785   if( mIndicator )
 786   {
 787     mIndicator->Close();
 788   }
 789
 790   delete mIndicator;
 791   mIndicator = NULL;
 792 }
 793
 794 void Window::OnDestroy()
 795 {
 796   mAdaptor = NULL;
 797 }
 798
 799 void Window::AddAvailableOrientation(Dali::Window::WindowOrientation orientation)
 800 {
 801   bool found = false;
 802
 803   for( std::size_t i=0; i<mAvailableOrientations.size(); i++ )
 804   {
 805     if(mAvailableOrientations[i] == orientation)
 806     {
 807       found = true;
 808       break;
 809     }
 810   }
 811
 812   if( ! found )
 813   {
 814     mAvailableOrientations.push_back(orientation);
 815     SetAvailableOrientations( mAvailableOrientations );
 816   }
 817 }
 818
 819 void Window::RemoveAvailableOrientation(Dali::Window::WindowOrientation orientation)
 820 {
 821   for( std::vector<Dali::Window::WindowOrientation>::iterator iter = mAvailableOrientations.begin();
 822        iter != mAvailableOrientations.end(); ++iter )
 823   {
 824     if( *iter == orientation )
 825     {
 826       mAvailableOrientations.erase( iter );
 827       break;
 828     }
 829   }
 830   SetAvailableOrientations( mAvailableOrientations );
 831 }
 832
 833 void Window::SetAvailableOrientations(const std::vector<Dali::Window::WindowOrientation>& orientations)
 834 {
 835   int rotations[4];
 836   for( std::size_t i = 0; i < mAvailableOrientations.size(); ++i )
 837   {
 838     rotations[i] = static_cast< int >( mAvailableOrientations[i] );
 839   }
 840   ecore_wl_window_rotation_available_rotations_set( mEventHandler->mEcoreWindow, rotations, mAvailableOrientations.size() );
 841 }
 842
 843 const std::vector<Dali::Window::WindowOrientation>& Window::GetAvailableOrientations()
 844 {
 845   return mAvailableOrientations;
 846 }
 847
 848 void Window::SetPreferredOrientation(Dali::Window::WindowOrientation orientation)
 849 {
 850   mPreferredOrientation = orientation;
 851
 852   ecore_wl_window_rotation_preferred_rotation_set( mEventHandler->mEcoreWindow, orientation );
 853 }
 854
 855 Dali::Window::WindowOrientation Window::GetPreferredOrientation()
 856 {
 857   return mPreferredOrientation;
 858 }
 859
 860 void Window::SetAcceptFocus( bool accept )
 861 {
 862   mIsFocusAcceptable = accept;
 863
 864   ecore_wl_window_focus_skip_set( mEventHandler->mEcoreWindow, !accept );
 865 }
 866
 867 bool Window::IsFocusAcceptable() const
 868 {
 869   return mIsFocusAcceptable;
 870 }
 871
 872 void Window::Show()
 873 {
 874   mVisible = true;
 875   ecore_wl_window_show( mEventHandler->mEcoreWindow );
 876
 877   // Need an update request
 878   if( mAdaptor )
 879   {
 880     mAdaptor->RequestUpdateOnce();
 881   }
 882 }
 883
 884 void Window::Hide()
 885 {
 886   mVisible = false;
 887   ecore_wl_window_hide( mEventHandler->mEcoreWindow );
 888 }
 889
 890 bool Window::IsVisible() const
 891 {
 892   return mVisible;
 893 }
 894
 895 void Window::RotationDone( int orientation, int width, int height )
 896 {
 897   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 898   if( wlSurface )
 899   {
 900     wlSurface->RequestRotation( orientation, width, height );
 901   }
 902
 903   mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) );
 904
 905   // Emit signal
 906   mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
 907
 908   mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) );
 909 }
 910
 911 void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
 912 {
 913   mIndicatorVisible = mode;
 914 }
 915
 916 unsigned int Window::GetSupportedAuxiliaryHintCount() const
 917 {
 918   return mSupportedAuxiliaryHints.size();
 919 }
 920
 921 std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const
 922 {
 923   if( index >= GetSupportedAuxiliaryHintCount() )
 924   {
 925     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
 926   }
 927
 928   return mSupportedAuxiliaryHints[index];
 929 }
 930
 931 unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 932 {
 933   bool supported = false;
 934
 935   // Check if the hint is suppported
 936   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
 937   {
 938     if( *iter == hint )
 939     {
 940       supported = true;
 941       break;
 942     }
 943   }
 944
 945   if( !supported )
 946   {
 947     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
 948     return 0;
 949   }
 950
 951   // Check if the hint is already added
 952   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
 953   {
 954     if( mAuxiliaryHints[i].first == hint )
 955     {
 956       // Just change the value
 957       mAuxiliaryHints[i].second = value;
 958
 959       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
 960
 961       return i + 1;   // id is index + 1
 962     }
 963   }
 964
 965   // Add the hint
 966   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
 967
 968   unsigned int id = mAuxiliaryHints.size();
 969
 970   ecore_wl_window_aux_hint_add( mEventHandler->mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
 971
 972   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
 973
 974   return id;
 975 }
 976
 977 bool Window::RemoveAuxiliaryHint( unsigned int id )
 978 {
 979   if( id == 0 || id > mAuxiliaryHints.size() )
 980   {
 981     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
 982     return false;
 983   }
 984
 985   mAuxiliaryHints[id - 1].second = std::string();
 986
 987   ecore_wl_window_aux_hint_del( mEventHandler->mEcoreWindow, static_cast< int >( id ) );
 988
 989   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
 990
 991   return true;
 992 }
 993
 994 bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 995 {
 996   if( id == 0 || id > mAuxiliaryHints.size() )
 997   {
 998     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
 999     return false;
1000   }
1001
1002   mAuxiliaryHints[id - 1].second = value;
1003
1004   ecore_wl_window_aux_hint_change( mEventHandler->mEcoreWindow, static_cast< int >( id ), value.c_str() );
1005
1006   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() );
1007
1008   return true;
1009 }
1010
1011 std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
1012 {
1013   if( id == 0 || id > mAuxiliaryHints.size() )
1014   {
1015     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1016     return std::string();
1017   }
1018
1019   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() );
1020
1021   return mAuxiliaryHints[id - 1].second;
1022 }
1023
1024 unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
1025 {
1026   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1027   {
1028     if( mAuxiliaryHints[i].first == hint )
1029     {
1030       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1031       return i + 1;
1032     }
1033   }
1034
1035   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1036
1037   return 0;
1038 }
1039
1040 void Window::SetInputRegion( const Rect< int >& inputRegion )
1041 {
1042   ecore_wl_window_input_region_set( mEventHandler->mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1043
1044   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 );
1045 }
1046
1047 void Window::SetType( Dali::Window::Type type )
1048 {
1049   Ecore_Wl_Window_Type windowType;
1050
1051   if( type != mType )
1052   {
1053     switch( type )
1054     {
1055       case Dali::Window::NORMAL:
1056       {
1057         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1058         break;
1059       }
1060       case Dali::Window::NOTIFICATION:
1061       {
1062         windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1063         break;
1064       }
1065       case Dali::Window::UTILITY:
1066       {
1067         windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1068         break;
1069       }
1070       case Dali::Window::DIALOG:
1071       {
1072         windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1073         break;
1074       }
1075       default:
1076       {
1077         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1078         break;
1079       }
1080     }
1081
1082     ecore_wl_window_type_set( mEventHandler->mEcoreWindow, windowType );
1083   }
1084
1085   mType = type;
1086 }
1087
1088 Dali::Window::Type Window::GetType() const
1089 {
1090   return mType;
1091 }
1092
1093 bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1094 {
1095   if( mType != Dali::Window::NOTIFICATION )
1096   {
1097     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType );
1098     return false;
1099   }
1100
1101   while( !mEventHandler->mTizenPolicy )
1102   {
1103     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1104   }
1105
1106   int notificationLevel;
1107
1108   switch( level )
1109   {
1110     case Dali::Window::NotificationLevel::NONE:
1111     {
1112       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1113       break;
1114     }
1115     case Dali::Window::NotificationLevel::BASE:
1116     {
1117       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1118       break;
1119     }
1120     case Dali::Window::NotificationLevel::MEDIUM:
1121     {
1122       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1123       break;
1124     }
1125     case Dali::Window::NotificationLevel::HIGH:
1126     {
1127       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1128       break;
1129     }
1130     case Dali::Window::NotificationLevel::TOP:
1131     {
1132       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1133       break;
1134     }
1135     default:
1136     {
1137       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: invalid level [%d]\n", level );
1138       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1139       break;
1140     }
1141   }
1142
1143   mEventHandler->mNotificationLevelChangeDone = false;
1144   mEventHandler->mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1145
1146   tizen_policy_set_notification_level( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), notificationLevel );
1147
1148   int count = 0;
1149
1150   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1151   {
1152     ecore_wl_flush();
1153     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1154     count++;
1155   }
1156
1157   if( !mEventHandler->mNotificationLevelChangeDone )
1158   {
1159     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mEventHandler->mNotificationChangeState );
1160     return false;
1161   }
1162   else if( mEventHandler->mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1163   {
1164     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Permission denied! [%d]\n", level );
1165     return false;
1166   }
1167
1168   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level is changed [%d]\n", mEventHandler->mNotificationLevel );
1169
1170   return true;
1171 }
1172
1173 Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const
1174 {
1175   if( mType != Dali::Window::NOTIFICATION )
1176   {
1177     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType );
1178     return Dali::Window::NotificationLevel::NONE;
1179   }
1180
1181   while( !mEventHandler->mTizenPolicy )
1182   {
1183     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1184   }
1185
1186   int count = 0;
1187
1188   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1189   {
1190     ecore_wl_flush();
1191     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1192     count++;
1193   }
1194
1195   if( !mEventHandler->mNotificationLevelChangeDone )
1196   {
1197     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState );
1198     return Dali::Window::NotificationLevel::NONE;
1199   }
1200
1201   Dali::Window::NotificationLevel::Type level;
1202
1203   switch( mEventHandler->mNotificationLevel )
1204   {
1205     case TIZEN_POLICY_LEVEL_NONE:
1206     {
1207       level = Dali::Window::NotificationLevel::NONE;
1208       break;
1209     }
1210     case TIZEN_POLICY_LEVEL_DEFAULT:
1211     {
1212       level = Dali::Window::NotificationLevel::BASE;
1213       break;
1214     }
1215     case TIZEN_POLICY_LEVEL_MEDIUM:
1216     {
1217       level = Dali::Window::NotificationLevel::MEDIUM;
1218       break;
1219     }
1220     case TIZEN_POLICY_LEVEL_HIGH:
1221     {
1222       level = Dali::Window::NotificationLevel::HIGH;
1223       break;
1224     }
1225     case TIZEN_POLICY_LEVEL_TOP:
1226     {
1227       level = Dali::Window::NotificationLevel::TOP;
1228       break;
1229     }
1230     default:
1231     {
1232       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel );
1233       level = Dali::Window::NotificationLevel::NONE;
1234       break;
1235     }
1236   }
1237
1238   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: level [%d]\n", mEventHandler->mNotificationLevel );
1239
1240   return level;
1241 }
1242
1243 void Window::SetOpaqueState( bool opaque )
1244 {
1245   while( !mEventHandler->mTizenPolicy )
1246   {
1247     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1248   }
1249
1250   tizen_policy_set_opaque_state( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), ( opaque ? 1 : 0 ) );
1251
1252   mOpaqueState = opaque;
1253
1254   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque );
1255 }
1256
1257 bool Window::IsOpaqueState() const
1258 {
1259   return mOpaqueState;
1260 }
1261
1262 bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1263 {
1264   while( !mEventHandler->mTizenPolicy )
1265   {
1266     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1267   }
1268
1269   mEventHandler->mScreenOffModeChangeDone = false;
1270   mEventHandler->mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1271
1272   unsigned int mode = 0;
1273
1274   switch( screenOffMode )
1275   {
1276     case Dali::Window::ScreenOffMode::TIMEOUT:
1277     {
1278       mode = 0;
1279       break;
1280     }
1281     case Dali::Window::ScreenOffMode::NEVER:
1282     {
1283       mode = 1;
1284       break;
1285     }
1286   }
1287
1288   tizen_policy_set_window_screen_mode( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), mode );
1289
1290   int count = 0;
1291
1292   while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
1293   {
1294     ecore_wl_flush();
1295     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1296     count++;
1297   }
1298
1299   if( !mEventHandler->mScreenOffModeChangeDone )
1300   {
1301     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mEventHandler->mScreenOffModeChangeState );
1302     return false;
1303   }
1304   else if( mEventHandler->mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1305   {
1306     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
1307     return false;
1308   }
1309
1310   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode is changed [%d]\n", mEventHandler->mScreenOffMode );
1311
1312   return true;
1313 }
1314
1315 Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const
1316 {
1317   while( !mEventHandler->mTizenPolicy )
1318   {
1319     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1320   }
1321
1322   int count = 0;
1323
1324   while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
1325   {
1326     ecore_wl_flush();
1327     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1328     count++;
1329   }
1330
1331   if( !mEventHandler->mScreenOffModeChangeDone )
1332   {
1333     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: Error! [%d]\n", mEventHandler->mScreenOffModeChangeState );
1334     return Dali::Window::ScreenOffMode::TIMEOUT;
1335   }
1336
1337   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1338
1339   switch( mEventHandler->mScreenOffMode )
1340   {
1341     case 0:
1342     {
1343       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1344       break;
1345     }
1346     case 1:
1347     {
1348       screenMode = Dali::Window::ScreenOffMode::NEVER;
1349       break;
1350     }
1351   }
1352
1353   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: screen mode [%d]\n", mEventHandler->mScreenOffMode );
1354
1355   return screenMode;
1356 }
1357
1358 bool Window::SetBrightness( int brightness )
1359 {
1360   if( brightness < 0 || brightness > 100 )
1361   {
1362     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness );
1363     return false;
1364   }
1365
1366   while( !mEventHandler->mTizenDisplayPolicy )
1367   {
1368     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1369   }
1370
1371   mEventHandler->mBrightnessChangeDone = false;
1372   mEventHandler->mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1373
1374   tizen_display_policy_set_window_brightness( mEventHandler->mTizenDisplayPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), brightness );
1375
1376   int count = 0;
1377
1378   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1379   {
1380     ecore_wl_flush();
1381     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1382     count++;
1383   }
1384
1385   if( !mEventHandler->mBrightnessChangeDone )
1386   {
1387     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mEventHandler->mBrightnessChangeState );
1388     return false;
1389   }
1390   else if( mEventHandler->mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1391   {
1392     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Permission denied! [%d]\n", brightness );
1393     return false;
1394   }
1395
1396   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness is changed [%d]\n", mEventHandler->mBrightness );
1397
1398   return true;
1399 }
1400
1401 int Window::GetBrightness() const
1402 {
1403   while( !mEventHandler->mTizenDisplayPolicy )
1404   {
1405     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1406   }
1407
1408   int count = 0;
1409
1410   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1411   {
1412     ecore_wl_flush();
1413     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1414     count++;
1415   }
1416
1417   if( !mEventHandler->mBrightnessChangeDone )
1418   {
1419     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Error! [%d]\n", mEventHandler->mBrightnessChangeState );
1420     return 0;
1421   }
1422
1423   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Brightness [%d]\n", mEventHandler->mBrightness );
1424
1425   return mEventHandler->mBrightness;
1426 }
1427
1428 void Window::SetSize( Dali::Window::WindowSize size )
1429 {
1430   if( !mResizeEnabled )
1431   {
1432     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
1433     mResizeEnabled = true;
1434   }
1435
1436   PositionSize positionSize = mSurface->GetPositionSize();
1437
1438   if( positionSize.width != size.GetWidth() || positionSize.height != size.GetHeight() )
1439   {
1440     positionSize.width = size.GetWidth();
1441     positionSize.height = size.GetHeight();
1442
1443     mSurface->MoveResize( positionSize );
1444
1445     mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
1446
1447     // Emit signal
1448     mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) );
1449
1450     mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
1451   }
1452 }
1453
1454 Dali::Window::WindowSize Window::GetSize() const
1455 {
1456   PositionSize positionSize = mSurface->GetPositionSize();
1457
1458   return Dali::Window::WindowSize( positionSize.width, positionSize.height );
1459 }
1460
1461 void Window::SetPosition( Dali::Window::WindowPosition position )
1462 {
1463   if( !mResizeEnabled )
1464   {
1465     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
1466     mResizeEnabled = true;
1467   }
1468
1469   PositionSize positionSize = mSurface->GetPositionSize();
1470
1471   if( positionSize.x != position.GetX() || positionSize.y != position.GetY() )
1472   {
1473     positionSize.x = position.GetX();
1474     positionSize.y = position.GetY();
1475
1476     mSurface->MoveResize( positionSize );
1477   }
1478 }
1479
1480 Dali::Window::WindowPosition Window::GetPosition() const
1481 {
1482   PositionSize positionSize = mSurface->GetPositionSize();
1483
1484   return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
1485 }
1486
1487 void Window::SetTransparency( bool transparent )
1488 {
1489   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
1490   if( wlSurface )
1491   {
1492     wlSurface->SetTransparency( transparent );
1493   }
1494 }
1495
1496 } // Adaptor
1497
1498 } // Internal
1499
1500 } // Dali
1501
1502 #pragma GCC diagnostic pop