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

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