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