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     mWindowPropertyHandler( NULL ),
  72     mWindowIconifyStateHandler( NULL ),
  73     mWindowVisibilityStateHandler( NULL ),
  74     mWindowFocusInHandler( NULL ),
  75     mWindowFocusOutHandler( NULL ),
  76     mEcoreWindow( 0 ),
  77     mDisplay( NULL ),
  78     mEventQueue( NULL ),
  79     mTizenPolicy( NULL ),
  80     mTizenDisplayPolicy( NULL ),
  81     mNotificationLevel( -1 ),
  82     mNotificationChangeState( 0 ),
  83     mNotificationLevelChangeDone( true ),
  84     mScreenMode( 0 ),
  85     mScreenModeChangeState( 0 ),
  86     mScreenModeChangeDone( true ),
  87     mBrightness( 0 ),
  88     mBrightnessChangeState( 0 ),
  89     mBrightnessChangeDone( true )
  90   {
  91     // store ecore window handle
  92     ECore::WindowRenderSurface* wlWindow( dynamic_cast< ECore::WindowRenderSurface * >( mWindow->mSurface ) );
  93     if( wlWindow )
  94     {
  95       mEcoreWindow = wlWindow->GetWlWindow();
  96     }
  97     DALI_ASSERT_ALWAYS( mEcoreWindow != 0 && "There is no ecore Wl window");
  98
  99     if( mWindow->mEcoreEventHander )
 100     {
 101       mWindowIconifyStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this );
 102       mWindowVisibilityStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, EcoreEventWindowVisibilityChanged, this );
 103       mWindowFocusInHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this );
 104       mWindowFocusOutHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this );
 105     }
 106
 107     mDisplay = ecore_wl_display_get();
 108
 109     if( mDisplay )
 110     {
 111       wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) );
 112       if( displayWrapper )
 113       {
 114         mEventQueue = wl_display_create_queue( mDisplay );
 115         if( mEventQueue )
 116         {
 117           wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue );
 118
 119           wl_registry* registry = wl_display_get_registry( displayWrapper );
 120           wl_registry_add_listener( registry, &mRegistryListener, this );
 121         }
 122
 123         wl_proxy_wrapper_destroy( displayWrapper );
 124       }
 125     }
 126   }
 127
 128   /**
 129    * Destructor
 130    */
 131   ~EventHandler()
 132   {
 133     if ( mWindowPropertyHandler )
 134     {
 135       ecore_event_handler_del( mWindowPropertyHandler );
 136     }
 137
 138     if ( mWindowIconifyStateHandler )
 139     {
 140       ecore_event_handler_del( mWindowIconifyStateHandler );
 141     }
 142
 143     if ( mWindowVisibilityStateHandler )
 144     {
 145       ecore_event_handler_del( mWindowVisibilityStateHandler );
 146     }
 147
 148     if( mWindowFocusInHandler )
 149     {
 150       ecore_event_handler_del( mWindowFocusInHandler );
 151     }
 152
 153     if( mWindowFocusOutHandler )
 154     {
 155       ecore_event_handler_del( mWindowFocusOutHandler );
 156     }
 157
 158     if( mEventQueue )
 159     {
 160       wl_event_queue_destroy( mEventQueue );
 161     }
 162   }
 163
 164   // Static methods
 165
 166   /// Called when the window properties are changed.
 167   static Eina_Bool EcoreEventWindowPropertyChanged( void* data, int type, void* event )
 168   {
 169     return EINA_FALSE;
 170   }
 171
 172   /// Called when the window iconify state is changed.
 173   static Eina_Bool EcoreEventWindowIconifyStateChanged( void* data, int type, void* event )
 174   {
 175     Ecore_Wl_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl_Event_Window_Iconify_State_Change* >( event ) );
 176     EventHandler* handler( static_cast< EventHandler* >( data ) );
 177     Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 178
 179     if ( handler && handler->mWindow )
 180     {
 181       WindowVisibilityObserver* observer( handler->mWindow->mAdaptor );
 182       if ( observer && ( iconifyChangedEvent->win == static_cast< unsigned int> ( ecore_wl_window_id_get( handler->mEcoreWindow ) ) ) )
 183       {
 184         if( iconifyChangedEvent->iconified == EINA_TRUE )
 185         {
 186           observer->OnWindowHidden();
 187           DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Iconfied\n", handler->mEcoreWindow );
 188         }
 189         else
 190         {
 191           observer->OnWindowShown();
 192           DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow );
 193         }
 194         handled = ECORE_CALLBACK_DONE;
 195       }
 196     }
 197
 198     return handled;
 199   }
 200
 201   /// Called when the window visibility is changed.
 202   static Eina_Bool EcoreEventWindowVisibilityChanged( void* data, int type, void* event )
 203   {
 204     Ecore_Wl_Event_Window_Visibility_Change* visibilityChangedEvent( static_cast< Ecore_Wl_Event_Window_Visibility_Change* >( event ) );
 205     EventHandler* handler( static_cast< EventHandler* >( data ) );
 206     Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 207
 208     if ( handler && handler->mWindow )
 209     {
 210       WindowVisibilityObserver* observer( handler->mWindow->mAdaptor );
 211       if ( observer && ( visibilityChangedEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( handler->mEcoreWindow ) ) ) )
 212       {
 213         if( visibilityChangedEvent->fully_obscured == 1 )
 214         {
 215           observer->OnWindowHidden();
 216           DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) full obscured\n", handler->mEcoreWindow );
 217         }
 218         else
 219         {
 220           observer->OnWindowShown();
 221           DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow );
 222         }
 223         handled = ECORE_CALLBACK_DONE;
 224       }
 225     }
 226
 227     return handled;
 228   }
 229
 230   /// Called when the window gains focus
 231   static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
 232   {
 233     Ecore_Wl_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl_Event_Focus_In* >( event ) );
 234     EventHandler* handler( static_cast< EventHandler* >( data ) );
 235
 236     if ( handler && handler->mWindow && focusInEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( handler->mEcoreWindow ) ) )
 237     {
 238       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
 239
 240       handler->mWindow->mFocusChangedSignal.Emit( true );
 241     }
 242
 243     return ECORE_CALLBACK_PASS_ON;
 244   }
 245
 246   /// Called when the window loses focus
 247   static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
 248   {
 249     Ecore_Wl_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl_Event_Focus_Out* >( event ) );
 250     EventHandler* handler( static_cast< EventHandler* >( data ) );
 251
 252     if ( handler && handler->mWindow && focusOutEvent->win == static_cast< unsigned int >(ecore_wl_window_id_get( handler->mEcoreWindow ) ) )
 253     {
 254       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
 255
 256       handler->mWindow->mFocusChangedSignal.Emit( false );
 257     }
 258
 259     return ECORE_CALLBACK_PASS_ON;
 260   }
 261
 262   static void RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
 263   {
 264     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 265
 266     if( strcmp( interface, tizen_policy_interface.name ) == 0 )
 267     {
 268       eventHandler->mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, version ) );
 269       if( !eventHandler->mTizenPolicy )
 270       {
 271         DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" );
 272         return;
 273       }
 274
 275       tizen_policy_add_listener( eventHandler->mTizenPolicy, &eventHandler->mTizenPolicyListener, data );
 276
 277       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" );
 278     }
 279     else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 )
 280     {
 281       eventHandler->mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) );
 282       if( !eventHandler->mTizenDisplayPolicy )
 283       {
 284         DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" );
 285         return;
 286       }
 287
 288       tizen_display_policy_add_listener( eventHandler->mTizenDisplayPolicy, &eventHandler->mTizenDisplayPolicyListener, data );
 289
 290       DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" );
 291     }
 292   }
 293
 294   static void RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
 295   {
 296     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 297     eventHandler->mTizenPolicy = NULL;
 298     eventHandler->mTizenDisplayPolicy = NULL;
 299   }
 300
 301   static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
 302   {
 303     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 304
 305     eventHandler->mNotificationLevel = level;
 306     eventHandler->mNotificationChangeState = state;
 307     eventHandler->mNotificationLevelChangeDone = true;
 308
 309     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state );
 310   }
 311
 312   static void TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
 313   {
 314     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 315
 316     eventHandler->mScreenMode = mode;
 317     eventHandler->mScreenModeChangeState = state;
 318     eventHandler->mScreenModeChangeDone = true;
 319
 320     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
 321   }
 322
 323   static void DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
 324   {
 325     Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
 326
 327     eventHandler->mBrightness = brightness;
 328     eventHandler->mBrightnessChangeState = state;
 329     eventHandler->mBrightnessChangeDone = true;
 330
 331     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
 332   }
 333
 334   const struct wl_registry_listener mRegistryListener =
 335   {
 336      RegistryGlobalCallback,
 337      RegistryGlobalCallbackRemove
 338   };
 339
 340   const struct tizen_policy_listener mTizenPolicyListener =
 341   {
 342      NULL,
 343      NULL,
 344      TizenPolicyNotificationChangeDone,
 345      NULL,
 346      TizenPolicyScreenModeChangeDone,
 347      NULL,
 348      NULL,
 349      NULL,
 350      NULL
 351   };
 352
 353   const struct tizen_display_policy_listener mTizenDisplayPolicyListener =
 354   {
 355     DisplayPolicyBrightnessChangeDone
 356   };
 357
 358   // Data
 359   Window* mWindow;
 360   Ecore_Event_Handler* mWindowPropertyHandler;
 361   Ecore_Event_Handler* mWindowIconifyStateHandler;
 362   Ecore_Event_Handler* mWindowVisibilityStateHandler;
 363   Ecore_Event_Handler* mWindowFocusInHandler;
 364   Ecore_Event_Handler* mWindowFocusOutHandler;
 365   Ecore_Wl_Window* mEcoreWindow;
 366
 367   wl_display* mDisplay;
 368   wl_event_queue* mEventQueue;
 369   tizen_policy* mTizenPolicy;
 370   tizen_display_policy* mTizenDisplayPolicy;
 371
 372   int mNotificationLevel;
 373   uint32_t mNotificationChangeState;
 374   bool mNotificationLevelChangeDone;
 375
 376   int mScreenMode;
 377   uint32_t mScreenModeChangeState;
 378   bool mScreenModeChangeDone;
 379
 380   int mBrightness;
 381   uint32_t mBrightnessChangeState;
 382   bool mBrightnessChangeDone;
 383 };
 384
 385 Window* Window::New(const PositionSize& posSize, const std::string& name, const std::string& className, bool isTransparent)
 386 {
 387   Window* window = new Window();
 388   window->mIsTransparent = isTransparent;
 389   window->Initialize(posSize, name, className);
 390   return window;
 391 }
 392
 393 void Window::SetAdaptor(Dali::Adaptor& adaptor)
 394 {
 395   DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
 396   mStarted = true;
 397
 398   // Only create one overlay per window
 399   Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
 400   Integration::Core& core = adaptorImpl.GetCore();
 401   mOverlay = &core.GetSystemOverlay();
 402
 403   Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
 404   taskList.CreateTask();
 405
 406   mAdaptor = &adaptorImpl;
 407   mAdaptor->AddObserver( *this );
 408
 409   // Can only create the detector when we know the Core has been instantiated.
 410   mDragAndDropDetector = DragAndDropDetector::New();
 411   mAdaptor->SetDragAndDropDetector( &GetImplementation( mDragAndDropDetector ) );
 412
 413   if( mOrientation )
 414   {
 415     mOrientation->SetAdaptor(adaptor);
 416   }
 417
 418   if( mIndicator != NULL )
 419   {
 420     mIndicator->SetAdaptor(mAdaptor);
 421   }
 422 }
 423
 424 RenderSurface* Window::GetSurface()
 425 {
 426   return mSurface;
 427 }
 428
 429 void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
 430 {
 431   DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "visible : %d\n", visibleMode );
 432   DALI_ASSERT_DEBUG(mOverlay);
 433
 434   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 435   DALI_ASSERT_DEBUG(wlSurface);
 436
 437   if( wlSurface )
 438   {
 439     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 440
 441     mIndicatorVisible = visibleMode;
 442
 443     if ( mIndicatorVisible == Dali::Window::VISIBLE )
 444     {
 445       // when the indicator is visible, set proper mode for indicator server according to bg mode
 446       if ( mIndicatorOpacityMode == Dali::Window::OPAQUE )
 447       {
 448         ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
 449       }
 450       else if ( mIndicatorOpacityMode == Dali::Window::TRANSLUCENT )
 451       {
 452         ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSLUCENT);
 453       }
 454       else if ( mIndicatorOpacityMode == Dali::Window::TRANSPARENT )
 455       {
 456         ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
 457       }
 458     }
 459     else
 460     {
 461       // when the indicator is not visible, set TRANSPARENT mode for indicator server
 462       ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSPARENT); // it means hidden indicator
 463     }
 464   }
 465
 466   DoShowIndicator( mIndicatorOrientation );
 467 }
 468
 469 void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )
 470 {
 471   DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "Orientation: %d\n", orientation );
 472
 473   DoRotateIndicator( orientation );
 474 }
 475
 476 void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode )
 477 {
 478   mIndicatorOpacityMode = opacityMode;
 479
 480   if( mIndicator != NULL )
 481   {
 482     mIndicator->SetOpacityMode( opacityMode );
 483   }
 484 }
 485
 486 void Window::SetClass(std::string name, std::string klass)
 487 {
 488   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 489
 490   if( wlSurface )
 491   {
 492     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 493     ecore_wl_window_title_set( wlWindow, name.c_str() );
 494     ecore_wl_window_class_name_set( wlWindow, klass.c_str() );
 495   }
 496   else
 497   {
 498     DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window has no surface\n" );
 499   }
 500 }
 501
 502 Window::Window()
 503 : mSurface( NULL ),
 504   mIndicatorVisible( Dali::Window::VISIBLE ),
 505   mIndicatorIsShown( false ),
 506   mShowRotatedIndicatorOnClose( false ),
 507   mStarted( false ),
 508   mIsTransparent( false ),
 509   mWMRotationAppSet( false ),
 510   mEcoreEventHander( true ),
 511   mIsFocusAcceptable( true ),
 512   mVisible( true ),
 513   mOpaqueState( false ),
 514   mIndicator( NULL ),
 515   mIndicatorOrientation( Dali::Window::PORTRAIT ),
 516   mNextIndicatorOrientation( Dali::Window::PORTRAIT ),
 517   mIndicatorOpacityMode( Dali::Window::OPAQUE ),
 518   mOverlay( NULL ),
 519   mAdaptor( NULL ),
 520   mType( Dali::DevelWindow::NORMAL ),
 521   mEventHandler( NULL ),
 522   mPreferredOrientation( Dali::Window::PORTRAIT ),
 523   mSupportedAuxiliaryHints(),
 524   mAuxiliaryHints()
 525 {
 526 }
 527
 528 Window::~Window()
 529 {
 530   delete mEventHandler;
 531
 532   if( mIndicator )
 533   {
 534     mIndicator->Close();
 535     delete mIndicator;
 536   }
 537
 538   if ( mAdaptor )
 539   {
 540     mAdaptor->RemoveObserver( *this );
 541     mAdaptor->SetDragAndDropDetector( NULL );
 542     mAdaptor = NULL;
 543   }
 544
 545   delete mSurface;
 546
 547   mSupportedAuxiliaryHints.clear();
 548   mAuxiliaryHints.clear();
 549 }
 550
 551 void Window::Initialize(const PositionSize& windowPosition, const std::string& name, const std::string& className)
 552 {
 553   // create an Wayland window by default
 554   Any surface;
 555   ECore::WindowRenderSurface* windowSurface = new ECore::WindowRenderSurface( windowPosition, surface, name, mIsTransparent );
 556
 557   mSurface = windowSurface;
 558   SetClass( name, className );
 559   windowSurface->Map();
 560
 561   mOrientation = Orientation::New(this);
 562
 563   // create event handler for Wayland window
 564   mEventHandler = new EventHandler( this );
 565
 566   // get auxiliary hint
 567   Eina_List* hints = ecore_wl_window_aux_hints_supported_get( mEventHandler->mEcoreWindow );
 568   if( hints )
 569   {
 570     Eina_List* l = NULL;
 571     char* hint = NULL;
 572
 573     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) ) ) )
 574     {
 575       mSupportedAuxiliaryHints.push_back( hint );
 576
 577       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::Initialize: %s\n", hint );
 578     }
 579   }
 580 }
 581
 582 void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
 583 {
 584   if( mIndicator == NULL )
 585   {
 586     if( mIndicatorVisible != Dali::Window::INVISIBLE )
 587     {
 588       mIndicator = new Indicator( mAdaptor, mIndicatorOrientation, this );
 589       mIndicator->SetOpacityMode( mIndicatorOpacityMode );
 590       Dali::Actor actor = mIndicator->GetActor();
 591       SetIndicatorActorRotation();
 592       mOverlay->Add(actor);
 593     }
 594     // else don't create a hidden indicator
 595   }
 596   else // Already have indicator
 597   {
 598     if( mIndicatorVisible == Dali::Window::VISIBLE )
 599     {
 600       // If we are resuming, and rotation has changed,
 601       if( mIndicatorIsShown == false && mIndicatorOrientation != mNextIndicatorOrientation )
 602       {
 603         // then close current indicator and open new one
 604         mShowRotatedIndicatorOnClose = true;
 605         mIndicator->Close(); // May synchronously call IndicatorClosed() callback & 1 level of recursion
 606         // Don't show actor - will contain indicator for old orientation.
 607       }
 608     }
 609   }
 610
 611   // set indicator visible mode
 612   if( mIndicator != NULL )
 613   {
 614     mIndicator->SetVisible( mIndicatorVisible );
 615   }
 616
 617   bool show = (mIndicatorVisible != Dali::Window::INVISIBLE );
 618   SetIndicatorProperties( show, lastOrientation );
 619   mIndicatorIsShown = show;
 620 }
 621
 622 void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation )
 623 {
 624   if( mIndicatorIsShown )
 625   {
 626     mShowRotatedIndicatorOnClose = true;
 627     mNextIndicatorOrientation = orientation;
 628     mIndicator->Close(); // May synchronously call IndicatorClosed() callback
 629   }
 630   else
 631   {
 632     // Save orientation for when the indicator is next shown
 633     mShowRotatedIndicatorOnClose = false;
 634     mNextIndicatorOrientation = orientation;
 635   }
 636 }
 637
 638 void Window::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation )
 639 {
 640   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 641
 642   if( wlSurface )
 643   {
 644     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 645     if ( isShow )
 646     {
 647       ecore_wl_window_indicator_state_set(wlWindow, ECORE_WL_INDICATOR_STATE_ON);
 648     }
 649     else
 650     {
 651       ecore_wl_window_indicator_state_set(wlWindow, ECORE_WL_INDICATOR_STATE_OFF);
 652     }
 653   }
 654 }
 655
 656 void Window::IndicatorTypeChanged(Indicator::Type type)
 657 {
 658 #if defined(DALI_PROFILE_MOBILE)
 659   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 660
 661   if( wlSurface )
 662   {
 663     Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
 664     switch(type)
 665     {
 666       case Indicator::INDICATOR_TYPE_1:
 667         ecore_wl_indicator_visible_type_set(wlWindow, ECORE_WL_INDICATOR_VISIBLE_TYPE_SHOWN);
 668         break;
 669
 670       case Indicator::INDICATOR_TYPE_2:
 671         ecore_wl_indicator_visible_type_set(wlWindow, ECORE_WL_INDICATOR_VISIBLE_TYPE_HIDDEN);
 672         break;
 673
 674       case Indicator::INDICATOR_TYPE_UNKNOWN:
 675       default:
 676         break;
 677     }
 678   }
 679 #endif //MOBILE
 680 }
 681
 682 void Window::IndicatorClosed( IndicatorInterface* indicator )
 683 {
 684   DALI_LOG_TRACE_METHOD( gWindowLogFilter );
 685
 686   if( mShowRotatedIndicatorOnClose )
 687   {
 688     Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation;
 689     mIndicator->Open(mNextIndicatorOrientation);
 690     mIndicatorOrientation = mNextIndicatorOrientation;
 691     SetIndicatorActorRotation();
 692     DoShowIndicator(currentOrientation);
 693   }
 694 }
 695
 696 void Window::IndicatorVisibilityChanged(bool isVisible)
 697 {
 698   mIndicatorVisibilityChangedSignal.Emit(isVisible);
 699 }
 700
 701 void Window::SetIndicatorActorRotation()
 702 {
 703   DALI_LOG_TRACE_METHOD( gWindowLogFilter );
 704   DALI_ASSERT_DEBUG( mIndicator != NULL );
 705
 706   Dali::Actor actor = mIndicator->GetActor();
 707   switch( mIndicatorOrientation )
 708   {
 709     case Dali::Window::PORTRAIT:
 710       actor.SetParentOrigin( ParentOrigin::TOP_CENTER );
 711       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 712       actor.SetOrientation( Degree(0), Vector3::ZAXIS );
 713       break;
 714     case Dali::Window::PORTRAIT_INVERSE:
 715       actor.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
 716       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 717       actor.SetOrientation( Degree(180), Vector3::ZAXIS );
 718       break;
 719     case Dali::Window::LANDSCAPE:
 720       actor.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 721       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 722       actor.SetOrientation( Degree(270), Vector3::ZAXIS );
 723       break;
 724     case Dali::Window::LANDSCAPE_INVERSE:
 725       actor.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
 726       actor.SetAnchorPoint(  AnchorPoint::TOP_CENTER );
 727       actor.SetOrientation( Degree(90), Vector3::ZAXIS );
 728       break;
 729   }
 730 }
 731
 732 void Window::Raise()
 733 {
 734   ecore_wl_window_raise( 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()
 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_wl_window_rotation_change_done_send( mEventHandler->mEcoreWindow );
 899 }
 900
 901 unsigned int Window::GetSupportedAuxiliaryHintCount()
 902 {
 903   return mSupportedAuxiliaryHints.size();
 904 }
 905
 906 std::string Window::GetSupportedAuxiliaryHint( unsigned int index )
 907 {
 908   if( index >= GetSupportedAuxiliaryHintCount() )
 909   {
 910     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
 911   }
 912
 913   return mSupportedAuxiliaryHints[index];
 914 }
 915
 916 unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 917 {
 918   bool supported = false;
 919
 920   // Check if the hint is suppported
 921   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
 922   {
 923     if( *iter == hint )
 924     {
 925       supported = true;
 926       break;
 927     }
 928   }
 929
 930   if( !supported )
 931   {
 932     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
 933     return 0;
 934   }
 935
 936   // Check if the hint is already added
 937   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
 938   {
 939     if( mAuxiliaryHints[i].first == hint )
 940     {
 941       // Just change the value
 942       mAuxiliaryHints[i].second = value;
 943
 944       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
 945
 946       return i + 1;   // id is index + 1
 947     }
 948   }
 949
 950   // Add the hint
 951   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
 952
 953   unsigned int id = mAuxiliaryHints.size();
 954
 955   ecore_wl_window_aux_hint_add( mEventHandler->mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
 956
 957   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
 958
 959   return id;
 960 }
 961
 962 bool Window::RemoveAuxiliaryHint( unsigned int id )
 963 {
 964   if( id == 0 || id > mAuxiliaryHints.size() )
 965   {
 966     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
 967     return false;
 968   }
 969
 970   mAuxiliaryHints[id - 1].second = std::string();
 971
 972   ecore_wl_window_aux_hint_del( mEventHandler->mEcoreWindow, static_cast< int >( id ) );
 973
 974   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
 975
 976   return true;
 977 }
 978
 979 bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 980 {
 981   if( id == 0 || id > mAuxiliaryHints.size() )
 982   {
 983     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
 984     return false;
 985   }
 986
 987   mAuxiliaryHints[id - 1].second = value;
 988
 989   ecore_wl_window_aux_hint_change( mEventHandler->mEcoreWindow, static_cast< int >( id ), value.c_str() );
 990
 991   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() );
 992
 993   return true;
 994 }
 995
 996 std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
 997 {
 998   if( id == 0 || id > mAuxiliaryHints.size() )
 999   {
1000     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1001     return std::string();
1002   }
1003
1004   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() );
1005
1006   return mAuxiliaryHints[id - 1].second;
1007 }
1008
1009 unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
1010 {
1011   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1012   {
1013     if( mAuxiliaryHints[i].first == hint )
1014     {
1015       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1016       return i + 1;
1017     }
1018   }
1019
1020   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1021
1022   return 0;
1023 }
1024
1025 void Window::SetInputRegion( const Rect< int >& inputRegion )
1026 {
1027   ecore_wl_window_input_region_set( mEventHandler->mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1028
1029   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 );
1030 }
1031
1032 void Window::SetType( Dali::DevelWindow::Type type )
1033 {
1034   Ecore_Wl_Window_Type windowType;
1035
1036   if( type != mType )
1037   {
1038     switch( type )
1039     {
1040       case Dali::DevelWindow::NORMAL:
1041       {
1042         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1043         break;
1044       }
1045       case Dali::DevelWindow::NOTIFICATION:
1046       {
1047         windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1048         break;
1049       }
1050       case Dali::DevelWindow::UTILITY:
1051       {
1052         windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1053         break;
1054       }
1055       case Dali::DevelWindow::DIALOG:
1056       {
1057         windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1058         break;
1059       }
1060       default:
1061       {
1062         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1063         break;
1064       }
1065     }
1066
1067     ecore_wl_window_type_set( mEventHandler->mEcoreWindow, windowType );
1068   }
1069
1070   mType = type;
1071 }
1072
1073 Dali::DevelWindow::Type Window::GetType() const
1074 {
1075   return mType;
1076 }
1077
1078 bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level )
1079 {
1080   if( mType != Dali::DevelWindow::NOTIFICATION )
1081   {
1082     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType );
1083     return false;
1084   }
1085
1086   while( !mEventHandler->mTizenPolicy )
1087   {
1088     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1089   }
1090
1091   int notificationLevel;
1092
1093   switch( level )
1094   {
1095     case Dali::DevelWindow::NotificationLevel::NONE:
1096     {
1097       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1098       break;
1099     }
1100     case Dali::DevelWindow::NotificationLevel::BASE:
1101     {
1102       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1103       break;
1104     }
1105     case Dali::DevelWindow::NotificationLevel::MEDIUM:
1106     {
1107       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1108       break;
1109     }
1110     case Dali::DevelWindow::NotificationLevel::HIGH:
1111     {
1112       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1113       break;
1114     }
1115     case Dali::DevelWindow::NotificationLevel::TOP:
1116     {
1117       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1118       break;
1119     }
1120     default:
1121     {
1122       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: invalid level [%d]\n", level );
1123       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1124       break;
1125     }
1126   }
1127
1128   mEventHandler->mNotificationLevelChangeDone = false;
1129   mEventHandler->mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1130
1131   tizen_policy_set_notification_level( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), notificationLevel );
1132
1133   int count = 0;
1134
1135   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1136   {
1137     ecore_wl_flush();
1138     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1139     count++;
1140   }
1141
1142   if( !mEventHandler->mNotificationLevelChangeDone )
1143   {
1144     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mEventHandler->mNotificationChangeState );
1145     return false;
1146   }
1147   else if( mEventHandler->mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1148   {
1149     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Permission denied! [%d]\n", level );
1150     return false;
1151   }
1152
1153   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level is changed [%d]\n", mEventHandler->mNotificationLevel );
1154
1155   return true;
1156 }
1157
1158 Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel()
1159 {
1160   if( mType != Dali::DevelWindow::NOTIFICATION )
1161   {
1162     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType );
1163     return Dali::DevelWindow::NotificationLevel::NONE;
1164   }
1165
1166   while( !mEventHandler->mTizenPolicy )
1167   {
1168     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1169   }
1170
1171   int count = 0;
1172
1173   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1174   {
1175     ecore_wl_flush();
1176     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1177     count++;
1178   }
1179
1180   if( !mEventHandler->mNotificationLevelChangeDone )
1181   {
1182     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState );
1183     return Dali::DevelWindow::NotificationLevel::NONE;
1184   }
1185
1186   Dali::DevelWindow::NotificationLevel::Type level;
1187
1188   switch( mEventHandler->mNotificationLevel )
1189   {
1190     case TIZEN_POLICY_LEVEL_NONE:
1191     {
1192       level = Dali::DevelWindow::NotificationLevel::NONE;
1193       break;
1194     }
1195     case TIZEN_POLICY_LEVEL_DEFAULT:
1196     {
1197       level = Dali::DevelWindow::NotificationLevel::BASE;
1198       break;
1199     }
1200     case TIZEN_POLICY_LEVEL_MEDIUM:
1201     {
1202       level = Dali::DevelWindow::NotificationLevel::MEDIUM;
1203       break;
1204     }
1205     case TIZEN_POLICY_LEVEL_HIGH:
1206     {
1207       level = Dali::DevelWindow::NotificationLevel::HIGH;
1208       break;
1209     }
1210     case TIZEN_POLICY_LEVEL_TOP:
1211     {
1212       level = Dali::DevelWindow::NotificationLevel::TOP;
1213       break;
1214     }
1215     default:
1216     {
1217       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel );
1218       level = Dali::DevelWindow::NotificationLevel::NONE;
1219       break;
1220     }
1221   }
1222
1223   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: level [%d]\n", mEventHandler->mNotificationLevel );
1224
1225   return level;
1226 }
1227
1228 void Window::SetOpaqueState( bool opaque )
1229 {
1230   while( !mEventHandler->mTizenPolicy )
1231   {
1232     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1233   }
1234
1235   tizen_policy_set_opaque_state( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), ( opaque ? 1 : 0 ) );
1236
1237   mOpaqueState = opaque;
1238
1239   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque );
1240 }
1241
1242 bool Window::IsOpaqueState()
1243 {
1244   return mOpaqueState;
1245 }
1246
1247 bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode )
1248 {
1249   while( !mEventHandler->mTizenPolicy )
1250   {
1251     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1252   }
1253
1254   mEventHandler->mScreenModeChangeDone = false;
1255   mEventHandler->mScreenModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1256
1257   unsigned int mode = 0;
1258
1259   switch( screenMode )
1260   {
1261     case Dali::DevelWindow::ScreenMode::DEFAULT:
1262     {
1263       mode = 0;
1264       break;
1265     }
1266     case Dali::DevelWindow::ScreenMode::ALWAYS_ON:
1267     {
1268       mode = 1;
1269       break;
1270     }
1271   }
1272
1273   tizen_policy_set_window_screen_mode( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), mode );
1274
1275   int count = 0;
1276
1277   while( !mEventHandler->mScreenModeChangeDone && count < 3 )
1278   {
1279     ecore_wl_flush();
1280     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1281     count++;
1282   }
1283
1284   if( !mEventHandler->mScreenModeChangeDone )
1285   {
1286     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode change is failed [%d, %d]\n", screenMode, mEventHandler->mScreenModeChangeState );
1287     return false;
1288   }
1289   else if( mEventHandler->mScreenModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1290   {
1291     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Permission denied! [%d]\n", screenMode );
1292     return false;
1293   }
1294
1295   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode is changed [%d]\n", mEventHandler->mScreenMode );
1296
1297   return true;
1298 }
1299
1300 Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode()
1301 {
1302   while( !mEventHandler->mTizenPolicy )
1303   {
1304     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1305   }
1306
1307   int count = 0;
1308
1309   while( !mEventHandler->mScreenModeChangeDone && count < 3 )
1310   {
1311     ecore_wl_flush();
1312     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1313     count++;
1314   }
1315
1316   if( !mEventHandler->mScreenModeChangeDone )
1317   {
1318     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: Error! [%d]\n", mEventHandler->mScreenModeChangeState );
1319     return Dali::DevelWindow::ScreenMode::DEFAULT;
1320   }
1321
1322   Dali::DevelWindow::ScreenMode::Type screenMode = Dali::DevelWindow::ScreenMode::DEFAULT;
1323
1324   switch( mEventHandler->mScreenMode )
1325   {
1326     case 0:
1327     {
1328       screenMode = Dali::DevelWindow::ScreenMode::DEFAULT;
1329       break;
1330     }
1331     case 1:
1332     {
1333       screenMode = Dali::DevelWindow::ScreenMode::ALWAYS_ON;
1334       break;
1335     }
1336   }
1337
1338   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: screen mode [%d]\n", mEventHandler->mScreenMode );
1339
1340   return screenMode;
1341 }
1342
1343 bool Window::SetBrightness( int brightness )
1344 {
1345   if( brightness < 0 || brightness > 100 )
1346   {
1347     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness );
1348     return false;
1349   }
1350
1351   while( !mEventHandler->mTizenDisplayPolicy )
1352   {
1353     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1354   }
1355
1356   mEventHandler->mBrightnessChangeDone = false;
1357   mEventHandler->mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1358
1359   tizen_display_policy_set_window_brightness( mEventHandler->mTizenDisplayPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), brightness );
1360
1361   int count = 0;
1362
1363   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1364   {
1365     ecore_wl_flush();
1366     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1367     count++;
1368   }
1369
1370   if( !mEventHandler->mBrightnessChangeDone )
1371   {
1372     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mEventHandler->mBrightnessChangeState );
1373     return false;
1374   }
1375   else if( mEventHandler->mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1376   {
1377     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Permission denied! [%d]\n", brightness );
1378     return false;
1379   }
1380
1381   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness is changed [%d]\n", mEventHandler->mBrightness );
1382
1383   return true;
1384 }
1385
1386 int Window::GetBrightness()
1387 {
1388   while( !mEventHandler->mTizenDisplayPolicy )
1389   {
1390     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1391   }
1392
1393   int count = 0;
1394
1395   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1396   {
1397     ecore_wl_flush();
1398     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1399     count++;
1400   }
1401
1402   if( !mEventHandler->mBrightnessChangeDone )
1403   {
1404     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Error! [%d]\n", mEventHandler->mBrightnessChangeState );
1405     return 0;
1406   }
1407
1408   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Brightness [%d]\n", mEventHandler->mBrightness );
1409
1410   return mEventHandler->mBrightness;
1411 }
1412
1413 } // Adaptor
1414
1415 } // Internal
1416
1417 } // Dali
1418
1419 #pragma GCC diagnostic pop