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