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

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