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

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