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