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

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