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   mWindowRotationAngle( 0 ),
 695   mScreenRotationAngle( 0 ),
 696   mSupportedPreProtation( 0 )
 697 #ifdef DALI_ELDBUS_AVAILABLE
 698   , mSystemConnection( NULL )
 699 #endif
 700 {
 701   Initialize( positionSize, surface, isTransparent );
 702 }
 703
 704 WindowBaseEcoreWl2::~WindowBaseEcoreWl2()
 705 {
 706 #ifdef DALI_ELDBUS_AVAILABLE
 707     // Close down ElDBus connections.
 708     if( mSystemConnection )
 709     {
 710       eldbus_connection_unref( mSystemConnection );
 711     }
 712 #endif // DALI_ELDBUS_AVAILABLE
 713
 714   vconf_ignore_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged );
 715   vconf_ignore_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged );
 716
 717   for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter )
 718   {
 719     ecore_event_handler_del( *iter );
 720   }
 721   mEcoreEventHandler.Clear();
 722
 723   if( mEventQueue )
 724   {
 725     wl_event_queue_destroy( mEventQueue );
 726   }
 727
 728   mSupportedAuxiliaryHints.clear();
 729   mAuxiliaryHints.clear();
 730
 731   if( mEglWindow != NULL )
 732   {
 733     wl_egl_window_destroy( mEglWindow );
 734     mEglWindow = NULL;
 735   }
 736
 737   if( mOwnSurface )
 738   {
 739     ecore_wl2_window_free( mEcoreWindow );
 740
 741     WindowSystem::Shutdown();
 742   }
 743 }
 744
 745 void WindowBaseEcoreWl2::Initialize( PositionSize positionSize, Any surface, bool isTransparent )
 746 {
 747   if( surface.Empty() == false )
 748   {
 749     // check we have a valid type
 750     DALI_ASSERT_ALWAYS( ( surface.GetType() == typeid (Ecore_Wl2_Window *) ) && "Surface type is invalid" );
 751
 752     mEcoreWindow = AnyCast< Ecore_Wl2_Window* >( surface );
 753   }
 754   else
 755   {
 756     // we own the surface about to created
 757     WindowSystem::Initialize();
 758
 759     mOwnSurface = true;
 760     CreateWindow( positionSize );
 761   }
 762
 763   mWlSurface = ecore_wl2_window_surface_get( mEcoreWindow );
 764
 765   SetTransparency( isTransparent );
 766
 767   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) );
 768   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_FOCUS_IN,                    EcoreEventWindowFocusIn,             this ) );
 769   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_FOCUS_OUT,                   EcoreEventWindowFocusOut,            this ) );
 770   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_OUTPUT_TRANSFORM,            EcoreEventOutputTransform,           this ) );
 771   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_IGNORE_OUTPUT_TRANSFORM,     EcoreEventIgnoreOutputTransform,     this ) );
 772
 773   // Register Rotate event
 774   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_ROTATE,               EcoreEventRotate,                    this ) );
 775
 776   // Register Configure event
 777   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_CONFIGURE,            EcoreEventConfigure,                 this ) );
 778
 779   // Register Touch events
 780   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,               EcoreEventMouseButtonDown,           this ) );
 781   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,                 EcoreEventMouseButtonUp,             this ) );
 782   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE,                      EcoreEventMouseButtonMove,           this ) );
 783   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_CANCEL,             EcoreEventMouseButtonCancel,         this ) );
 784
 785   // Register Mouse wheel events
 786   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL,                     EcoreEventMouseWheel,                this ) );
 787
 788   // Register Detent event
 789   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_DETENT_ROTATE,                   EcoreEventDetentRotation,            this ) );
 790
 791   // Register Key events
 792   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN,                        EcoreEventKeyDown,                   this ) );
 793   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_UP,                          EcoreEventKeyUp,                     this ) );
 794
 795   // Register Selection event - clipboard selection
 796   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_DATA_SOURCE_SEND,            EcoreEventDataSend,                  this ) );
 797   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SELECTION_DATA_READY,        EcoreEventDataReceive,               this ) );
 798
 799   // Register Effect Start/End event
 800   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_EFFECT_START,                EcoreEventEffectStart,               this ) );
 801   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_EFFECT_END,                  EcoreEventEffectEnd,                 this ) );
 802
 803   // Register Vconf notify - font name and size
 804   vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this );
 805   vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this );
 806
 807   InitializeEcoreElDBus();
 808
 809   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get( NULL );
 810   mDisplay = ecore_wl2_display_get( display );
 811
 812   if( mDisplay )
 813   {
 814     wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) );
 815     if( displayWrapper )
 816     {
 817       mEventQueue = wl_display_create_queue( mDisplay );
 818       if( mEventQueue )
 819       {
 820         wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue );
 821
 822         wl_registry* registry = wl_display_get_registry( displayWrapper );
 823         wl_registry_add_listener( registry, &registryListener, this );
 824       }
 825
 826       wl_proxy_wrapper_destroy( displayWrapper );
 827     }
 828   }
 829
 830   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get( display );
 831
 832   if( ecoreWlInput )
 833   {
 834     mKeyMap = ecore_wl2_input_keymap_get( ecoreWlInput );
 835
 836     mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this ) );
 837   }
 838
 839   // get auxiliary hint
 840   Eina_List* hints = ecore_wl2_window_aux_hints_supported_get( mEcoreWindow );
 841   if( hints )
 842   {
 843     Eina_List* l = NULL;
 844     char* hint = NULL;
 845
 846     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) ) ) )
 847     {
 848       mSupportedAuxiliaryHints.push_back( hint );
 849
 850       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::Initialize: %s\n", hint );
 851     }
 852   }
 853 }
 854
 855 Eina_Bool WindowBaseEcoreWl2::OnIconifyStateChanged( void* data, int type, void* event )
 856 {
 857   Ecore_Wl2_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl2_Event_Window_Iconify_State_Change* >( event ) );
 858   Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 859
 860   if( iconifyChangedEvent->win == static_cast< unsigned int>( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 861   {
 862     if( iconifyChangedEvent->iconified == EINA_TRUE )
 863     {
 864       mIconifyChangedSignal.Emit( true );
 865     }
 866     else
 867     {
 868       mIconifyChangedSignal.Emit( false );
 869     }
 870     handled = ECORE_CALLBACK_DONE;
 871   }
 872
 873   return handled;
 874 }
 875
 876 Eina_Bool WindowBaseEcoreWl2::OnFocusIn( void* data, int type, void* event )
 877 {
 878   Ecore_Wl2_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl2_Event_Focus_In* >( event ) );
 879
 880   if( focusInEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 881   {
 882     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
 883
 884     mFocusChangedSignal.Emit( true );
 885   }
 886
 887   return ECORE_CALLBACK_PASS_ON;
 888 }
 889
 890 Eina_Bool WindowBaseEcoreWl2::OnFocusOut( void* data, int type, void* event )
 891 {
 892   Ecore_Wl2_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl2_Event_Focus_Out* >( event ) );
 893
 894   if( focusOutEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 895   {
 896     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
 897
 898     mFocusChangedSignal.Emit( false );
 899   }
 900
 901   return ECORE_CALLBACK_PASS_ON;
 902 }
 903
 904 Eina_Bool WindowBaseEcoreWl2::OnOutputTransform( void* data, int type, void* event )
 905 {
 906   Ecore_Wl2_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl2_Event_Output_Transform* >( event ) );
 907
 908   if( transformEvent->output == ecore_wl2_window_output_find( mEcoreWindow ) )
 909   {
 910     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow );
 911
 912     mOutputTransformedSignal.Emit();
 913   }
 914
 915   return ECORE_CALLBACK_PASS_ON;
 916 }
 917
 918 Eina_Bool WindowBaseEcoreWl2::OnIgnoreOutputTransform( void* data, int type, void* event )
 919 {
 920   Ecore_Wl2_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl2_Event_Ignore_Output_Transform* >( event ) );
 921
 922   if( ignoreTransformEvent->win == mEcoreWindow )
 923   {
 924     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow );
 925
 926     mOutputTransformedSignal.Emit();
 927   }
 928
 929   return ECORE_CALLBACK_PASS_ON;
 930 }
 931
 932 void WindowBaseEcoreWl2::OnRotation( void* data, int type, void* event )
 933 {
 934   Ecore_Wl2_Event_Window_Rotation* ev( static_cast< Ecore_Wl2_Event_Window_Rotation* >( event ) );
 935
 936   if( ev->win == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 937   {
 938     DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h );
 939
 940     RotationEvent rotationEvent;
 941     rotationEvent.angle = ev->angle;
 942     rotationEvent.winResize = 0;
 943
 944     if( ev->angle == 0 || ev->angle == 180 )
 945     {
 946       rotationEvent.width = ev->w;
 947       rotationEvent.height = ev->h;
 948     }
 949     else
 950     {
 951       rotationEvent.width = ev->h;
 952       rotationEvent.height = ev->w;
 953     }
 954
 955     mRotationSignal.Emit( rotationEvent );
 956   }
 957 }
 958
 959 void WindowBaseEcoreWl2::OnConfiguration( void* data, int type, void* event )
 960 {
 961   Ecore_Wl2_Event_Window_Configure* ev( static_cast< Ecore_Wl2_Event_Window_Configure* >( event ) );
 962
 963   if( ev->win == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 964   {
 965     // Note: To comply with the wayland protocol, Dali should make an ack_configure
 966     // by calling ecore_wl2_window_commit
 967     ecore_wl2_window_commit(mEcoreWindow, EINA_FALSE);
 968   }
 969 }
 970
 971 void WindowBaseEcoreWl2::OnMouseButtonDown( void* data, int type, void* event )
 972 {
 973   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 974
 975   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 976   {
 977     Device::Class::Type deviceClass;
 978     Device::Subclass::Type deviceSubclass;
 979
 980     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 981     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 982
 983     PointState::Type state ( PointState::DOWN );
 984
 985     if( deviceClass != Device::Class::Type::MOUSE )
 986     {
 987       // Check if the buttons field is set and ensure it's the primary touch button.
 988       // If this event was triggered by buttons other than the primary button (used for touch), then
 989       // just send an interrupted event to Core.
 990       if( touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID ) )
 991       {
 992         state = PointState::INTERRUPTED;
 993       }
 994     }
 995
 996     Integration::Point point;
 997     point.SetDeviceId( touchEvent->multi.device );
 998     point.SetState( state );
 999     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
1000     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
1001     point.SetPressure( touchEvent->multi.pressure );
1002     point.SetAngle( Degree( touchEvent->multi.angle ) );
1003     point.SetDeviceClass( deviceClass );
1004     point.SetDeviceSubclass( deviceSubclass );
1005     point.SetMouseButton( static_cast< MouseButton::Type >( touchEvent->buttons) );
1006
1007     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1008   }
1009 }
1010
1011 void WindowBaseEcoreWl2::OnMouseButtonUp( void* data, int type, void* event )
1012 {
1013   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
1014
1015   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1016   {
1017     Device::Class::Type deviceClass;
1018     Device::Subclass::Type deviceSubclass;
1019
1020     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
1021     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
1022
1023     Integration::Point point;
1024     point.SetDeviceId( touchEvent->multi.device );
1025     point.SetState( PointState::UP );
1026     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
1027     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
1028     point.SetPressure( touchEvent->multi.pressure );
1029     point.SetAngle( Degree( touchEvent->multi.angle ) );
1030     point.SetDeviceClass( deviceClass );
1031     point.SetDeviceSubclass( deviceSubclass );
1032     point.SetMouseButton( static_cast< MouseButton::Type >( touchEvent->buttons) );
1033
1034     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1035   }
1036 }
1037
1038 void WindowBaseEcoreWl2::OnMouseButtonMove( void* data, int type, void* event )
1039 {
1040   Ecore_Event_Mouse_Move* touchEvent = static_cast< Ecore_Event_Mouse_Move* >( event );
1041
1042   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1043   {
1044     Device::Class::Type deviceClass;
1045     Device::Subclass::Type deviceSubclass;
1046
1047     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
1048     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
1049
1050     Integration::Point point;
1051     point.SetDeviceId( touchEvent->multi.device );
1052     point.SetState( PointState::MOTION );
1053     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
1054     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
1055     point.SetPressure( touchEvent->multi.pressure );
1056     point.SetAngle( Degree( touchEvent->multi.angle ) );
1057     point.SetDeviceClass( deviceClass );
1058     point.SetDeviceSubclass( deviceSubclass );
1059
1060     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1061   }
1062 }
1063
1064 void WindowBaseEcoreWl2::OnMouseButtonCancel( void* data, int type, void* event )
1065 {
1066   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
1067
1068   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1069   {
1070     Integration::Point point;
1071     point.SetDeviceId( touchEvent->multi.device );
1072     point.SetState( PointState::INTERRUPTED );
1073     point.SetScreenPosition( Vector2( 0.0f, 0.0f ) );
1074
1075     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1076
1077     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseButtonCancel\n" );
1078   }
1079 }
1080
1081 void WindowBaseEcoreWl2::OnMouseWheel( void* data, int type, void* event )
1082 {
1083   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast< Ecore_Event_Mouse_Wheel* >( event );
1084
1085   if( mouseWheelEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1086   {
1087     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseWheel: direction: %d, modifiers: %d, x: %d, y: %d, z: %d\n", mouseWheelEvent->direction, mouseWheelEvent->modifiers, mouseWheelEvent->x, mouseWheelEvent->y, mouseWheelEvent->z );
1088
1089     WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2( mouseWheelEvent->x, mouseWheelEvent->y ), mouseWheelEvent->z, mouseWheelEvent->timestamp );
1090
1091     mWheelEventSignal.Emit( wheelEvent );
1092   }
1093 }
1094
1095 void WindowBaseEcoreWl2::OnDetentRotation( void* data, int type, void* event )
1096 {
1097   Ecore_Event_Detent_Rotate* detentEvent = static_cast< Ecore_Event_Detent_Rotate* >( event );
1098
1099   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n" );
1100
1101   int direction = ( detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE ) ? 1 : -1;
1102   int timeStamp = detentEvent->timestamp;
1103
1104   WheelEvent wheelEvent( WheelEvent::CUSTOM_WHEEL, direction, 0, Vector2( 0.0f, 0.0f ), 0, timeStamp );
1105
1106   mWheelEventSignal.Emit( wheelEvent );
1107 }
1108
1109 void WindowBaseEcoreWl2::OnKeyDown( void* data, int type, void* event )
1110 {
1111   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
1112
1113   if( keyEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1114   {
1115     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyDown\n" );
1116
1117     std::string keyName( keyEvent->keyname );
1118     std::string logicalKey( "" );
1119     std::string keyString( "" );
1120     std::string compose( "" );
1121
1122     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1123     if( keyEvent->compose )
1124     {
1125       compose = keyEvent->compose;
1126     }
1127
1128     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1129     if( keyEvent->key )
1130     {
1131       logicalKey = keyEvent->key;
1132     }
1133
1134     int keyCode = 0;
1135     GetKeyCode( keyName, keyCode ); // Get key code dynamically.
1136
1137     if( keyCode == 0 )
1138     {
1139       // Get a specific key code from dali key look up table.
1140       keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1141     }
1142
1143     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1144     int modifier( keyEvent->modifiers );
1145     unsigned long time = keyEvent->timestamp;
1146     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1147     {
1148       keyCode = atoi( keyEvent->keyname + 8 );
1149     }
1150
1151     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1152     if( keyEvent->string )
1153     {
1154       keyString = keyEvent->string;
1155     }
1156
1157     std::string deviceName;
1158     Device::Class::Type deviceClass;
1159     Device::Subclass::Type deviceSubclass;
1160
1161     GetDeviceName( keyEvent, deviceName );
1162     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1163     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1164
1165     Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, compose, deviceName, deviceClass, deviceSubclass );
1166
1167      mKeyEventSignal.Emit( keyEvent );
1168   }
1169 }
1170
1171 void WindowBaseEcoreWl2::OnKeyUp( void* data, int type, void* event )
1172 {
1173   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
1174
1175   if( keyEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1176   {
1177     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp\n" );
1178
1179     std::string keyName( keyEvent->keyname );
1180     std::string logicalKey( "" );
1181     std::string keyString( "" );
1182     std::string compose( "" );
1183
1184     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1185     if( keyEvent->compose )
1186     {
1187       compose = keyEvent->compose;
1188     }
1189
1190     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1191     if( keyEvent->key )
1192     {
1193       logicalKey = keyEvent->key;
1194     }
1195
1196     int keyCode = 0;
1197     GetKeyCode( keyName, keyCode ); // Get key code dynamically.
1198
1199     if( keyCode == 0 )
1200     {
1201       // Get a specific key code from dali key look up table.
1202       keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1203     }
1204
1205     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1206     int modifier( keyEvent->modifiers );
1207     unsigned long time = keyEvent->timestamp;
1208     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1209     {
1210       keyCode = atoi( keyEvent->keyname + 8 );
1211     }
1212
1213     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1214     if( keyEvent->string )
1215     {
1216       keyString = keyEvent->string;
1217     }
1218
1219     std::string deviceName;
1220     Device::Class::Type deviceClass;
1221     Device::Subclass::Type deviceSubclass;
1222
1223     GetDeviceName( keyEvent, deviceName );
1224     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1225     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1226
1227     Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, compose, deviceName, deviceClass, deviceSubclass );
1228
1229      mKeyEventSignal.Emit( keyEvent );
1230   }
1231 }
1232
1233 void WindowBaseEcoreWl2::OnDataSend( void* data, int type, void* event )
1234 {
1235   mSelectionDataSendSignal.Emit( event );
1236 }
1237
1238 void WindowBaseEcoreWl2::OnDataReceive( void* data, int type, void* event )
1239 {
1240   mSelectionDataReceivedSignal.Emit( event  );
1241 }
1242
1243 void WindowBaseEcoreWl2::OnFontNameChanged()
1244 {
1245   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_CHANGE );
1246 }
1247
1248 void WindowBaseEcoreWl2::OnFontSizeChanged()
1249 {
1250   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
1251 }
1252
1253 void WindowBaseEcoreWl2::OnEcoreElDBusAccessibilityNotification( void* context, const Eldbus_Message* message )
1254 {
1255 #ifdef DALI_ELDBUS_AVAILABLE
1256   AccessibilityInfo info;
1257
1258   // The string defines the arg-list's respective types.
1259   if( !eldbus_message_arguments_get( message, "iiiiiiu", &info.gestureValue, &info.startX, &info.startY, &info.endX, &info.endY, &info.state, &info.eventTime ) )
1260   {
1261     DALI_LOG_ERROR( "OnEcoreElDBusAccessibilityNotification: Error getting arguments\n" );
1262   }
1263
1264   mAccessibilitySignal.Emit( info );
1265 #endif
1266 }
1267
1268 void WindowBaseEcoreWl2::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type )
1269 {
1270   mTransitionEffectEventSignal.Emit( state, type );
1271 }
1272
1273 void WindowBaseEcoreWl2::KeymapChanged(void *data, int type, void *event)
1274 {
1275   Ecore_Wl2_Event_Seat_Keymap_Changed *changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>( event );
1276   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id );
1277   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get( changed->display );
1278   if( ecoreWlInput )
1279   {
1280     mKeyMap = ecore_wl2_input_keymap_get( ecoreWlInput );
1281   }
1282 }
1283
1284 void WindowBaseEcoreWl2::RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
1285 {
1286   if( strcmp( interface, tizen_policy_interface.name ) == 0 )
1287   {
1288     uint32_t clientVersion = std::min( version, MAX_TIZEN_CLIENT_VERSION );
1289
1290     mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, clientVersion ) );
1291     if( !mTizenPolicy )
1292     {
1293       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" );
1294       return;
1295     }
1296
1297     tizen_policy_add_listener( mTizenPolicy, &tizenPolicyListener, data );
1298
1299     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" );
1300   }
1301   else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 )
1302   {
1303     mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) );
1304     if( !mTizenDisplayPolicy )
1305     {
1306       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" );
1307       return;
1308     }
1309
1310     tizen_display_policy_add_listener( mTizenDisplayPolicy, &tizenDisplayPolicyListener, data );
1311
1312     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" );
1313   }
1314 }
1315
1316 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
1317 {
1318   mTizenPolicy = NULL;
1319   mTizenDisplayPolicy = NULL;
1320 }
1321
1322 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
1323 {
1324   mNotificationLevel = level;
1325   mNotificationChangeState = state;
1326   mNotificationLevelChangeDone = true;
1327
1328   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state );
1329 }
1330
1331 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
1332 {
1333   mScreenOffMode = mode;
1334   mScreenOffModeChangeState = state;
1335   mScreenOffModeChangeDone = true;
1336
1337   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
1338 }
1339
1340 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
1341 {
1342   mBrightness = brightness;
1343   mBrightnessChangeState = state;
1344   mBrightnessChangeDone = true;
1345
1346   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
1347 }
1348
1349 void WindowBaseEcoreWl2::GetKeyCode( std::string keyName, int32_t& keyCode )
1350 {
1351   xkb_keysym_t sym = XKB_KEY_NoSymbol;
1352   KeyCodeMap foundKeyCode;
1353
1354   sym = xkb_keysym_from_name( keyName.c_str(), XKB_KEYSYM_NO_FLAGS );
1355   if( sym == XKB_KEY_NoSymbol )
1356   {
1357     DALI_LOG_ERROR( "Failed to get keysym in WindowBaseEcoreWl2\n" );
1358     return;
1359   }
1360
1361   foundKeyCode.keySym = sym;
1362   foundKeyCode.isKeyCode = false;
1363   xkb_keymap_key_for_each( mKeyMap, FindKeyCode, &foundKeyCode );
1364   keyCode = static_cast< int32_t >( foundKeyCode.keyCode );
1365 }
1366
1367 Any WindowBaseEcoreWl2::GetNativeWindow()
1368 {
1369   return mEcoreWindow;
1370 }
1371
1372 int WindowBaseEcoreWl2::GetNativeWindowId()
1373 {
1374   return ecore_wl2_window_id_get( mEcoreWindow );
1375 }
1376
1377 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow( int width, int height )
1378 {
1379   mEglWindow = wl_egl_window_create( mWlSurface, width, height );
1380
1381   return static_cast< EGLNativeWindowType >( mEglWindow );
1382 }
1383
1384 void WindowBaseEcoreWl2::DestroyEglWindow()
1385 {
1386   if( mEglWindow != NULL )
1387   {
1388     wl_egl_window_destroy( mEglWindow );
1389     mEglWindow = NULL;
1390   }
1391 }
1392
1393 void WindowBaseEcoreWl2::SetEglWindowRotation( int angle )
1394 {
1395   wl_egl_window_tizen_rotation rotation;
1396
1397   switch( angle )
1398   {
1399     case 0:
1400     {
1401       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0 ;
1402       break;
1403     }
1404     case 90:
1405     {
1406       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
1407       break;
1408     }
1409     case 180:
1410     {
1411       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
1412       break;
1413     }
1414     case 270:
1415     {
1416       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
1417       break;
1418     }
1419     default:
1420     {
1421       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0 ;
1422       break;
1423     }
1424   }
1425
1426   wl_egl_window_tizen_set_rotation( mEglWindow, rotation );
1427 }
1428
1429 void WindowBaseEcoreWl2::SetEglWindowBufferTransform( int angle )
1430 {
1431   wl_output_transform bufferTransform;
1432
1433   switch( angle )
1434   {
1435     case 0:
1436     {
1437       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1438       break;
1439     }
1440     case 90:
1441     {
1442       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1443       break;
1444     }
1445     case 180:
1446     {
1447       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1448       break;
1449     }
1450     case 270:
1451     {
1452       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1453       break;
1454     }
1455     default:
1456     {
1457       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1458       break;
1459     }
1460   }
1461
1462   wl_egl_window_tizen_set_buffer_transform( mEglWindow, bufferTransform );
1463 }
1464
1465 void WindowBaseEcoreWl2::SetEglWindowTransform( int angle )
1466 {
1467   wl_output_transform windowTransform;
1468
1469   switch( angle )
1470   {
1471     case 0:
1472     {
1473       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1474       break;
1475     }
1476     case 90:
1477     {
1478       windowTransform = WL_OUTPUT_TRANSFORM_90;
1479       break;
1480     }
1481     case 180:
1482     {
1483       windowTransform = WL_OUTPUT_TRANSFORM_180;
1484       break;
1485     }
1486     case 270:
1487     {
1488       windowTransform = WL_OUTPUT_TRANSFORM_270;
1489       break;
1490     }
1491     default:
1492     {
1493       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1494       break;
1495     }
1496   }
1497
1498   wl_egl_window_tizen_set_window_transform( mEglWindow, windowTransform );
1499 }
1500
1501 void WindowBaseEcoreWl2::ResizeEglWindow( PositionSize positionSize )
1502 {
1503   wl_egl_window_resize( mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y );
1504
1505   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
1506   if( mMoveResizeSerial != mLastSubmittedMoveResizeSerial )
1507   {
1508     wl_egl_window_tizen_set_window_serial( mEglWindow, mMoveResizeSerial );
1509     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
1510   }
1511 }
1512
1513 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
1514 {
1515   // Check capability
1516   wl_egl_window_tizen_capability capability = static_cast< wl_egl_window_tizen_capability >( wl_egl_window_tizen_get_capabilities( mEglWindow ) );
1517   if( capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED )
1518   {
1519     mSupportedPreProtation = true;
1520     return true;
1521   }
1522   mSupportedPreProtation = false;
1523   return false;
1524 }
1525
1526 void WindowBaseEcoreWl2::Move( PositionSize positionSize )
1527 {
1528   ecore_wl2_window_position_set( mEcoreWindow, positionSize.x, positionSize.y );
1529 }
1530
1531 void WindowBaseEcoreWl2::Resize( PositionSize positionSize )
1532 {
1533   ecore_wl2_window_geometry_set( mEcoreWindow, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
1534 }
1535
1536 void WindowBaseEcoreWl2::MoveResize( PositionSize positionSize )
1537 {
1538   ecore_wl2_window_sync_geometry_set( mEcoreWindow, ++mMoveResizeSerial, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
1539 }
1540
1541 void WindowBaseEcoreWl2::SetClass( const std::string& name, const std::string& className )
1542 {
1543   ecore_wl2_window_title_set( mEcoreWindow, name.c_str() );
1544   ecore_wl2_window_class_set( mEcoreWindow, className.c_str() );
1545 }
1546
1547 void WindowBaseEcoreWl2::Raise()
1548 {
1549   // Use ecore_wl2_window_activate to prevent the window shown without rendering
1550   ecore_wl2_window_activate( mEcoreWindow );
1551 }
1552
1553 void WindowBaseEcoreWl2::Lower()
1554 {
1555   ecore_wl2_window_lower( mEcoreWindow );
1556 }
1557
1558 void WindowBaseEcoreWl2::Activate()
1559 {
1560   ecore_wl2_window_activate( mEcoreWindow );
1561 }
1562
1563 void WindowBaseEcoreWl2::SetAvailableAnlges( const std::vector< int >& angles )
1564 {
1565   int rotations[4] = { 0 };
1566   DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size() );
1567   for( std::size_t i = 0; i < angles.size(); ++i )
1568   {
1569     rotations[i] = static_cast< int >( angles[i] );
1570     DALI_LOG_RELEASE_INFO( "%d ", rotations[i] );
1571   }
1572   ecore_wl2_window_available_rotations_set( mEcoreWindow, rotations, angles.size() );
1573 }
1574
1575 void WindowBaseEcoreWl2::SetPreferredAngle( int angle )
1576 {
1577   ecore_wl2_window_preferred_rotation_set( mEcoreWindow, angle );
1578 }
1579
1580 void WindowBaseEcoreWl2::SetAcceptFocus( bool accept )
1581 {
1582   ecore_wl2_window_focus_skip_set( mEcoreWindow, !accept );
1583 }
1584
1585 void WindowBaseEcoreWl2::Show()
1586 {
1587   ecore_wl2_window_show( mEcoreWindow );
1588 }
1589
1590 void WindowBaseEcoreWl2::Hide()
1591 {
1592   ecore_wl2_window_hide( mEcoreWindow );
1593 }
1594
1595 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1596 {
1597   return mSupportedAuxiliaryHints.size();
1598 }
1599
1600 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint( unsigned int index ) const
1601 {
1602   if( index >= GetSupportedAuxiliaryHintCount() )
1603   {
1604     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
1605   }
1606
1607   return mSupportedAuxiliaryHints[index];
1608 }
1609
1610 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint( const std::string& hint, const std::string& value )
1611 {
1612   bool supported = false;
1613
1614   // Check if the hint is suppported
1615   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1616   {
1617     if( *iter == hint )
1618     {
1619       supported = true;
1620       break;
1621     }
1622   }
1623
1624   if( !supported )
1625   {
1626     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1627     return 0;
1628   }
1629
1630   // Check if the hint is already added
1631   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1632   {
1633     if( mAuxiliaryHints[i].first == hint )
1634     {
1635       // Just change the value
1636       mAuxiliaryHints[i].second = value;
1637
1638       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1639
1640       return i + 1;   // id is index + 1
1641     }
1642   }
1643
1644   // Add the hint
1645   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1646
1647   unsigned int id = mAuxiliaryHints.size();
1648
1649   ecore_wl2_window_aux_hint_add( mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1650
1651   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1652
1653   return id;
1654 }
1655
1656 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint( unsigned int id )
1657 {
1658   if( id == 0 || id > mAuxiliaryHints.size() )
1659   {
1660     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1661     return false;
1662   }
1663
1664   mAuxiliaryHints[id - 1].second = std::string();
1665
1666   ecore_wl2_window_aux_hint_del( mEcoreWindow, static_cast< int >( id ) );
1667
1668   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1669
1670   return true;
1671 }
1672
1673 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1674 {
1675   if( id == 0 || id > mAuxiliaryHints.size() )
1676   {
1677     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1678     return false;
1679   }
1680
1681   mAuxiliaryHints[id - 1].second = value;
1682
1683   ecore_wl2_window_aux_hint_change( mEcoreWindow, static_cast< int >( id ), value.c_str() );
1684
1685   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() );
1686
1687   return true;
1688 }
1689
1690 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue( unsigned int id ) const
1691 {
1692   if( id == 0 || id > mAuxiliaryHints.size() )
1693   {
1694     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1695     return std::string();
1696   }
1697
1698   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() );
1699
1700   return mAuxiliaryHints[id - 1].second;
1701 }
1702
1703 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId( const std::string& hint ) const
1704 {
1705   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1706   {
1707     if( mAuxiliaryHints[i].first == hint )
1708     {
1709       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1710       return i + 1;
1711     }
1712   }
1713
1714   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1715
1716   return 0;
1717 }
1718
1719 void WindowBaseEcoreWl2::SetInputRegion( const Rect< int >& inputRegion )
1720 {
1721   ecore_wl2_window_input_region_set( mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1722 }
1723
1724 void WindowBaseEcoreWl2::SetType( Dali::Window::Type type )
1725 {
1726   Ecore_Wl2_Window_Type windowType;
1727
1728   switch( type )
1729   {
1730     case Dali::Window::NORMAL:
1731     {
1732       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1733       break;
1734     }
1735     case Dali::Window::NOTIFICATION:
1736     {
1737       windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
1738       break;
1739     }
1740     case Dali::Window::UTILITY:
1741     {
1742       windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
1743       break;
1744     }
1745     case Dali::Window::DIALOG:
1746     {
1747       windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
1748       break;
1749     }
1750     default:
1751     {
1752       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1753       break;
1754     }
1755   }
1756
1757   ecore_wl2_window_type_set( mEcoreWindow, windowType );
1758 }
1759
1760 bool WindowBaseEcoreWl2::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1761 {
1762   while( !mTizenPolicy )
1763   {
1764     wl_display_dispatch_queue( mDisplay, mEventQueue );
1765   }
1766
1767   int notificationLevel;
1768
1769   switch( level )
1770   {
1771     case Dali::Window::NotificationLevel::NONE:
1772     {
1773       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1774       break;
1775     }
1776     case Dali::Window::NotificationLevel::BASE:
1777     {
1778       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1779       break;
1780     }
1781     case Dali::Window::NotificationLevel::MEDIUM:
1782     {
1783       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1784       break;
1785     }
1786     case Dali::Window::NotificationLevel::HIGH:
1787     {
1788       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1789       break;
1790     }
1791     case Dali::Window::NotificationLevel::TOP:
1792     {
1793       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1794       break;
1795     }
1796     default:
1797     {
1798       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level );
1799       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1800       break;
1801     }
1802   }
1803
1804   mNotificationLevelChangeDone = false;
1805   mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1806
1807   tizen_policy_set_notification_level( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), notificationLevel );
1808
1809   int count = 0;
1810
1811   while( !mNotificationLevelChangeDone && count < 3 )
1812   {
1813     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1814     wl_display_dispatch_queue( mDisplay, mEventQueue );
1815     count++;
1816   }
1817
1818   if( !mNotificationLevelChangeDone )
1819   {
1820     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState );
1821     return false;
1822   }
1823   else if( mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1824   {
1825     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level );
1826     return false;
1827   }
1828
1829   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel );
1830
1831   return true;
1832 }
1833
1834 Dali::Window::NotificationLevel::Type WindowBaseEcoreWl2::GetNotificationLevel() const
1835 {
1836   while( !mTizenPolicy )
1837   {
1838     wl_display_dispatch_queue( mDisplay, mEventQueue );
1839   }
1840
1841   int count = 0;
1842
1843   while( !mNotificationLevelChangeDone && count < 3 )
1844   {
1845     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1846     wl_display_dispatch_queue( mDisplay, mEventQueue );
1847     count++;
1848   }
1849
1850   if( !mNotificationLevelChangeDone )
1851   {
1852     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState );
1853     return Dali::Window::NotificationLevel::NONE;
1854   }
1855
1856   Dali::Window::NotificationLevel::Type level;
1857
1858   switch( mNotificationLevel )
1859   {
1860     case TIZEN_POLICY_LEVEL_NONE:
1861     {
1862       level = Dali::Window::NotificationLevel::NONE;
1863       break;
1864     }
1865     case TIZEN_POLICY_LEVEL_DEFAULT:
1866     {
1867       level = Dali::Window::NotificationLevel::BASE;
1868       break;
1869     }
1870     case TIZEN_POLICY_LEVEL_MEDIUM:
1871     {
1872       level = Dali::Window::NotificationLevel::MEDIUM;
1873       break;
1874     }
1875     case TIZEN_POLICY_LEVEL_HIGH:
1876     {
1877       level = Dali::Window::NotificationLevel::HIGH;
1878       break;
1879     }
1880     case TIZEN_POLICY_LEVEL_TOP:
1881     {
1882       level = Dali::Window::NotificationLevel::TOP;
1883       break;
1884     }
1885     default:
1886     {
1887       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel );
1888       level = Dali::Window::NotificationLevel::NONE;
1889       break;
1890     }
1891   }
1892
1893   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel );
1894
1895   return level;
1896 }
1897
1898 void WindowBaseEcoreWl2::SetOpaqueState( bool opaque )
1899 {
1900   while( !mTizenPolicy )
1901   {
1902     wl_display_dispatch_queue( mDisplay, mEventQueue );
1903   }
1904
1905   tizen_policy_set_opaque_state( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), ( opaque ? 1 : 0 ) );
1906 }
1907
1908 bool WindowBaseEcoreWl2::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1909 {
1910   while( !mTizenPolicy )
1911   {
1912     wl_display_dispatch_queue( mDisplay, mEventQueue );
1913   }
1914
1915   mScreenOffModeChangeDone = false;
1916   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1917
1918   unsigned int mode = 0;
1919
1920   switch( screenOffMode )
1921   {
1922     case Dali::Window::ScreenOffMode::TIMEOUT:
1923     {
1924       mode = 0;
1925       break;
1926     }
1927     case Dali::Window::ScreenOffMode::NEVER:
1928     {
1929       mode = 1;
1930       break;
1931     }
1932   }
1933
1934   tizen_policy_set_window_screen_mode( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), mode );
1935
1936   int count = 0;
1937
1938   while( !mScreenOffModeChangeDone && count < 3 )
1939   {
1940     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1941     wl_display_dispatch_queue( mDisplay, mEventQueue );
1942     count++;
1943   }
1944
1945   if( !mScreenOffModeChangeDone )
1946   {
1947     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState );
1948     return false;
1949   }
1950   else if( mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1951   {
1952     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
1953     return false;
1954   }
1955
1956   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode );
1957
1958   return true;
1959 }
1960
1961 Dali::Window::ScreenOffMode::Type WindowBaseEcoreWl2::GetScreenOffMode() const
1962 {
1963   while( !mTizenPolicy )
1964   {
1965     wl_display_dispatch_queue( mDisplay, mEventQueue );
1966   }
1967
1968   int count = 0;
1969
1970   while( !mScreenOffModeChangeDone && count < 3 )
1971   {
1972     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1973     wl_display_dispatch_queue( mDisplay, mEventQueue );
1974     count++;
1975   }
1976
1977   if( !mScreenOffModeChangeDone )
1978   {
1979     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState );
1980     return Dali::Window::ScreenOffMode::TIMEOUT;
1981   }
1982
1983   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1984
1985   switch( mScreenOffMode )
1986   {
1987     case 0:
1988     {
1989       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1990       break;
1991     }
1992     case 1:
1993     {
1994       screenMode = Dali::Window::ScreenOffMode::NEVER;
1995       break;
1996     }
1997   }
1998
1999   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode );
2000
2001   return screenMode;
2002 }
2003
2004 bool WindowBaseEcoreWl2::SetBrightness( int brightness )
2005 {
2006   while( !mTizenDisplayPolicy )
2007   {
2008     wl_display_dispatch_queue( mDisplay, mEventQueue );
2009   }
2010
2011   mBrightnessChangeDone = false;
2012   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2013
2014   tizen_display_policy_set_window_brightness( mTizenDisplayPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), brightness );
2015
2016   int count = 0;
2017
2018   while( !mBrightnessChangeDone && count < 3 )
2019   {
2020     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2021     wl_display_dispatch_queue( mDisplay, mEventQueue );
2022     count++;
2023   }
2024
2025   if( !mBrightnessChangeDone )
2026   {
2027     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState );
2028     return false;
2029   }
2030   else if( mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
2031   {
2032     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness );
2033     return false;
2034   }
2035
2036   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness );
2037
2038   return true;
2039 }
2040
2041 int WindowBaseEcoreWl2::GetBrightness() const
2042 {
2043   while( !mTizenDisplayPolicy )
2044   {
2045     wl_display_dispatch_queue( mDisplay, mEventQueue );
2046   }
2047
2048   int count = 0;
2049
2050   while( !mBrightnessChangeDone && count < 3 )
2051   {
2052     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2053     wl_display_dispatch_queue( mDisplay, mEventQueue );
2054     count++;
2055   }
2056
2057   if( !mBrightnessChangeDone )
2058   {
2059     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState );
2060     return 0;
2061   }
2062
2063   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness );
2064
2065   return mBrightness;
2066 }
2067
2068 bool WindowBaseEcoreWl2::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
2069 {
2070   Ecore_Wl2_Window_Keygrab_Mode mode;
2071
2072   switch( grabMode )
2073   {
2074     case KeyGrab::TOPMOST:
2075     {
2076       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2077       break;
2078     }
2079     case KeyGrab::SHARED:
2080     {
2081       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2082       break;
2083     }
2084     case KeyGrab::OVERRIDE_EXCLUSIVE:
2085     {
2086       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2087       break;
2088     }
2089     case KeyGrab::EXCLUSIVE:
2090     {
2091       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2092       break;
2093     }
2094     default:
2095     {
2096       return false;
2097     }
2098   }
2099
2100   return ecore_wl2_window_keygrab_set( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0, 0, mode );
2101 }
2102
2103 bool WindowBaseEcoreWl2::UngrabKey( Dali::KEY key )
2104 {
2105   return ecore_wl2_window_keygrab_unset( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0 );
2106 }
2107
2108 bool WindowBaseEcoreWl2::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
2109 {
2110   int keyCount = key.Count();
2111   int keyGrabModeCount = grabMode.Count();
2112
2113   if( keyCount != keyGrabModeCount || keyCount == 0 )
2114   {
2115     return false;
2116   }
2117
2118   eina_init();
2119
2120   Eina_List* keyList = NULL;
2121   Ecore_Wl2_Window_Keygrab_Info* info = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2122
2123   for( int index = 0; index < keyCount; ++index )
2124   {
2125     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2126
2127     switch( grabMode[index] )
2128     {
2129       case KeyGrab::TOPMOST:
2130       {
2131         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2132         break;
2133       }
2134       case KeyGrab::SHARED:
2135       {
2136         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2137         break;
2138       }
2139       case KeyGrab::OVERRIDE_EXCLUSIVE:
2140       {
2141         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2142         break;
2143       }
2144       case KeyGrab::EXCLUSIVE:
2145       {
2146         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2147         break;
2148       }
2149       default:
2150       {
2151         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2152         break;
2153       }
2154     }
2155
2156     keyList = eina_list_append( keyList, &info );
2157   }
2158
2159   Eina_List* grabList = ecore_wl2_window_keygrab_list_set( mEcoreWindow, keyList );
2160
2161   result.Resize( keyCount, true );
2162
2163   Eina_List* l = NULL;
2164   Eina_List* m = NULL;
2165   void* listData = NULL;
2166   void* data = NULL;
2167   if( grabList != NULL )
2168   {
2169     EINA_LIST_FOREACH( grabList, m, data )
2170     {
2171       int index = 0;
2172       EINA_LIST_FOREACH( keyList, l, listData )
2173       {
2174         if( static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key == NULL )
2175         {
2176           DALI_LOG_ERROR( "input key list has null data!" );
2177           break;
2178         }
2179
2180         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key ) == 0 )
2181         {
2182           result[index] = false;
2183         }
2184         ++index;
2185       }
2186     }
2187   }
2188
2189   delete [] info;
2190
2191   eina_list_free( keyList );
2192   eina_list_free( grabList );
2193   eina_shutdown();
2194
2195   return true;
2196 }
2197
2198 bool WindowBaseEcoreWl2::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
2199 {
2200   int keyCount = key.Count();
2201   if( keyCount == 0 )
2202   {
2203     return false;
2204   }
2205
2206   eina_init();
2207
2208   Eina_List* keyList = NULL;
2209   Ecore_Wl2_Window_Keygrab_Info* info = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2210
2211   for( int index = 0; index < keyCount; ++index )
2212   {
2213     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2214     keyList = eina_list_append( keyList, &info );
2215   }
2216
2217   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset( mEcoreWindow, keyList );
2218
2219   result.Resize( keyCount, true );
2220
2221   Eina_List* l = NULL;
2222   Eina_List* m = NULL;
2223   void *listData = NULL;
2224   void *data = NULL;
2225
2226   if( ungrabList != NULL )
2227   {
2228     EINA_LIST_FOREACH( ungrabList, m, data )
2229     {
2230       int index = 0;
2231       EINA_LIST_FOREACH( keyList, l, listData )
2232       {
2233         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key ) == 0 )
2234         {
2235           result[index] = false;
2236         }
2237         ++index;
2238       }
2239     }
2240   }
2241
2242   delete [] info;
2243
2244   eina_list_free( keyList );
2245   eina_list_free( ungrabList );
2246   eina_shutdown();
2247
2248   return true;
2249 }
2250
2251 void WindowBaseEcoreWl2::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
2252 {
2253   // calculate DPI
2254   float xres, yres;
2255
2256   Ecore_Wl2_Output* output = ecore_wl2_window_output_find( mEcoreWindow );
2257
2258   // 1 inch = 25.4 millimeters
2259   xres = ecore_wl2_output_dpi_get( output );
2260   yres = ecore_wl2_output_dpi_get( output );
2261
2262   dpiHorizontal = int( xres + 0.5f );  // rounding
2263   dpiVertical   = int( yres + 0.5f );
2264 }
2265
2266 int WindowBaseEcoreWl2::GetOrientation() const
2267 {
2268   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2269   if( mSupportedPreProtation )
2270   {
2271     orientation = 0;
2272   }
2273   return orientation;
2274 }
2275
2276 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2277 {
2278   int transform = 0;
2279
2280   if( ecore_wl2_window_ignore_output_transform_get( mEcoreWindow ) )
2281   {
2282     transform = 0;
2283   }
2284   else
2285   {
2286     transform = ecore_wl2_output_transform_get( ecore_wl2_window_output_find( mEcoreWindow ) );
2287   }
2288   mScreenRotationAngle = transform * 90;
2289   return mScreenRotationAngle;
2290 }
2291
2292 void WindowBaseEcoreWl2::SetWindowRotationAngle( int degree )
2293 {
2294   mWindowRotationAngle = degree;
2295   ecore_wl2_window_rotation_set( mEcoreWindow, degree );
2296 }
2297
2298 int WindowBaseEcoreWl2::GetWindowRotationAngle()
2299 {
2300   return mWindowRotationAngle;
2301 }
2302
2303 void WindowBaseEcoreWl2::WindowRotationCompleted( int degree, int width, int height )
2304 {
2305   ecore_wl2_window_rotation_change_done_send( mEcoreWindow, degree, width, height );
2306 }
2307
2308 void WindowBaseEcoreWl2::SetTransparency( bool transparent )
2309 {
2310   ecore_wl2_window_alpha_set( mEcoreWindow, transparent );
2311 }
2312
2313 void WindowBaseEcoreWl2::InitializeEcoreElDBus()
2314 {
2315 #ifdef DALI_ELDBUS_AVAILABLE
2316   Eldbus_Object* object;
2317   Eldbus_Proxy* manager;
2318
2319   if( !( mSystemConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SYSTEM ) ) )
2320   {
2321     DALI_LOG_ERROR( "Unable to get system bus\n" );
2322   }
2323
2324   object = eldbus_object_get( mSystemConnection, BUS, PATH );
2325   if( !object )
2326   {
2327     DALI_LOG_ERROR( "Getting object failed\n" );
2328     return;
2329   }
2330
2331   manager = eldbus_proxy_get( object, INTERFACE );
2332   if( !manager )
2333   {
2334     DALI_LOG_ERROR( "Getting proxy failed\n" );
2335     return;
2336   }
2337
2338   if( !eldbus_proxy_signal_handler_add( manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this ) )
2339   {
2340     DALI_LOG_ERROR( "No signal handler returned\n" );
2341   }
2342 #endif
2343 }
2344
2345 void WindowBaseEcoreWl2::CreateWindow( PositionSize positionSize )
2346 {
2347   Ecore_Wl2_Display* display = ecore_wl2_display_connect( NULL );
2348   if( !display )
2349   {
2350     DALI_ASSERT_ALWAYS( 0 && "Failed to get display" );
2351   }
2352
2353   mEcoreWindow = ecore_wl2_window_new( display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
2354
2355   if ( mEcoreWindow == 0 )
2356   {
2357     DALI_ASSERT_ALWAYS( 0 && "Failed to create Wayland window" );
2358   }
2359
2360   // Set default type
2361   ecore_wl2_window_type_set( mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL );
2362 }
2363
2364 void WindowBaseEcoreWl2::SetParent( WindowBase* parentWinBase )
2365 {
2366   Ecore_Wl2_Window* ecoreParent = NULL;
2367   if( parentWinBase )
2368   {
2369     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>( parentWinBase );
2370     ecoreParent = winBaseEcore2->mEcoreWindow;
2371   }
2372   ecore_wl2_window_parent_set( mEcoreWindow, ecoreParent );
2373 }
2374
2375 } // namespace Adaptor
2376
2377 } // namespace Internal
2378
2379 } // namespace Dali
2380
2381 #pragma GCC diagnostic pop