dali/internal/window-system/tizen-wayland/ecore-wl/window-base-ecore-wl.cpp

   1 /*
   2  * Copyright (c) 2018 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 // Ecore is littered with C style cast
  19 #pragma GCC diagnostic push
  20 #pragma GCC diagnostic ignored "-Wold-style-cast"
  21
  22 // CLASS HEADER
  23 #include <dali/internal/window-system/tizen-wayland/ecore-wl/window-base-ecore-wl.h>
  24
  25 // INTERNAL HEADERS
  26 #include <dali/internal/window-system/common/window-impl.h>
  27 #include <dali/internal/window-system/common/window-system.h>
  28 #include <dali/internal/window-system/common/window-render-surface.h>
  29 #include <dali/internal/input/common/key-impl.h>
  30
  31 // EXTERNAL_HEADERS
  32 #include <dali/public-api/object/any.h>
  33 #include <dali/integration-api/debug.h>
  34 #include <Ecore_Input.h>
  35 #include <vconf.h>
  36 #include <vconf-keys.h>
  37
  38 namespace Dali
  39 {
  40
  41 namespace Internal
  42 {
  43
  44 namespace Adaptor
  45 {
  46
  47 namespace
  48 {
  49
  50 #if defined(DEBUG_ENABLED)
  51 Debug::Filter* gWindowBaseLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_WINDOW_BASE" );
  52 #endif
  53
  54 const uint32_t MAX_TIZEN_CLIENT_VERSION = 7;
  55 const unsigned int PRIMARY_TOUCH_BUTTON_ID = 1;
  56
  57 const char* DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME = "db/setting/accessibility/font_name";  // It will be update at vconf-key.h and replaced.
  58
  59 // DBUS accessibility
  60 const char* BUS = "org.enlightenment.wm-screen-reader";
  61 const char* INTERFACE = "org.tizen.GestureNavigation";
  62 const char* PATH = "/org/tizen/GestureNavigation";
  63
  64 /**
  65  * Get the device name from the provided ecore key event
  66  */
  67 void GetDeviceName( Ecore_Event_Key* keyEvent, std::string& result )
  68 {
  69   const char* ecoreDeviceName = ecore_device_name_get( keyEvent->dev );
  70
  71   if( ecoreDeviceName )
  72   {
  73     result = ecoreDeviceName;
  74   }
  75 }
  76
  77 /**
  78  * Get the device class from the provided ecore event
  79  */
  80 void GetDeviceClass( Ecore_Device_Class ecoreDeviceClass, Device::Class::Type& deviceClass )
  81 {
  82   switch( ecoreDeviceClass )
  83   {
  84     case ECORE_DEVICE_CLASS_SEAT:
  85     {
  86       deviceClass = Device::Class::USER;
  87       break;
  88     }
  89     case ECORE_DEVICE_CLASS_KEYBOARD:
  90     {
  91       deviceClass = Device::Class::KEYBOARD;
  92       break;
  93     }
  94     case ECORE_DEVICE_CLASS_MOUSE:
  95     {
  96       deviceClass = Device::Class::MOUSE;
  97       break;
  98     }
  99     case ECORE_DEVICE_CLASS_TOUCH:
 100     {
 101       deviceClass = Device::Class::TOUCH;
 102       break;
 103     }
 104     case ECORE_DEVICE_CLASS_PEN:
 105     {
 106       deviceClass = Device::Class::PEN;
 107       break;
 108     }
 109     case ECORE_DEVICE_CLASS_POINTER:
 110     {
 111       deviceClass = Device::Class::POINTER;
 112       break;
 113     }
 114     case ECORE_DEVICE_CLASS_GAMEPAD:
 115     {
 116       deviceClass = Device::Class::GAMEPAD;
 117       break;
 118     }
 119     default:
 120     {
 121       deviceClass = Device::Class::NONE;
 122       break;
 123     }
 124   }
 125 }
 126
 127 void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subclass::Type& deviceSubclass )
 128 {
 129   switch( ecoreDeviceSubclass )
 130   {
 131     case ECORE_DEVICE_SUBCLASS_FINGER:
 132     {
 133       deviceSubclass = Device::Subclass::FINGER;
 134       break;
 135     }
 136     case ECORE_DEVICE_SUBCLASS_FINGERNAIL:
 137     {
 138       deviceSubclass = Device::Subclass::FINGERNAIL;
 139       break;
 140     }
 141     case ECORE_DEVICE_SUBCLASS_KNUCKLE:
 142     {
 143       deviceSubclass = Device::Subclass::KNUCKLE;
 144       break;
 145     }
 146     case ECORE_DEVICE_SUBCLASS_PALM:
 147     {
 148       deviceSubclass = Device::Subclass::PALM;
 149       break;
 150     }
 151     case ECORE_DEVICE_SUBCLASS_HAND_SIZE:
 152     {
 153       deviceSubclass = Device::Subclass::HAND_SIDE;
 154       break;
 155     }
 156     case ECORE_DEVICE_SUBCLASS_HAND_FLAT:
 157     {
 158       deviceSubclass = Device::Subclass::HAND_FLAT;
 159       break;
 160     }
 161     case ECORE_DEVICE_SUBCLASS_PEN_TIP:
 162     {
 163       deviceSubclass = Device::Subclass::PEN_TIP;
 164       break;
 165     }
 166     case ECORE_DEVICE_SUBCLASS_TRACKPAD:
 167     {
 168       deviceSubclass = Device::Subclass::TRACKPAD;
 169       break;
 170     }
 171     case ECORE_DEVICE_SUBCLASS_TRACKPOINT:
 172     {
 173       deviceSubclass = Device::Subclass::TRACKPOINT;
 174       break;
 175     }
 176     case ECORE_DEVICE_SUBCLASS_TRACKBALL:
 177     {
 178       deviceSubclass = Device::Subclass::TRACKBALL;
 179       break;
 180     }
 181 #ifdef OVER_TIZEN_VERSION_4
 182     case ECORE_DEVICE_SUBCLASS_REMOCON:
 183     {
 184       deviceSubclass = Device::Subclass::REMOCON;
 185       break;
 186     }
 187     case ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD:
 188     {
 189       deviceSubclass = Device::Subclass::VIRTUAL_KEYBOARD;
 190       break;
 191     }
 192 #endif
 193     default:
 194     {
 195       deviceSubclass = Device::Subclass::NONE;
 196       break;
 197     }
 198   }
 199 }
 200
 201 /////////////////////////////////////////////////////////////////////////////////////////////////
 202 // Window Callbacks
 203 /////////////////////////////////////////////////////////////////////////////////////////////////
 204
 205 /// Called when the window iconify state is changed.
 206 static Eina_Bool EcoreEventWindowIconifyStateChanged( void* data, int type, void* event )
 207 {
 208   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 209   if( windowBase )
 210   {
 211     return windowBase->OnIconifyStateChanged( data, type, event );
 212   }
 213
 214   return ECORE_CALLBACK_PASS_ON;
 215 }
 216
 217 /// Called when the window gains focus
 218 static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
 219 {
 220   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 221   if( windowBase )
 222   {
 223     return windowBase->OnFocusIn( data, type, event );
 224   }
 225
 226   return ECORE_CALLBACK_PASS_ON;
 227 }
 228
 229 /// Called when the window loses focus
 230 static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
 231 {
 232   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 233   if( windowBase )
 234   {
 235     return windowBase->OnFocusOut( data, type, event );
 236   }
 237
 238   return ECORE_CALLBACK_PASS_ON;
 239 }
 240
 241 /// Called when the output is transformed
 242 static Eina_Bool EcoreEventOutputTransform( void* data, int type, void* event )
 243 {
 244   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 245   if( windowBase )
 246   {
 247     return windowBase->OnOutputTransform( data, type, event );
 248   }
 249
 250   return ECORE_CALLBACK_PASS_ON;
 251 }
 252
 253 /// Called when the output transform should be ignored
 254 static Eina_Bool EcoreEventIgnoreOutputTransform( void* data, int type, void* event )
 255 {
 256   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 257   if( windowBase )
 258   {
 259     return windowBase->OnIgnoreOutputTransform( data, type, event );
 260   }
 261
 262   return ECORE_CALLBACK_PASS_ON;
 263 }
 264
 265 /**
 266  * Called when rotate event is recevied.
 267  */
 268 static Eina_Bool EcoreEventRotate( void* data, int type, void* event )
 269 {
 270   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 271   if( windowBase )
 272   {
 273     windowBase->OnRotation( data, type, event );
 274   }
 275   return ECORE_CALLBACK_PASS_ON;
 276 }
 277
 278 /////////////////////////////////////////////////////////////////////////////////////////////////
 279 // Touch Callbacks
 280 /////////////////////////////////////////////////////////////////////////////////////////////////
 281
 282 /**
 283  * Called when a touch down is received.
 284  */
 285 static Eina_Bool EcoreEventMouseButtonDown( void* data, int type, void* event )
 286 {
 287   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 288   if( windowBase )
 289   {
 290     windowBase->OnMouseButtonDown( data, type, event );
 291   }
 292   return ECORE_CALLBACK_PASS_ON;
 293 }
 294
 295 /**
 296  * Called when a touch up is received.
 297  */
 298 static Eina_Bool EcoreEventMouseButtonUp( void* data, int type, void* event )
 299 {
 300   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 301   if( windowBase )
 302   {
 303     windowBase->OnMouseButtonUp( data, type, event );
 304   }
 305   return ECORE_CALLBACK_PASS_ON;
 306 }
 307
 308 /**
 309  * Called when a touch motion is received.
 310  */
 311 static Eina_Bool EcoreEventMouseButtonMove( void* data, int type, void* event )
 312 {
 313   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 314   if( windowBase )
 315   {
 316     windowBase->OnMouseButtonMove( data, type, event );
 317   }
 318   return ECORE_CALLBACK_PASS_ON;
 319 }
 320
 321 /**
 322  * Called when a touch is canceled.
 323  */
 324 static Eina_Bool EcoreEventMouseButtonCancel( void* data, int type, void* event )
 325 {
 326   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 327   if( windowBase )
 328   {
 329     windowBase->OnMouseButtonCancel( data, type, event );
 330   }
 331   return ECORE_CALLBACK_PASS_ON;
 332 }
 333
 334 /**
 335  * Called when a mouse wheel is received.
 336  */
 337 static Eina_Bool EcoreEventMouseWheel( void* data, int type, void* event )
 338 {
 339   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 340   if( windowBase )
 341   {
 342     windowBase->OnMouseWheel( data, type, event );
 343   }
 344   return ECORE_CALLBACK_PASS_ON;
 345 }
 346
 347 /**
 348  * Called when a detent rotation event is recevied.
 349  */
 350 static Eina_Bool EcoreEventDetentRotation( void* data, int type, void* event )
 351 {
 352   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 353   if( windowBase )
 354   {
 355     windowBase->OnDetentRotation( data, type, event );
 356   }
 357   return ECORE_CALLBACK_PASS_ON;
 358 }
 359
 360 /////////////////////////////////////////////////////////////////////////////////////////////////
 361 // Key Callbacks
 362 /////////////////////////////////////////////////////////////////////////////////////////////////
 363
 364 /**
 365  * Called when a key down is received.
 366  */
 367 static Eina_Bool EcoreEventKeyDown( void* data, int type, void* event )
 368 {
 369   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 370   if( windowBase )
 371   {
 372     windowBase->OnKeyDown( data, type, event );
 373   }
 374   return ECORE_CALLBACK_PASS_ON;
 375 }
 376
 377 /**
 378  * Called when a key up is received.
 379  */
 380 static Eina_Bool EcoreEventKeyUp( void* data, int type, void* event )
 381 {
 382   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 383   if( windowBase )
 384   {
 385     windowBase->OnKeyUp( data, type, event );
 386   }
 387   return ECORE_CALLBACK_PASS_ON;
 388 }
 389
 390 /////////////////////////////////////////////////////////////////////////////////////////////////
 391 // Selection Callbacks
 392 /////////////////////////////////////////////////////////////////////////////////////////////////
 393
 394 /**
 395  * Called when the source window notifies us the content in clipboard is selected.
 396  */
 397 static Eina_Bool EcoreEventDataSend( void* data, int type, void* event )
 398 {
 399   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 400   if( windowBase )
 401   {
 402     windowBase->OnDataSend( data, type, event );
 403   }
 404   return ECORE_CALLBACK_PASS_ON;
 405 }
 406
 407 /**
 408 * Called when the source window sends us about the selected content.
 409 * For example, when item is selected in the clipboard.
 410 */
 411 static Eina_Bool EcoreEventDataReceive( void* data, int type, void* event )
 412 {
 413   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 414   if( windowBase )
 415   {
 416     windowBase->OnDataReceive( data, type, event );
 417   }
 418   return ECORE_CALLBACK_PASS_ON;
 419 }
 420
 421 /////////////////////////////////////////////////////////////////////////////////////////////////
 422 // Indicator Callbacks
 423 /////////////////////////////////////////////////////////////////////////////////////////////////
 424
 425 #if defined (DALI_PROFILE_MOBILE)
 426   /**
 427    * Called when the Ecore indicator event is received.
 428    */
 429   static Eina_Bool EcoreEventIndicator( void* data, int type, void* event )
 430   {
 431     WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 432     if( windowBase )
 433     {
 434       windowBase->OnIndicatorFlicked( data, type, event );
 435     }
 436     return ECORE_CALLBACK_PASS_ON;
 437   }
 438 #endif // DALI_PROFILE_MOBILE
 439
 440 /////////////////////////////////////////////////////////////////////////////////////////////////
 441 // Font Callbacks
 442 /////////////////////////////////////////////////////////////////////////////////////////////////
 443
 444 /**
 445  * Called when a font name is changed.
 446  */
 447 static void VconfNotifyFontNameChanged( keynode_t* node, void* data )
 448 {
 449   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 450   if( windowBase )
 451   {
 452     windowBase->OnFontNameChanged();
 453   }
 454 }
 455
 456 /**
 457  * Called when a font size is changed.
 458  */
 459 static void VconfNotifyFontSizeChanged( keynode_t* node, void* data )
 460 {
 461   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 462   if( windowBase )
 463   {
 464     windowBase->OnFontSizeChanged();
 465   }
 466 }
 467
 468 /////////////////////////////////////////////////////////////////////////////////////////////////
 469 // ElDBus Accessibility Callbacks
 470 /////////////////////////////////////////////////////////////////////////////////////////////////
 471
 472 #ifdef DALI_ELDBUS_AVAILABLE
 473 // Callback for Ecore ElDBus accessibility events.
 474 static void EcoreElDBusAccessibilityNotification( void* context, const Eldbus_Message* message )
 475 {
 476   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( context );
 477   if( windowBase )
 478   {
 479     windowBase->OnEcoreElDBusAccessibilityNotification( context, message );
 480   }
 481 }
 482 #endif // DALI_ELDBUS_AVAILABLE
 483
 484 static void RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
 485 {
 486   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 487   if( windowBase )
 488   {
 489     windowBase->RegistryGlobalCallback( data, registry, name, interface, version );
 490   }
 491 }
 492
 493 static void RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
 494 {
 495   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 496   if( windowBase )
 497   {
 498     windowBase->RegistryGlobalCallbackRemove( data, registry, id );
 499   }
 500 }
 501
 502 static void TizenPolicyConformant( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t isConformant )
 503 {
 504 }
 505
 506 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 )
 507 {
 508 }
 509
 510 static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
 511 {
 512   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 513   if( windowBase )
 514   {
 515     windowBase->TizenPolicyNotificationChangeDone( data, tizenPolicy, surface, level, state );
 516   }
 517 }
 518
 519 static void TizenPolicyTransientForDone( void* data, struct tizen_policy* tizenPolicy, uint32_t childId )
 520 {
 521 }
 522
 523 static void TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
 524 {
 525   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 526   if( windowBase )
 527   {
 528     windowBase->TizenPolicyScreenModeChangeDone( data, tizenPolicy, surface, mode, state );
 529   }
 530 }
 531
 532 static void TizenPolicyIconifyStateChanged( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t iconified, uint32_t force )
 533 {
 534 }
 535
 536 static void TizenPolicySupportedAuxiliaryHints( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, struct wl_array* hints, uint32_t numNints )
 537 {
 538 }
 539
 540 static void TizenPolicyAllowedAuxiliaryHint( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int id )
 541 {
 542 }
 543
 544 static void TizenPolicyAuxiliaryMessage( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, const char* key, const char* val, struct wl_array* options )
 545 {
 546 }
 547
 548 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 )
 549 {
 550 }
 551
 552 static void DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
 553 {
 554   WindowBaseEcoreWl* windowBase = static_cast< WindowBaseEcoreWl* >( data );
 555   if( windowBase )
 556   {
 557     windowBase->DisplayPolicyBrightnessChangeDone( data, displayPolicy, surface, brightness, state );
 558   }
 559 }
 560
 561 const struct wl_registry_listener registryListener =
 562 {
 563    RegistryGlobalCallback,
 564    RegistryGlobalCallbackRemove
 565 };
 566
 567 const struct tizen_policy_listener tizenPolicyListener =
 568 {
 569    TizenPolicyConformant,
 570    TizenPolicyConformantArea,
 571    TizenPolicyNotificationChangeDone,
 572    TizenPolicyTransientForDone,
 573    TizenPolicyScreenModeChangeDone,
 574    TizenPolicyIconifyStateChanged,
 575    TizenPolicySupportedAuxiliaryHints,
 576    TizenPolicyAllowedAuxiliaryHint,
 577    TizenPolicyAuxiliaryMessage,
 578    TizenPolicyConformantRegion
 579 };
 580
 581 const struct tizen_display_policy_listener tizenDisplayPolicyListener =
 582 {
 583   DisplayPolicyBrightnessChangeDone
 584 };
 585
 586 } // unnamed namespace
 587
 588 WindowBaseEcoreWl::WindowBaseEcoreWl( Dali::PositionSize positionSize, Any surface, bool isTransparent )
 589 : mEcoreEventHandler(),
 590   mEcoreWindow( NULL ),
 591   mWlSurface( NULL ),
 592   mEglWindow( NULL ),
 593   mDisplay( NULL ),
 594   mEventQueue( NULL ),
 595   mTizenPolicy( NULL ),
 596   mTizenDisplayPolicy( NULL ),
 597   mSupportedAuxiliaryHints(),
 598   mAuxiliaryHints(),
 599   mNotificationLevel( -1 ),
 600   mNotificationChangeState( 0 ),
 601   mNotificationLevelChangeDone( true ),
 602   mScreenOffMode( 0 ),
 603   mScreenOffModeChangeState( 0 ),
 604   mScreenOffModeChangeDone( true ),
 605   mBrightness( 0 ),
 606   mBrightnessChangeState( 0 ),
 607   mBrightnessChangeDone( true ),
 608   mOwnSurface( false )
 609 #ifdef DALI_ELDBUS_AVAILABLE
 610   , mSystemConnection( NULL )
 611 #endif
 612 {
 613   Initialize( positionSize, surface, isTransparent );
 614 }
 615
 616 WindowBaseEcoreWl::~WindowBaseEcoreWl()
 617 {
 618 #ifdef DALI_ELDBUS_AVAILABLE
 619     // Close down ElDBus connections.
 620     if( mSystemConnection )
 621     {
 622       eldbus_connection_unref( mSystemConnection );
 623     }
 624 #endif // DALI_ELDBUS_AVAILABLE
 625
 626   vconf_ignore_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged );
 627   vconf_ignore_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged );
 628
 629   for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter )
 630   {
 631     ecore_event_handler_del( *iter );
 632   }
 633   mEcoreEventHandler.Clear();
 634
 635   if( mEventQueue )
 636   {
 637     wl_event_queue_destroy( mEventQueue );
 638   }
 639
 640   mSupportedAuxiliaryHints.clear();
 641   mAuxiliaryHints.clear();
 642
 643   if( mEglWindow != NULL )
 644   {
 645     wl_egl_window_destroy( mEglWindow );
 646     mEglWindow = NULL;
 647   }
 648
 649   if( mOwnSurface )
 650   {
 651     ecore_wl_window_free( mEcoreWindow );
 652
 653     WindowSystem::Shutdown();
 654   }
 655 }
 656
 657 void WindowBaseEcoreWl::Initialize( PositionSize positionSize, Any surface, bool isTransparent )
 658 {
 659   if( surface.Empty() == false )
 660   {
 661     // check we have a valid type
 662     DALI_ASSERT_ALWAYS( ( surface.GetType() == typeid (Ecore_Wl_Window *) ) && "Surface type is invalid" );
 663
 664     mEcoreWindow = AnyCast< Ecore_Wl_Window* >( surface );
 665   }
 666   else
 667   {
 668     // we own the surface about to created
 669     WindowSystem::Initialize();
 670
 671     mOwnSurface = true;
 672     CreateWindow( positionSize );
 673   }
 674
 675   mWlSurface = ecore_wl_window_surface_create( mEcoreWindow );
 676
 677   SetTransparency( isTransparent );
 678
 679   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) );
 680   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN,                    EcoreEventWindowFocusIn,             this ) );
 681   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT,                   EcoreEventWindowFocusOut,            this ) );
 682   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_OUTPUT_TRANSFORM,            EcoreEventOutputTransform,           this ) );
 683   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM,     EcoreEventIgnoreOutputTransform,     this ) );
 684
 685   // Register Rotate event
 686   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ROTATE,               EcoreEventRotate,                    this ) );
 687
 688   // Register Touch events
 689   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,              EcoreEventMouseButtonDown,           this ) );
 690   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,                EcoreEventMouseButtonUp,             this ) );
 691   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE,                     EcoreEventMouseButtonMove,           this ) );
 692   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_CANCEL,            EcoreEventMouseButtonCancel,         this ) );
 693
 694   // Register Mouse wheel events
 695   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL,                    EcoreEventMouseWheel,                this ) );
 696
 697   // Register Detent event
 698   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_DETENT_ROTATE,                  EcoreEventDetentRotation,            this ) );
 699
 700   // Register Key events
 701   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN,                       EcoreEventKeyDown,                   this ) );
 702   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_UP,                         EcoreEventKeyUp,                     this ) );
 703
 704   // Register Selection event - clipboard selection
 705   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_DATA_SOURCE_SEND,            EcoreEventDataSend,                  this ) );
 706   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_SELECTION_DATA_READY,        EcoreEventDataReceive,               this ) );
 707
 708 #if defined (DALI_PROFILE_MOBILE)
 709   // Register indicator event
 710   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_INDICATOR_FLICK,             EcoreEventIndicator,                 this ) );
 711 #endif
 712
 713   // Register Vconf notify - font name and size
 714   vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this );
 715   vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this );
 716
 717   InitializeEcoreElDBus();
 718
 719   mDisplay = ecore_wl_display_get();
 720
 721   if( mDisplay )
 722   {
 723     wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) );
 724     if( displayWrapper )
 725     {
 726       mEventQueue = wl_display_create_queue( mDisplay );
 727       if( mEventQueue )
 728       {
 729         wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue );
 730
 731         wl_registry* registry = wl_display_get_registry( displayWrapper );
 732         wl_registry_add_listener( registry, &registryListener, this );
 733       }
 734
 735       wl_proxy_wrapper_destroy( displayWrapper );
 736     }
 737   }
 738
 739   // get auxiliary hint
 740   Eina_List* hints = ecore_wl_window_aux_hints_supported_get( mEcoreWindow );
 741   if( hints )
 742   {
 743     Eina_List* l = NULL;
 744     char* hint = NULL;
 745
 746     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) ) ) )
 747     {
 748       mSupportedAuxiliaryHints.push_back( hint );
 749
 750       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::Initialize: %s\n", hint );
 751     }
 752   }
 753 }
 754
 755 Eina_Bool WindowBaseEcoreWl::OnIconifyStateChanged( void* data, int type, void* event )
 756 {
 757   Ecore_Wl_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl_Event_Window_Iconify_State_Change* >( event ) );
 758   Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 759
 760   if( iconifyChangedEvent->win == static_cast< unsigned int>( ecore_wl_window_id_get( mEcoreWindow ) ) )
 761   {
 762     if( iconifyChangedEvent->iconified == EINA_TRUE )
 763     {
 764       mIconifyChangedSignal.Emit( true );
 765     }
 766     else
 767     {
 768       mIconifyChangedSignal.Emit( false );
 769     }
 770     handled = ECORE_CALLBACK_DONE;
 771   }
 772
 773   return handled;
 774 }
 775
 776 Eina_Bool WindowBaseEcoreWl::OnFocusIn( void* data, int type, void* event )
 777 {
 778   Ecore_Wl_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl_Event_Focus_In* >( event ) );
 779
 780   if( focusInEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 781   {
 782     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
 783
 784     mFocusChangedSignal.Emit( true );
 785   }
 786
 787   return ECORE_CALLBACK_PASS_ON;
 788 }
 789
 790 Eina_Bool WindowBaseEcoreWl::OnFocusOut( void* data, int type, void* event )
 791 {
 792   Ecore_Wl_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl_Event_Focus_Out* >( event ) );
 793
 794   if( focusOutEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 795   {
 796     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
 797
 798     mFocusChangedSignal.Emit( false );
 799   }
 800
 801   return ECORE_CALLBACK_PASS_ON;
 802 }
 803
 804 Eina_Bool WindowBaseEcoreWl::OnOutputTransform( void* data, int type, void* event )
 805 {
 806   Ecore_Wl_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl_Event_Output_Transform* >( event ) );
 807
 808   if( transformEvent->output == ecore_wl_window_output_find( mEcoreWindow ) )
 809   {
 810     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow );
 811
 812     mOutputTransformedSignal.Emit();
 813   }
 814
 815   return ECORE_CALLBACK_PASS_ON;
 816 }
 817
 818 Eina_Bool WindowBaseEcoreWl::OnIgnoreOutputTransform( void* data, int type, void* event )
 819 {
 820   Ecore_Wl_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl_Event_Ignore_Output_Transform* >( event ) );
 821
 822   if( ignoreTransformEvent->win == mEcoreWindow )
 823   {
 824     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow );
 825
 826     mOutputTransformedSignal.Emit();
 827   }
 828
 829   return ECORE_CALLBACK_PASS_ON;
 830 }
 831
 832 void WindowBaseEcoreWl::OnRotation( void* data, int type, void* event )
 833 {
 834   Ecore_Wl_Event_Window_Rotate* ev( static_cast< Ecore_Wl_Event_Window_Rotate* >( event ) );
 835
 836   if( ev->win == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 837   {
 838     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::OnRotation\n" );
 839
 840     RotationEvent rotationEvent;
 841     rotationEvent.angle = ev->angle;
 842     rotationEvent.winResize = 0;
 843
 844     if( ev->angle == 0 || ev->angle == 180 )
 845     {
 846       rotationEvent.width = ev->w;
 847       rotationEvent.height = ev->h;
 848     }
 849     else
 850     {
 851       rotationEvent.width = ev->h;
 852       rotationEvent.height = ev->w;
 853     }
 854
 855     mRotationSignal.Emit( rotationEvent );
 856   }
 857 }
 858
 859 void WindowBaseEcoreWl::OnMouseButtonDown( void* data, int type, void* event )
 860 {
 861   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 862
 863   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 864   {
 865     PointState::Type state ( PointState::DOWN );
 866
 867     // Check if the buttons field is set and ensure it's the primary touch button.
 868     // If this event was triggered by buttons other than the primary button (used for touch), then
 869     // just send an interrupted event to Core.
 870     if( touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID ) )
 871     {
 872       state = PointState::INTERRUPTED;
 873     }
 874
 875     Device::Class::Type deviceClass;
 876     Device::Subclass::Type deviceSubclass;
 877
 878     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 879     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 880
 881     Integration::Point point;
 882     point.SetDeviceId( touchEvent->multi.device );
 883     point.SetState( state );
 884     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
 885     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
 886     point.SetPressure( touchEvent->multi.pressure );
 887     point.SetAngle( Degree( touchEvent->multi.angle ) );
 888     point.SetDeviceClass( deviceClass );
 889     point.SetDeviceSubclass( deviceSubclass );
 890
 891     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 892   }
 893 }
 894
 895 void WindowBaseEcoreWl::OnMouseButtonUp( void* data, int type, void* event )
 896 {
 897   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 898
 899   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 900   {
 901     Device::Class::Type deviceClass;
 902     Device::Subclass::Type deviceSubclass;
 903
 904     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 905     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 906
 907     Integration::Point point;
 908     point.SetDeviceId( touchEvent->multi.device );
 909     point.SetState( PointState::UP );
 910     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
 911     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
 912     point.SetPressure( touchEvent->multi.pressure );
 913     point.SetAngle( Degree( touchEvent->multi.angle ) );
 914     point.SetDeviceClass( deviceClass );
 915     point.SetDeviceSubclass( deviceSubclass );
 916
 917     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 918   }
 919 }
 920
 921 void WindowBaseEcoreWl::OnMouseButtonMove( void* data, int type, void* event )
 922 {
 923   Ecore_Event_Mouse_Move* touchEvent = static_cast< Ecore_Event_Mouse_Move* >( event );
 924
 925   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 926   {
 927     Device::Class::Type deviceClass;
 928     Device::Subclass::Type deviceSubclass;
 929
 930     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 931     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 932
 933     Integration::Point point;
 934     point.SetDeviceId( touchEvent->multi.device );
 935     point.SetState( PointState::MOTION );
 936     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
 937     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
 938     point.SetPressure( touchEvent->multi.pressure );
 939     point.SetAngle( Degree( touchEvent->multi.angle ) );
 940     point.SetDeviceClass( deviceClass );
 941     point.SetDeviceSubclass( deviceSubclass );
 942
 943     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 944   }
 945 }
 946
 947 void WindowBaseEcoreWl::OnMouseButtonCancel( void* data, int type, void* event )
 948 {
 949   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 950
 951   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 952   {
 953     Integration::Point point;
 954     point.SetDeviceId( touchEvent->multi.device );
 955     point.SetState( PointState::INTERRUPTED );
 956     point.SetScreenPosition( Vector2( 0.0f, 0.0f ) );
 957
 958     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 959
 960     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnMouseButtonCancel\n" );
 961   }
 962 }
 963
 964 void WindowBaseEcoreWl::OnMouseWheel( void* data, int type, void* event )
 965 {
 966   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast< Ecore_Event_Mouse_Wheel* >( event );
 967
 968   if( mouseWheelEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 969   {
 970     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnMouseWheel: direction: %d, modifiers: %d, x: %d, y: %d, z: %d\n", mouseWheelEvent->direction, mouseWheelEvent->modifiers, mouseWheelEvent->x, mouseWheelEvent->y, mouseWheelEvent->z );
 971
 972     WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2( mouseWheelEvent->x, mouseWheelEvent->y ), mouseWheelEvent->z, mouseWheelEvent->timestamp );
 973
 974     mWheelEventSignal.Emit( wheelEvent );
 975   }
 976 }
 977
 978 void WindowBaseEcoreWl::OnDetentRotation( void* data, int type, void* event )
 979 {
 980   Ecore_Event_Detent_Rotate* detentEvent = static_cast< Ecore_Event_Detent_Rotate* >( event );
 981
 982   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::OnDetentRotation\n" );
 983
 984   int direction = ( detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE ) ? 1 : -1;
 985   int timeStamp = detentEvent->timestamp;
 986
 987   WheelEvent wheelEvent( WheelEvent::CUSTOM_WHEEL, 0, 0, Vector2( 0.0f, 0.0f ), direction, timeStamp );
 988
 989   mWheelEventSignal.Emit( wheelEvent );
 990 }
 991
 992 void WindowBaseEcoreWl::OnKeyDown( void* data, int type, void* event )
 993 {
 994   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
 995
 996   if( keyEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 997   {
 998     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyDown\n" );
 999
1000     std::string keyName( keyEvent->keyname );
1001     std::string keyString( "" );
1002     std::string compose( "" );
1003
1004     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1005     if( keyEvent->compose )
1006     {
1007       compose = keyEvent->compose;
1008     }
1009
1010     int keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1011     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1012     int modifier( keyEvent->modifiers );
1013     unsigned long time = keyEvent->timestamp;
1014     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1015     {
1016       keyCode = atoi( keyEvent->keyname + 8 );
1017     }
1018
1019     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1020     if( keyEvent->string )
1021     {
1022       keyString = keyEvent->string;
1023     }
1024
1025     std::string deviceName;
1026     Device::Class::Type deviceClass;
1027     Device::Subclass::Type deviceSubclass;
1028
1029     GetDeviceName( keyEvent, deviceName );
1030     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1031     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1032
1033     Integration::KeyEvent keyEvent( keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, compose, deviceName, deviceClass, deviceSubclass );
1034
1035      mKeyEventSignal.Emit( keyEvent );
1036   }
1037 }
1038
1039 void WindowBaseEcoreWl::OnKeyUp( void* data, int type, void* event )
1040 {
1041   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
1042
1043   if( keyEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
1044   {
1045     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyUp\n" );
1046
1047     std::string keyName( keyEvent->keyname );
1048     std::string keyString( "" );
1049     std::string compose( "" );
1050
1051     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1052     if( keyEvent->compose )
1053     {
1054       compose = keyEvent->compose;
1055     }
1056
1057     int keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1058     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1059     int modifier( keyEvent->modifiers );
1060     unsigned long time = keyEvent->timestamp;
1061     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1062     {
1063       keyCode = atoi( keyEvent->keyname + 8 );
1064     }
1065
1066     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1067     if( keyEvent->string )
1068     {
1069       keyString = keyEvent->string;
1070     }
1071
1072     std::string deviceName;
1073     Device::Class::Type deviceClass;
1074     Device::Subclass::Type deviceSubclass;
1075
1076     GetDeviceName( keyEvent, deviceName );
1077     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1078     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1079
1080     Integration::KeyEvent keyEvent( keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, compose, deviceName, deviceClass, deviceSubclass );
1081
1082      mKeyEventSignal.Emit( keyEvent );
1083   }
1084 }
1085
1086 void WindowBaseEcoreWl::OnDataSend( void* data, int type, void* event )
1087 {
1088   mSelectionDataSendSignal.Emit( event );
1089 }
1090
1091 void WindowBaseEcoreWl::OnDataReceive( void* data, int type, void* event )
1092 {
1093   mSelectionDataReceivedSignal.Emit( event  );
1094 }
1095
1096 void WindowBaseEcoreWl::OnIndicatorFlicked( void* data, int type, void* event )
1097 {
1098   mIndicatorFlickedSignal.Emit();
1099 }
1100
1101 void WindowBaseEcoreWl::OnFontNameChanged()
1102 {
1103   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_CHANGE );
1104 }
1105
1106 void WindowBaseEcoreWl::OnFontSizeChanged()
1107 {
1108   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
1109 }
1110
1111 void WindowBaseEcoreWl::OnEcoreElDBusAccessibilityNotification( void* context, const Eldbus_Message* message )
1112 {
1113 #ifdef DALI_ELDBUS_AVAILABLE
1114   AccessibilityInfo info;
1115
1116   // The string defines the arg-list's respective types.
1117   if( !eldbus_message_arguments_get( message, "iiiiiiu", &info.gestureValue, &info.startX, &info.startY, &info.endX, &info.endY, &info.state, &info.eventTime ) )
1118   {
1119     DALI_LOG_ERROR( "OnEcoreElDBusAccessibilityNotification: Error getting arguments\n" );
1120   }
1121
1122   mAccessibilitySignal.Emit( info );
1123 #endif
1124 }
1125
1126 void WindowBaseEcoreWl::RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
1127 {
1128   if( strcmp( interface, tizen_policy_interface.name ) == 0 )
1129   {
1130     uint32_t clientVersion = std::min( version, MAX_TIZEN_CLIENT_VERSION );
1131
1132     mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, clientVersion ) );
1133     if( !mTizenPolicy )
1134     {
1135       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" );
1136       return;
1137     }
1138
1139     tizen_policy_add_listener( mTizenPolicy, &tizenPolicyListener, data );
1140
1141     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" );
1142   }
1143   else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 )
1144   {
1145     mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) );
1146     if( !mTizenDisplayPolicy )
1147     {
1148       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" );
1149       return;
1150     }
1151
1152     tizen_display_policy_add_listener( mTizenDisplayPolicy, &tizenDisplayPolicyListener, data );
1153
1154     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" );
1155   }
1156 }
1157
1158 void WindowBaseEcoreWl::RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
1159 {
1160   mTizenPolicy = NULL;
1161   mTizenDisplayPolicy = NULL;
1162 }
1163
1164 void WindowBaseEcoreWl::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
1165 {
1166   mNotificationLevel = level;
1167   mNotificationChangeState = state;
1168   mNotificationLevelChangeDone = true;
1169
1170   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state );
1171 }
1172
1173 void WindowBaseEcoreWl::TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
1174 {
1175   mScreenOffMode = mode;
1176   mScreenOffModeChangeState = state;
1177   mScreenOffModeChangeDone = true;
1178
1179   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
1180 }
1181
1182 void WindowBaseEcoreWl::DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
1183 {
1184   mBrightness = brightness;
1185   mBrightnessChangeState = state;
1186   mBrightnessChangeDone = true;
1187
1188   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
1189 }
1190
1191 Any WindowBaseEcoreWl::GetNativeWindow()
1192 {
1193   return mEcoreWindow;
1194 }
1195
1196 int WindowBaseEcoreWl::GetNativeWindowId()
1197 {
1198   return ecore_wl_window_id_get( mEcoreWindow );
1199 }
1200
1201 EGLNativeWindowType WindowBaseEcoreWl::CreateEglWindow( int width, int height )
1202 {
1203   mEglWindow = wl_egl_window_create( mWlSurface, width, height );
1204
1205   return static_cast< EGLNativeWindowType >( mEglWindow );
1206 }
1207
1208 void WindowBaseEcoreWl::DestroyEglWindow()
1209 {
1210   if( mEglWindow != NULL )
1211   {
1212     wl_egl_window_destroy( mEglWindow );
1213     mEglWindow = NULL;
1214   }
1215 }
1216
1217 void WindowBaseEcoreWl::SetEglWindowRotation( int angle )
1218 {
1219   wl_egl_window_rotation rotation;
1220
1221   switch( angle )
1222   {
1223     case 0:
1224     {
1225       rotation = ROTATION_0;
1226       break;
1227     }
1228     case 90:
1229     {
1230       rotation = ROTATION_270;
1231       break;
1232     }
1233     case 180:
1234     {
1235       rotation = ROTATION_180;
1236       break;
1237     }
1238     case 270:
1239     {
1240       rotation = ROTATION_90;
1241       break;
1242     }
1243     default:
1244     {
1245       rotation = ROTATION_0;
1246       break;
1247     }
1248   }
1249
1250   wl_egl_window_set_rotation( mEglWindow, rotation );
1251 }
1252
1253 void WindowBaseEcoreWl::SetEglWindowBufferTransform( int angle )
1254 {
1255   wl_output_transform bufferTransform;
1256
1257   switch( angle )
1258   {
1259     case 0:
1260     {
1261       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1262       break;
1263     }
1264     case 90:
1265     {
1266       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1267       break;
1268     }
1269     case 180:
1270     {
1271       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1272       break;
1273     }
1274     case 270:
1275     {
1276       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1277       break;
1278     }
1279     default:
1280     {
1281       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1282       break;
1283     }
1284   }
1285
1286   wl_egl_window_set_buffer_transform( mEglWindow, bufferTransform );
1287 }
1288
1289 void WindowBaseEcoreWl::SetEglWindowTransform( int angle )
1290 {
1291   wl_output_transform windowTransform;
1292
1293   switch( angle )
1294   {
1295     case 0:
1296     {
1297       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1298       break;
1299     }
1300     case 90:
1301     {
1302       windowTransform = WL_OUTPUT_TRANSFORM_90;
1303       break;
1304     }
1305     case 180:
1306     {
1307       windowTransform = WL_OUTPUT_TRANSFORM_180;
1308       break;
1309     }
1310     case 270:
1311     {
1312       windowTransform = WL_OUTPUT_TRANSFORM_270;
1313       break;
1314     }
1315     default:
1316     {
1317       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1318       break;
1319     }
1320   }
1321
1322   wl_egl_window_set_window_transform( mEglWindow, windowTransform );
1323 }
1324
1325 void WindowBaseEcoreWl::ResizeEglWindow( PositionSize positionSize )
1326 {
1327   wl_egl_window_resize( mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y );
1328 }
1329
1330 bool WindowBaseEcoreWl::IsEglWindowRotationSupported()
1331 {
1332   // Check capability
1333   wl_egl_window_capability capability = static_cast< wl_egl_window_capability >( wl_egl_window_get_capabilities( mEglWindow ) );
1334   if( capability == WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED )
1335   {
1336     return true;
1337   }
1338
1339   return false;
1340 }
1341
1342 void WindowBaseEcoreWl::Move( PositionSize positionSize )
1343 {
1344   ecore_wl_window_position_set( mEcoreWindow, positionSize.x, positionSize.y );
1345 }
1346
1347 void WindowBaseEcoreWl::Resize( PositionSize positionSize )
1348 {
1349   ecore_wl_window_update_size( mEcoreWindow, positionSize.width, positionSize.height );
1350 }
1351
1352 void WindowBaseEcoreWl::MoveResize( PositionSize positionSize )
1353 {
1354   ecore_wl_window_position_set( mEcoreWindow, positionSize.x, positionSize.y );
1355   ecore_wl_window_update_size( mEcoreWindow, positionSize.width, positionSize.height );
1356 }
1357
1358 void WindowBaseEcoreWl::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode, Dali::Window::IndicatorBgOpacity opacityMode )
1359 {
1360   DALI_LOG_TRACE_METHOD_FMT( gWindowBaseLogFilter, "visible : %d\n", visibleMode );
1361
1362   if( visibleMode == Dali::Window::VISIBLE )
1363   {
1364     // when the indicator is visible, set proper mode for indicator server according to bg mode
1365     if( opacityMode == Dali::Window::OPAQUE )
1366     {
1367       ecore_wl_window_indicator_opacity_set( mEcoreWindow, ECORE_WL_INDICATOR_OPAQUE );
1368     }
1369     else if( opacityMode == Dali::Window::TRANSLUCENT )
1370     {
1371       ecore_wl_window_indicator_opacity_set( mEcoreWindow, ECORE_WL_INDICATOR_TRANSLUCENT );
1372     }
1373     else if( opacityMode == Dali::Window::TRANSPARENT )
1374     {
1375       ecore_wl_window_indicator_opacity_set( mEcoreWindow, ECORE_WL_INDICATOR_OPAQUE );
1376     }
1377   }
1378   else
1379   {
1380     // when the indicator is not visible, set TRANSPARENT mode for indicator server
1381     ecore_wl_window_indicator_opacity_set( mEcoreWindow, ECORE_WL_INDICATOR_TRANSPARENT); // it means hidden indicator
1382   }
1383 }
1384
1385 void WindowBaseEcoreWl::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation )
1386 {
1387   if( isShow )
1388   {
1389     ecore_wl_window_indicator_state_set( mEcoreWindow, ECORE_WL_INDICATOR_STATE_ON );
1390   }
1391   else
1392   {
1393     ecore_wl_window_indicator_state_set( mEcoreWindow, ECORE_WL_INDICATOR_STATE_OFF );
1394   }
1395 }
1396
1397 void WindowBaseEcoreWl::IndicatorTypeChanged( IndicatorInterface::Type type )
1398 {
1399 #if defined(DALI_PROFILE_MOBILE)
1400   switch( type )
1401   {
1402     case IndicatorInterface::INDICATOR_TYPE_1:
1403     {
1404       ecore_wl_indicator_visible_type_set( mEcoreWindow, ECORE_WL_INDICATOR_VISIBLE_TYPE_SHOWN );
1405       break;
1406     }
1407     case IndicatorInterface::INDICATOR_TYPE_2:
1408     {
1409       ecore_wl_indicator_visible_type_set( mEcoreWindow, ECORE_WL_INDICATOR_VISIBLE_TYPE_HIDDEN );
1410       break;
1411     }
1412     case IndicatorInterface::INDICATOR_TYPE_UNKNOWN:
1413     default:
1414     {
1415       break;
1416     }
1417   }
1418 #endif //MOBILE
1419 }
1420
1421 void WindowBaseEcoreWl::SetClass( const std::string& name, const std::string& className )
1422 {
1423   ecore_wl_window_title_set( mEcoreWindow, name.c_str() );
1424   ecore_wl_window_class_name_set( mEcoreWindow, className.c_str() );
1425 }
1426
1427 void WindowBaseEcoreWl::Raise()
1428 {
1429   // Use ecore_wl_window_activate to prevent the window shown without rendering
1430   ecore_wl_window_activate( mEcoreWindow );
1431 }
1432
1433 void WindowBaseEcoreWl::Lower()
1434 {
1435   ecore_wl_window_lower( mEcoreWindow );
1436 }
1437
1438 void WindowBaseEcoreWl::Activate()
1439 {
1440   ecore_wl_window_activate( mEcoreWindow );
1441 }
1442
1443 void WindowBaseEcoreWl::SetAvailableOrientations( const std::vector< Dali::Window::WindowOrientation >& orientations )
1444 {
1445   int rotations[4] = { 0 };
1446   for( std::size_t i = 0; i < orientations.size(); ++i )
1447   {
1448     rotations[i] = static_cast< int >( orientations[i] );
1449   }
1450   ecore_wl_window_rotation_available_rotations_set( mEcoreWindow, rotations, orientations.size() );
1451 }
1452
1453 void WindowBaseEcoreWl::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
1454 {
1455   ecore_wl_window_rotation_preferred_rotation_set( mEcoreWindow, orientation );
1456 }
1457
1458 void WindowBaseEcoreWl::SetAcceptFocus( bool accept )
1459 {
1460   ecore_wl_window_focus_skip_set( mEcoreWindow, !accept );
1461 }
1462
1463 void WindowBaseEcoreWl::Show()
1464 {
1465   ecore_wl_window_show( mEcoreWindow );
1466 }
1467
1468 void WindowBaseEcoreWl::Hide()
1469 {
1470   ecore_wl_window_hide( mEcoreWindow );
1471 }
1472
1473 unsigned int WindowBaseEcoreWl::GetSupportedAuxiliaryHintCount() const
1474 {
1475   return mSupportedAuxiliaryHints.size();
1476 }
1477
1478 std::string WindowBaseEcoreWl::GetSupportedAuxiliaryHint( unsigned int index ) const
1479 {
1480   if( index >= GetSupportedAuxiliaryHintCount() )
1481   {
1482     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
1483   }
1484
1485   return mSupportedAuxiliaryHints[index];
1486 }
1487
1488 unsigned int WindowBaseEcoreWl::AddAuxiliaryHint( const std::string& hint, const std::string& value )
1489 {
1490   bool supported = false;
1491
1492   // Check if the hint is suppported
1493   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1494   {
1495     if( *iter == hint )
1496     {
1497       supported = true;
1498       break;
1499     }
1500   }
1501
1502   if( !supported )
1503   {
1504     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1505     return 0;
1506   }
1507
1508   // Check if the hint is already added
1509   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1510   {
1511     if( mAuxiliaryHints[i].first == hint )
1512     {
1513       // Just change the value
1514       mAuxiliaryHints[i].second = value;
1515
1516       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1517
1518       return i + 1;   // id is index + 1
1519     }
1520   }
1521
1522   // Add the hint
1523   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1524
1525   unsigned int id = mAuxiliaryHints.size();
1526
1527   ecore_wl_window_aux_hint_add( mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1528
1529   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1530
1531   return id;
1532 }
1533
1534 bool WindowBaseEcoreWl::RemoveAuxiliaryHint( unsigned int id )
1535 {
1536   if( id == 0 || id > mAuxiliaryHints.size() )
1537   {
1538     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1539     return false;
1540   }
1541
1542   mAuxiliaryHints[id - 1].second = std::string();
1543
1544   ecore_wl_window_aux_hint_del( mEcoreWindow, static_cast< int >( id ) );
1545
1546   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1547
1548   return true;
1549 }
1550
1551 bool WindowBaseEcoreWl::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1552 {
1553   if( id == 0 || id > mAuxiliaryHints.size() )
1554   {
1555     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1556     return false;
1557   }
1558
1559   mAuxiliaryHints[id - 1].second = value;
1560
1561   ecore_wl_window_aux_hint_change( mEcoreWindow, static_cast< int >( id ), value.c_str() );
1562
1563   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str() );
1564
1565   return true;
1566 }
1567
1568 std::string WindowBaseEcoreWl::GetAuxiliaryHintValue( unsigned int id ) const
1569 {
1570   if( id == 0 || id > mAuxiliaryHints.size() )
1571   {
1572     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1573     return std::string();
1574   }
1575
1576   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str() );
1577
1578   return mAuxiliaryHints[id - 1].second;
1579 }
1580
1581 unsigned int WindowBaseEcoreWl::GetAuxiliaryHintId( const std::string& hint ) const
1582 {
1583   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1584   {
1585     if( mAuxiliaryHints[i].first == hint )
1586     {
1587       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1588       return i + 1;
1589     }
1590   }
1591
1592   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1593
1594   return 0;
1595 }
1596
1597 void WindowBaseEcoreWl::SetInputRegion( const Rect< int >& inputRegion )
1598 {
1599   ecore_wl_window_input_region_set( mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1600 }
1601
1602 void WindowBaseEcoreWl::SetType( Dali::Window::Type type )
1603 {
1604   Ecore_Wl_Window_Type windowType;
1605
1606   switch( type )
1607   {
1608     case Dali::Window::NORMAL:
1609     {
1610       windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1611       break;
1612     }
1613     case Dali::Window::NOTIFICATION:
1614     {
1615       windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1616       break;
1617     }
1618     case Dali::Window::UTILITY:
1619     {
1620       windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1621       break;
1622     }
1623     case Dali::Window::DIALOG:
1624     {
1625       windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1626       break;
1627     }
1628     default:
1629     {
1630       windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1631       break;
1632     }
1633   }
1634
1635   ecore_wl_window_type_set( mEcoreWindow, windowType );
1636 }
1637
1638 bool WindowBaseEcoreWl::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1639 {
1640   while( !mTizenPolicy )
1641   {
1642     wl_display_dispatch_queue( mDisplay, mEventQueue );
1643   }
1644
1645   int notificationLevel;
1646
1647   switch( level )
1648   {
1649     case Dali::Window::NotificationLevel::NONE:
1650     {
1651       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1652       break;
1653     }
1654     case Dali::Window::NotificationLevel::BASE:
1655     {
1656       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1657       break;
1658     }
1659     case Dali::Window::NotificationLevel::MEDIUM:
1660     {
1661       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1662       break;
1663     }
1664     case Dali::Window::NotificationLevel::HIGH:
1665     {
1666       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1667       break;
1668     }
1669     case Dali::Window::NotificationLevel::TOP:
1670     {
1671       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1672       break;
1673     }
1674     default:
1675     {
1676       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: invalid level [%d]\n", level );
1677       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1678       break;
1679     }
1680   }
1681
1682   mNotificationLevelChangeDone = false;
1683   mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1684
1685   tizen_policy_set_notification_level( mTizenPolicy, ecore_wl_window_surface_get( mEcoreWindow ), notificationLevel );
1686
1687   int count = 0;
1688
1689   while( !mNotificationLevelChangeDone && count < 3 )
1690   {
1691     ecore_wl_flush();
1692     wl_display_dispatch_queue( mDisplay, mEventQueue );
1693     count++;
1694   }
1695
1696   if( !mNotificationLevelChangeDone )
1697   {
1698     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState );
1699     return false;
1700   }
1701   else if( mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1702   {
1703     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Permission denied! [%d]\n", level );
1704     return false;
1705   }
1706
1707   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel );
1708
1709   return true;
1710 }
1711
1712 Dali::Window::NotificationLevel::Type WindowBaseEcoreWl::GetNotificationLevel() const
1713 {
1714   while( !mTizenPolicy )
1715   {
1716     wl_display_dispatch_queue( mDisplay, mEventQueue );
1717   }
1718
1719   int count = 0;
1720
1721   while( !mNotificationLevelChangeDone && count < 3 )
1722   {
1723     ecore_wl_flush();
1724     wl_display_dispatch_queue( mDisplay, mEventQueue );
1725     count++;
1726   }
1727
1728   if( !mNotificationLevelChangeDone )
1729   {
1730     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState );
1731     return Dali::Window::NotificationLevel::NONE;
1732   }
1733
1734   Dali::Window::NotificationLevel::Type level;
1735
1736   switch( mNotificationLevel )
1737   {
1738     case TIZEN_POLICY_LEVEL_NONE:
1739     {
1740       level = Dali::Window::NotificationLevel::NONE;
1741       break;
1742     }
1743     case TIZEN_POLICY_LEVEL_DEFAULT:
1744     {
1745       level = Dali::Window::NotificationLevel::BASE;
1746       break;
1747     }
1748     case TIZEN_POLICY_LEVEL_MEDIUM:
1749     {
1750       level = Dali::Window::NotificationLevel::MEDIUM;
1751       break;
1752     }
1753     case TIZEN_POLICY_LEVEL_HIGH:
1754     {
1755       level = Dali::Window::NotificationLevel::HIGH;
1756       break;
1757     }
1758     case TIZEN_POLICY_LEVEL_TOP:
1759     {
1760       level = Dali::Window::NotificationLevel::TOP;
1761       break;
1762     }
1763     default:
1764     {
1765       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel );
1766       level = Dali::Window::NotificationLevel::NONE;
1767       break;
1768     }
1769   }
1770
1771   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: level [%d]\n", mNotificationLevel );
1772
1773   return level;
1774 }
1775
1776 void WindowBaseEcoreWl::SetOpaqueState( bool opaque )
1777 {
1778   while( !mTizenPolicy )
1779   {
1780     wl_display_dispatch_queue( mDisplay, mEventQueue );
1781   }
1782
1783   tizen_policy_set_opaque_state( mTizenPolicy, ecore_wl_window_surface_get( mEcoreWindow ), ( opaque ? 1 : 0 ) );
1784 }
1785
1786 bool WindowBaseEcoreWl::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1787 {
1788   while( !mTizenPolicy )
1789   {
1790     wl_display_dispatch_queue( mDisplay, mEventQueue );
1791   }
1792
1793   mScreenOffModeChangeDone = false;
1794   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1795
1796   unsigned int mode = 0;
1797
1798   switch( screenOffMode )
1799   {
1800     case Dali::Window::ScreenOffMode::TIMEOUT:
1801     {
1802       mode = 0;
1803       break;
1804     }
1805     case Dali::Window::ScreenOffMode::NEVER:
1806     {
1807       mode = 1;
1808       break;
1809     }
1810   }
1811
1812   tizen_policy_set_window_screen_mode( mTizenPolicy, ecore_wl_window_surface_get( mEcoreWindow ), mode );
1813
1814   int count = 0;
1815
1816   while( !mScreenOffModeChangeDone && count < 3 )
1817   {
1818     ecore_wl_flush();
1819     wl_display_dispatch_queue( mDisplay, mEventQueue );
1820     count++;
1821   }
1822
1823   if( !mScreenOffModeChangeDone )
1824   {
1825     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState );
1826     return false;
1827   }
1828   else if( mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1829   {
1830     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
1831     return false;
1832   }
1833
1834   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode );
1835
1836   return true;
1837 }
1838
1839 Dali::Window::ScreenOffMode::Type WindowBaseEcoreWl::GetScreenOffMode() const
1840 {
1841   while( !mTizenPolicy )
1842   {
1843     wl_display_dispatch_queue( mDisplay, mEventQueue );
1844   }
1845
1846   int count = 0;
1847
1848   while( !mScreenOffModeChangeDone && count < 3 )
1849   {
1850     ecore_wl_flush();
1851     wl_display_dispatch_queue( mDisplay, mEventQueue );
1852     count++;
1853   }
1854
1855   if( !mScreenOffModeChangeDone )
1856   {
1857     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState );
1858     return Dali::Window::ScreenOffMode::TIMEOUT;
1859   }
1860
1861   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1862
1863   switch( mScreenOffMode )
1864   {
1865     case 0:
1866     {
1867       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1868       break;
1869     }
1870     case 1:
1871     {
1872       screenMode = Dali::Window::ScreenOffMode::NEVER;
1873       break;
1874     }
1875   }
1876
1877   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode );
1878
1879   return screenMode;
1880 }
1881
1882 bool WindowBaseEcoreWl::SetBrightness( int brightness )
1883 {
1884   while( !mTizenDisplayPolicy )
1885   {
1886     wl_display_dispatch_queue( mDisplay, mEventQueue );
1887   }
1888
1889   mBrightnessChangeDone = false;
1890   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1891
1892   tizen_display_policy_set_window_brightness( mTizenDisplayPolicy, ecore_wl_window_surface_get( mEcoreWindow ), brightness );
1893
1894   int count = 0;
1895
1896   while( !mBrightnessChangeDone && count < 3 )
1897   {
1898     ecore_wl_flush();
1899     wl_display_dispatch_queue( mDisplay, mEventQueue );
1900     count++;
1901   }
1902
1903   if( !mBrightnessChangeDone )
1904   {
1905     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState );
1906     return false;
1907   }
1908   else if( mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1909   {
1910     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Permission denied! [%d]\n", brightness );
1911     return false;
1912   }
1913
1914   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Brightness is changed [%d]\n", mBrightness );
1915
1916   return true;
1917 }
1918
1919 int WindowBaseEcoreWl::GetBrightness() const
1920 {
1921   while( !mTizenDisplayPolicy )
1922   {
1923     wl_display_dispatch_queue( mDisplay, mEventQueue );
1924   }
1925
1926   int count = 0;
1927
1928   while( !mBrightnessChangeDone && count < 3 )
1929   {
1930     ecore_wl_flush();
1931     wl_display_dispatch_queue( mDisplay, mEventQueue );
1932     count++;
1933   }
1934
1935   if( !mBrightnessChangeDone )
1936   {
1937     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetBrightness: Error! [%d]\n", mBrightnessChangeState );
1938     return 0;
1939   }
1940
1941   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetBrightness: Brightness [%d]\n", mBrightness );
1942
1943   return mBrightness;
1944 }
1945
1946 bool WindowBaseEcoreWl::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
1947 {
1948   Ecore_Wl_Window_Keygrab_Mode mode;
1949
1950   switch( grabMode )
1951   {
1952     case KeyGrab::TOPMOST:
1953     {
1954       mode = ECORE_WL_WINDOW_KEYGRAB_TOPMOST;
1955       break;
1956     }
1957     case KeyGrab::SHARED:
1958     {
1959       mode = ECORE_WL_WINDOW_KEYGRAB_SHARED;
1960       break;
1961     }
1962     case KeyGrab::OVERRIDE_EXCLUSIVE:
1963     {
1964       mode = ECORE_WL_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
1965       break;
1966     }
1967     case KeyGrab::EXCLUSIVE:
1968     {
1969       mode = ECORE_WL_WINDOW_KEYGRAB_EXCLUSIVE;
1970       break;
1971     }
1972     default:
1973     {
1974       return false;
1975     }
1976   }
1977
1978   return ecore_wl_window_keygrab_set( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0, 0, mode );
1979 }
1980
1981 bool WindowBaseEcoreWl::UngrabKey( Dali::KEY key )
1982 {
1983   return ecore_wl_window_keygrab_unset( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0 );
1984 }
1985
1986 bool WindowBaseEcoreWl::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
1987 {
1988   int keyCount = key.Count();
1989   int keyGrabModeCount = grabMode.Count();
1990
1991   if( keyCount != keyGrabModeCount || keyCount == 0 )
1992   {
1993     return false;
1994   }
1995
1996   eina_init();
1997
1998   Eina_List* keyList = NULL;
1999   Ecore_Wl_Window_Keygrab_Info* info = new Ecore_Wl_Window_Keygrab_Info[keyCount];
2000
2001   for( int index = 0; index < keyCount; ++index )
2002   {
2003     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2004
2005     switch( grabMode[index] )
2006     {
2007       case KeyGrab::TOPMOST:
2008       {
2009         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_TOPMOST;
2010         break;
2011       }
2012       case KeyGrab::SHARED:
2013       {
2014         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_SHARED;
2015         break;
2016       }
2017       case KeyGrab::OVERRIDE_EXCLUSIVE:
2018       {
2019         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2020         break;
2021       }
2022       case KeyGrab::EXCLUSIVE:
2023       {
2024         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_EXCLUSIVE;
2025         break;
2026       }
2027       default:
2028       {
2029         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_UNKNOWN;
2030         break;
2031       }
2032     }
2033
2034     keyList = eina_list_append( keyList, &info );
2035   }
2036
2037   Eina_List* grabList = ecore_wl_window_keygrab_list_set( mEcoreWindow, keyList );
2038
2039   result.Resize( keyCount, true );
2040
2041   Eina_List* l = NULL;
2042   Eina_List* m = NULL;
2043   void* listData = NULL;
2044   void* data = NULL;
2045   if( grabList != NULL )
2046   {
2047     EINA_LIST_FOREACH( grabList, m, data )
2048     {
2049       int index = 0;
2050       EINA_LIST_FOREACH( keyList, l, listData )
2051       {
2052         if( static_cast< Ecore_Wl_Window_Keygrab_Info* >( listData )->key == NULL )
2053         {
2054           DALI_LOG_ERROR( "input key list has null data!" );
2055           break;
2056         }
2057
2058         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl_Window_Keygrab_Info* >( listData )->key ) == 0 )
2059         {
2060           result[index] = false;
2061         }
2062         ++index;
2063       }
2064     }
2065   }
2066
2067   delete [] info;
2068
2069   eina_list_free( keyList );
2070   eina_list_free( grabList );
2071   eina_shutdown();
2072
2073   return true;
2074 }
2075
2076 bool WindowBaseEcoreWl::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
2077 {
2078   int keyCount = key.Count();
2079   if( keyCount == 0 )
2080   {
2081     return false;
2082   }
2083
2084   eina_init();
2085
2086   Eina_List* keyList = NULL;
2087   Ecore_Wl_Window_Keygrab_Info* info = new Ecore_Wl_Window_Keygrab_Info[keyCount];
2088
2089   for( int index = 0; index < keyCount; ++index )
2090   {
2091     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2092     keyList = eina_list_append( keyList, &info );
2093   }
2094
2095   Eina_List* ungrabList = ecore_wl_window_keygrab_list_unset( mEcoreWindow, keyList );
2096
2097   result.Resize( keyCount, true );
2098
2099   Eina_List* l = NULL;
2100   Eina_List* m = NULL;
2101   void *listData = NULL;
2102   void *data = NULL;
2103
2104   if( ungrabList != NULL )
2105   {
2106     EINA_LIST_FOREACH( ungrabList, m, data )
2107     {
2108       int index = 0;
2109       EINA_LIST_FOREACH( keyList, l, listData )
2110       {
2111         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl_Window_Keygrab_Info* >( listData )->key ) == 0 )
2112         {
2113           result[index] = false;
2114         }
2115         ++index;
2116       }
2117     }
2118   }
2119
2120   delete [] info;
2121
2122   eina_list_free( keyList );
2123   eina_list_free( ungrabList );
2124   eina_shutdown();
2125
2126   return true;
2127 }
2128
2129 void WindowBaseEcoreWl::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
2130 {
2131   // calculate DPI
2132   float xres, yres;
2133
2134   // 1 inch = 25.4 millimeters
2135   xres = ecore_wl_dpi_get();
2136   yres = ecore_wl_dpi_get();
2137
2138   dpiHorizontal = int( xres + 0.5f );  // rounding
2139   dpiVertical   = int( yres + 0.5f );
2140 }
2141
2142 int WindowBaseEcoreWl::GetScreenRotationAngle()
2143 {
2144   int transform = 0;
2145
2146   if( ecore_wl_window_ignore_output_transform_get( mEcoreWindow ) )
2147   {
2148     transform = 0;
2149   }
2150   else
2151   {
2152     transform = ecore_wl_output_transform_get( ecore_wl_window_output_find( mEcoreWindow ) );
2153   }
2154
2155   return transform * 90;
2156 }
2157
2158 void WindowBaseEcoreWl::SetWindowRotationAngle( int degree )
2159 {
2160   ecore_wl_window_rotation_set( mEcoreWindow, degree );
2161 }
2162
2163 void WindowBaseEcoreWl::WindowRotationCompleted( int degree, int width, int height )
2164 {
2165   ecore_wl_window_rotation_change_done_send( mEcoreWindow );
2166 }
2167
2168 void WindowBaseEcoreWl::SetTransparency( bool transparent )
2169 {
2170   ecore_wl_window_alpha_set( mEcoreWindow, transparent );
2171 }
2172
2173 void WindowBaseEcoreWl::InitializeEcoreElDBus()
2174 {
2175 #ifdef DALI_ELDBUS_AVAILABLE
2176   Eldbus_Object* object;
2177   Eldbus_Proxy* manager;
2178
2179   if( !( mSystemConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SYSTEM ) ) )
2180   {
2181     DALI_LOG_ERROR( "Unable to get system bus\n" );
2182   }
2183
2184   object = eldbus_object_get( mSystemConnection, BUS, PATH );
2185   if( !object )
2186   {
2187     DALI_LOG_ERROR( "Getting object failed\n" );
2188     return;
2189   }
2190
2191   manager = eldbus_proxy_get( object, INTERFACE );
2192   if( !manager )
2193   {
2194     DALI_LOG_ERROR( "Getting proxy failed\n" );
2195     return;
2196   }
2197
2198   if( !eldbus_proxy_signal_handler_add( manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this ) )
2199   {
2200     DALI_LOG_ERROR( "No signal handler returned\n" );
2201   }
2202 #endif
2203 }
2204
2205 void WindowBaseEcoreWl::CreateWindow( PositionSize positionSize )
2206 {
2207   mEcoreWindow = ecore_wl_window_new( 0, positionSize.x, positionSize.y, positionSize.width, positionSize.height, ECORE_WL_WINDOW_BUFFER_TYPE_EGL_WINDOW );
2208
2209   if ( mEcoreWindow == 0 )
2210   {
2211     DALI_ASSERT_ALWAYS( 0 && "Failed to create Wayland window" );
2212   }
2213 }
2214
2215 } // namespace Adaptor
2216
2217 } // namespace Internal
2218
2219 } // namespace Dali
2220
2221 #pragma GCC diagnostic pop