dali/internal/window-system/tizen-wayland/ecore-wl/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 <dali/internal/window-system/common/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 <dali/devel-api/adaptor-framework/orientation.h>
  34
  35 // INTERNAL HEADERS
  36 #include <dali/internal/window-system/tizen-wayland/ecore-wl/window-render-surface-ecore-wl.h>
  37 #include <dali/internal/input/common/drag-and-drop-detector-impl.h>
  38 #include <dali/internal/window-system/common/ecore-indicator-impl.h>
  39 #include <dali/internal/window-system/common/window-visibility-observer.h>
  40 #include <dali/internal/window-system/common/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   if ( orientation <= Dali::Window::LANDSCAPE_INVERSE )
 853   {
 854     for( std::size_t i = 0; i < mAvailableOrientations.size(); i++ )
 855     {
 856       if( mAvailableOrientations[i] == orientation )
 857       {
 858         found = true;
 859         break;
 860       }
 861     }
 862
 863     if( ! found )
 864     {
 865       mAvailableOrientations.push_back(orientation);
 866       SetAvailableOrientations( mAvailableOrientations );
 867     }
 868   }
 869 }
 870
 871 void Window::RemoveAvailableOrientation(Dali::Window::WindowOrientation orientation)
 872 {
 873   for( std::vector<Dali::Window::WindowOrientation>::iterator iter = mAvailableOrientations.begin();
 874        iter != mAvailableOrientations.end(); ++iter )
 875   {
 876     if( *iter == orientation )
 877     {
 878       mAvailableOrientations.erase( iter );
 879       break;
 880     }
 881   }
 882   SetAvailableOrientations( mAvailableOrientations );
 883 }
 884
 885 void Window::SetAvailableOrientations(const std::vector<Dali::Window::WindowOrientation>& orientations)
 886 {
 887   int rotations[4] = { 0 };
 888   for( std::size_t i = 0; i < mAvailableOrientations.size(); ++i )
 889   {
 890     rotations[i] = static_cast< int >( mAvailableOrientations[i] );
 891   }
 892   ecore_wl_window_rotation_available_rotations_set( mEventHandler->mEcoreWindow, rotations, mAvailableOrientations.size() );
 893 }
 894
 895 const std::vector<Dali::Window::WindowOrientation>& Window::GetAvailableOrientations()
 896 {
 897   return mAvailableOrientations;
 898 }
 899
 900 void Window::SetPreferredOrientation(Dali::Window::WindowOrientation orientation)
 901 {
 902   mPreferredOrientation = orientation;
 903
 904   ecore_wl_window_rotation_preferred_rotation_set( mEventHandler->mEcoreWindow, orientation );
 905 }
 906
 907 Dali::Window::WindowOrientation Window::GetPreferredOrientation()
 908 {
 909   return mPreferredOrientation;
 910 }
 911
 912 void Window::SetAcceptFocus( bool accept )
 913 {
 914   mIsFocusAcceptable = accept;
 915
 916   ecore_wl_window_focus_skip_set( mEventHandler->mEcoreWindow, !accept );
 917 }
 918
 919 bool Window::IsFocusAcceptable() const
 920 {
 921   return mIsFocusAcceptable;
 922 }
 923
 924 void Window::Show()
 925 {
 926   mVisible = true;
 927   ecore_wl_window_show( mEventHandler->mEcoreWindow );
 928
 929   if( !mIconified )
 930   {
 931     if( mAdaptor )
 932     {
 933       WindowVisibilityObserver* observer( mAdaptor );
 934       observer->OnWindowShown();
 935       DALI_LOG_RELEASE_INFO( "Window (%p) ::Show() \n", mEventHandler->mEcoreWindow);
 936     }
 937   }
 938 }
 939
 940 void Window::Hide()
 941 {
 942   mVisible = false;
 943   ecore_wl_window_hide( mEventHandler->mEcoreWindow );
 944
 945   if( !mIconified )
 946   {
 947     if( mAdaptor )
 948     {
 949       WindowVisibilityObserver* observer( mAdaptor );
 950       observer->OnWindowHidden();
 951       DALI_LOG_RELEASE_INFO( "Window (%p) ::Hide() \n", mEventHandler->mEcoreWindow);
 952     }
 953   }
 954 }
 955
 956 bool Window::IsVisible() const
 957 {
 958   return mVisible;
 959 }
 960
 961 void Window::RotationDone( int orientation, int width, int height )
 962 {
 963   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
 964   if( wlSurface )
 965   {
 966     wlSurface->RequestRotation( orientation, width, height );
 967   }
 968
 969   mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) );
 970
 971   // Emit signal
 972   mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
 973
 974   mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) );
 975 }
 976
 977 void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
 978 {
 979   mIndicatorVisible = mode;
 980 }
 981
 982 unsigned int Window::GetSupportedAuxiliaryHintCount() const
 983 {
 984   return mSupportedAuxiliaryHints.size();
 985 }
 986
 987 std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const
 988 {
 989   if( index >= GetSupportedAuxiliaryHintCount() )
 990   {
 991     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
 992   }
 993
 994   return mSupportedAuxiliaryHints[index];
 995 }
 996
 997 unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 998 {
 999   bool supported = false;
1000
1001   // Check if the hint is suppported
1002   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1003   {
1004     if( *iter == hint )
1005     {
1006       supported = true;
1007       break;
1008     }
1009   }
1010
1011   if( !supported )
1012   {
1013     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1014     return 0;
1015   }
1016
1017   // Check if the hint is already added
1018   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1019   {
1020     if( mAuxiliaryHints[i].first == hint )
1021     {
1022       // Just change the value
1023       mAuxiliaryHints[i].second = value;
1024
1025       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1026
1027       return i + 1;   // id is index + 1
1028     }
1029   }
1030
1031   // Add the hint
1032   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1033
1034   unsigned int id = mAuxiliaryHints.size();
1035
1036   ecore_wl_window_aux_hint_add( mEventHandler->mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1037
1038   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1039
1040   return id;
1041 }
1042
1043 bool Window::RemoveAuxiliaryHint( unsigned int id )
1044 {
1045   if( id == 0 || id > mAuxiliaryHints.size() )
1046   {
1047     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1048     return false;
1049   }
1050
1051   mAuxiliaryHints[id - 1].second = std::string();
1052
1053   ecore_wl_window_aux_hint_del( mEventHandler->mEcoreWindow, static_cast< int >( id ) );
1054
1055   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1056
1057   return true;
1058 }
1059
1060 bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1061 {
1062   if( id == 0 || id > mAuxiliaryHints.size() )
1063   {
1064     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1065     return false;
1066   }
1067
1068   mAuxiliaryHints[id - 1].second = value;
1069
1070   ecore_wl_window_aux_hint_change( mEventHandler->mEcoreWindow, static_cast< int >( id ), value.c_str() );
1071
1072   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() );
1073
1074   return true;
1075 }
1076
1077 std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
1078 {
1079   if( id == 0 || id > mAuxiliaryHints.size() )
1080   {
1081     DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1082     return std::string();
1083   }
1084
1085   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() );
1086
1087   return mAuxiliaryHints[id - 1].second;
1088 }
1089
1090 unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
1091 {
1092   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1093   {
1094     if( mAuxiliaryHints[i].first == hint )
1095     {
1096       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1097       return i + 1;
1098     }
1099   }
1100
1101   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1102
1103   return 0;
1104 }
1105
1106 void Window::SetInputRegion( const Rect< int >& inputRegion )
1107 {
1108   ecore_wl_window_input_region_set( mEventHandler->mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1109
1110   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 );
1111 }
1112
1113 void Window::SetType( Dali::Window::Type type )
1114 {
1115   Ecore_Wl_Window_Type windowType;
1116
1117   if( type != mType )
1118   {
1119     switch( type )
1120     {
1121       case Dali::Window::NORMAL:
1122       {
1123         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1124         break;
1125       }
1126       case Dali::Window::NOTIFICATION:
1127       {
1128         windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1129         break;
1130       }
1131       case Dali::Window::UTILITY:
1132       {
1133         windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1134         break;
1135       }
1136       case Dali::Window::DIALOG:
1137       {
1138         windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1139         break;
1140       }
1141       default:
1142       {
1143         windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1144         break;
1145       }
1146     }
1147
1148     ecore_wl_window_type_set( mEventHandler->mEcoreWindow, windowType );
1149   }
1150
1151   mType = type;
1152 }
1153
1154 Dali::Window::Type Window::GetType() const
1155 {
1156   return mType;
1157 }
1158
1159 bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1160 {
1161   if( mType != Dali::Window::NOTIFICATION )
1162   {
1163     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType );
1164     return false;
1165   }
1166
1167   while( !mEventHandler->mTizenPolicy )
1168   {
1169     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1170   }
1171
1172   int notificationLevel;
1173
1174   switch( level )
1175   {
1176     case Dali::Window::NotificationLevel::NONE:
1177     {
1178       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1179       break;
1180     }
1181     case Dali::Window::NotificationLevel::BASE:
1182     {
1183       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1184       break;
1185     }
1186     case Dali::Window::NotificationLevel::MEDIUM:
1187     {
1188       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1189       break;
1190     }
1191     case Dali::Window::NotificationLevel::HIGH:
1192     {
1193       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1194       break;
1195     }
1196     case Dali::Window::NotificationLevel::TOP:
1197     {
1198       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1199       break;
1200     }
1201     default:
1202     {
1203       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: invalid level [%d]\n", level );
1204       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1205       break;
1206     }
1207   }
1208
1209   mEventHandler->mNotificationLevelChangeDone = false;
1210   mEventHandler->mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1211
1212   tizen_policy_set_notification_level( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), notificationLevel );
1213
1214   int count = 0;
1215
1216   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1217   {
1218     ecore_wl_flush();
1219     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1220     count++;
1221   }
1222
1223   if( !mEventHandler->mNotificationLevelChangeDone )
1224   {
1225     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mEventHandler->mNotificationChangeState );
1226     return false;
1227   }
1228   else if( mEventHandler->mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1229   {
1230     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Permission denied! [%d]\n", level );
1231     return false;
1232   }
1233
1234   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level is changed [%d]\n", mEventHandler->mNotificationLevel );
1235
1236   return true;
1237 }
1238
1239 Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const
1240 {
1241   if( mType != Dali::Window::NOTIFICATION )
1242   {
1243     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType );
1244     return Dali::Window::NotificationLevel::NONE;
1245   }
1246
1247   while( !mEventHandler->mTizenPolicy )
1248   {
1249     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1250   }
1251
1252   int count = 0;
1253
1254   while( !mEventHandler->mNotificationLevelChangeDone && count < 3 )
1255   {
1256     ecore_wl_flush();
1257     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1258     count++;
1259   }
1260
1261   if( !mEventHandler->mNotificationLevelChangeDone )
1262   {
1263     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState );
1264     return Dali::Window::NotificationLevel::NONE;
1265   }
1266
1267   Dali::Window::NotificationLevel::Type level;
1268
1269   switch( mEventHandler->mNotificationLevel )
1270   {
1271     case TIZEN_POLICY_LEVEL_NONE:
1272     {
1273       level = Dali::Window::NotificationLevel::NONE;
1274       break;
1275     }
1276     case TIZEN_POLICY_LEVEL_DEFAULT:
1277     {
1278       level = Dali::Window::NotificationLevel::BASE;
1279       break;
1280     }
1281     case TIZEN_POLICY_LEVEL_MEDIUM:
1282     {
1283       level = Dali::Window::NotificationLevel::MEDIUM;
1284       break;
1285     }
1286     case TIZEN_POLICY_LEVEL_HIGH:
1287     {
1288       level = Dali::Window::NotificationLevel::HIGH;
1289       break;
1290     }
1291     case TIZEN_POLICY_LEVEL_TOP:
1292     {
1293       level = Dali::Window::NotificationLevel::TOP;
1294       break;
1295     }
1296     default:
1297     {
1298       DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel );
1299       level = Dali::Window::NotificationLevel::NONE;
1300       break;
1301     }
1302   }
1303
1304   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: level [%d]\n", mEventHandler->mNotificationLevel );
1305
1306   return level;
1307 }
1308
1309 void Window::SetOpaqueState( bool opaque )
1310 {
1311   while( !mEventHandler->mTizenPolicy )
1312   {
1313     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1314   }
1315
1316   tizen_policy_set_opaque_state( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), ( opaque ? 1 : 0 ) );
1317
1318   mOpaqueState = opaque;
1319
1320   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque );
1321 }
1322
1323 bool Window::IsOpaqueState() const
1324 {
1325   return mOpaqueState;
1326 }
1327
1328 bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1329 {
1330   while( !mEventHandler->mTizenPolicy )
1331   {
1332     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1333   }
1334
1335   mEventHandler->mScreenOffModeChangeDone = false;
1336   mEventHandler->mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1337
1338   unsigned int mode = 0;
1339
1340   switch( screenOffMode )
1341   {
1342     case Dali::Window::ScreenOffMode::TIMEOUT:
1343     {
1344       mode = 0;
1345       break;
1346     }
1347     case Dali::Window::ScreenOffMode::NEVER:
1348     {
1349       mode = 1;
1350       break;
1351     }
1352   }
1353
1354   tizen_policy_set_window_screen_mode( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), mode );
1355
1356   int count = 0;
1357
1358   while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
1359   {
1360     ecore_wl_flush();
1361     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1362     count++;
1363   }
1364
1365   if( !mEventHandler->mScreenOffModeChangeDone )
1366   {
1367     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mEventHandler->mScreenOffModeChangeState );
1368     return false;
1369   }
1370   else if( mEventHandler->mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1371   {
1372     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
1373     return false;
1374   }
1375
1376   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode is changed [%d]\n", mEventHandler->mScreenOffMode );
1377
1378   return true;
1379 }
1380
1381 Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const
1382 {
1383   while( !mEventHandler->mTizenPolicy )
1384   {
1385     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1386   }
1387
1388   int count = 0;
1389
1390   while( !mEventHandler->mScreenOffModeChangeDone && count < 3 )
1391   {
1392     ecore_wl_flush();
1393     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1394     count++;
1395   }
1396
1397   if( !mEventHandler->mScreenOffModeChangeDone )
1398   {
1399     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: Error! [%d]\n", mEventHandler->mScreenOffModeChangeState );
1400     return Dali::Window::ScreenOffMode::TIMEOUT;
1401   }
1402
1403   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1404
1405   switch( mEventHandler->mScreenOffMode )
1406   {
1407     case 0:
1408     {
1409       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1410       break;
1411     }
1412     case 1:
1413     {
1414       screenMode = Dali::Window::ScreenOffMode::NEVER;
1415       break;
1416     }
1417   }
1418
1419   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: screen mode [%d]\n", mEventHandler->mScreenOffMode );
1420
1421   return screenMode;
1422 }
1423
1424 bool Window::SetBrightness( int brightness )
1425 {
1426   if( brightness < 0 || brightness > 100 )
1427   {
1428     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness );
1429     return false;
1430   }
1431
1432   while( !mEventHandler->mTizenDisplayPolicy )
1433   {
1434     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1435   }
1436
1437   mEventHandler->mBrightnessChangeDone = false;
1438   mEventHandler->mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1439
1440   tizen_display_policy_set_window_brightness( mEventHandler->mTizenDisplayPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), brightness );
1441
1442   int count = 0;
1443
1444   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1445   {
1446     ecore_wl_flush();
1447     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1448     count++;
1449   }
1450
1451   if( !mEventHandler->mBrightnessChangeDone )
1452   {
1453     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mEventHandler->mBrightnessChangeState );
1454     return false;
1455   }
1456   else if( mEventHandler->mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1457   {
1458     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Permission denied! [%d]\n", brightness );
1459     return false;
1460   }
1461
1462   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness is changed [%d]\n", mEventHandler->mBrightness );
1463
1464   return true;
1465 }
1466
1467 int Window::GetBrightness() const
1468 {
1469   while( !mEventHandler->mTizenDisplayPolicy )
1470   {
1471     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1472   }
1473
1474   int count = 0;
1475
1476   while( !mEventHandler->mBrightnessChangeDone && count < 3 )
1477   {
1478     ecore_wl_flush();
1479     wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue );
1480     count++;
1481   }
1482
1483   if( !mEventHandler->mBrightnessChangeDone )
1484   {
1485     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Error! [%d]\n", mEventHandler->mBrightnessChangeState );
1486     return 0;
1487   }
1488
1489   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Brightness [%d]\n", mEventHandler->mBrightness );
1490
1491   return mEventHandler->mBrightness;
1492 }
1493
1494 void Window::SetSize( Dali::Window::WindowSize size )
1495 {
1496   if( !mResizeEnabled )
1497   {
1498     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
1499     mResizeEnabled = true;
1500   }
1501
1502   PositionSize positionSize = mSurface->GetPositionSize();
1503
1504   if( positionSize.width != size.GetWidth() || positionSize.height != size.GetHeight() )
1505   {
1506     positionSize.width = size.GetWidth();
1507     positionSize.height = size.GetHeight();
1508
1509     mSurface->MoveResize( positionSize );
1510
1511     mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
1512
1513     // Emit signal
1514     mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) );
1515
1516     mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
1517   }
1518 }
1519
1520 Dali::Window::WindowSize Window::GetSize() const
1521 {
1522   PositionSize positionSize = mSurface->GetPositionSize();
1523
1524   return Dali::Window::WindowSize( positionSize.width, positionSize.height );
1525 }
1526
1527 void Window::SetPosition( Dali::Window::WindowPosition position )
1528 {
1529   if( !mResizeEnabled )
1530   {
1531     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
1532     mResizeEnabled = true;
1533   }
1534
1535   PositionSize positionSize = mSurface->GetPositionSize();
1536
1537   if( positionSize.x != position.GetX() || positionSize.y != position.GetY() )
1538   {
1539     positionSize.x = position.GetX();
1540     positionSize.y = position.GetY();
1541
1542     mSurface->MoveResize( positionSize );
1543   }
1544 }
1545
1546 Dali::Window::WindowPosition Window::GetPosition() const
1547 {
1548   PositionSize positionSize = mSurface->GetPositionSize();
1549
1550   return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
1551 }
1552
1553 void Window::SetTransparency( bool transparent )
1554 {
1555   ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
1556   if( wlSurface )
1557   {
1558     wlSurface->SetTransparency( transparent );
1559   }
1560 }
1561
1562 } // Adaptor
1563
1564 } // Internal
1565
1566 } // Dali
1567
1568 #pragma GCC diagnostic pop