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