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_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1665   }
1666   mVisible = true;
1667
1668   ecore_wl2_window_show(mEcoreWindow);
1669 }
1670
1671 void WindowBaseEcoreWl2::Hide()
1672 {
1673   mVisible = false;
1674   ecore_wl2_window_hide(mEcoreWindow);
1675 }
1676
1677 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1678 {
1679   return mSupportedAuxiliaryHints.size();
1680 }
1681
1682 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint(unsigned int index) const
1683 {
1684   if(index >= GetSupportedAuxiliaryHintCount())
1685   {
1686     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index);
1687   }
1688
1689   return mSupportedAuxiliaryHints[index];
1690 }
1691
1692 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint(const std::string& hint, const std::string& value)
1693 {
1694   bool supported = false;
1695
1696   // Check if the hint is suppported
1697   for(std::vector<std::string>::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter)
1698   {
1699     if(*iter == hint)
1700     {
1701       supported = true;
1702       break;
1703     }
1704   }
1705
1706   if(!supported)
1707   {
1708     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str());
1709     return 0;
1710   }
1711
1712   // Check if the hint is already added
1713   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1714   {
1715     if(mAuxiliaryHints[i].first == hint)
1716     {
1717       // Just change the value
1718       mAuxiliaryHints[i].second = value;
1719
1720       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1);
1721
1722       return i + 1; // id is index + 1
1723     }
1724   }
1725
1726   // Add the hint
1727   mAuxiliaryHints.push_back(std::pair<std::string, std::string>(hint, value));
1728
1729   unsigned int id = mAuxiliaryHints.size();
1730
1731   ecore_wl2_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
1732
1733   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
1734
1735   return id;
1736 }
1737
1738 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint(unsigned int id)
1739 {
1740   if(id == 0 || id > mAuxiliaryHints.size())
1741   {
1742     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id);
1743     return false;
1744   }
1745
1746   mAuxiliaryHints[id - 1].second = std::string();
1747
1748   ecore_wl2_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
1749
1750   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
1751
1752   return true;
1753 }
1754
1755 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
1756 {
1757   if(id == 0 || id > mAuxiliaryHints.size())
1758   {
1759     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id);
1760     return false;
1761   }
1762
1763   mAuxiliaryHints[id - 1].second = value;
1764
1765   ecore_wl2_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
1766
1767   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());
1768
1769   return true;
1770 }
1771
1772 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue(unsigned int id) const
1773 {
1774   if(id == 0 || id > mAuxiliaryHints.size())
1775   {
1776     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id);
1777     return std::string();
1778   }
1779
1780   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());
1781
1782   return mAuxiliaryHints[id - 1].second;
1783 }
1784
1785 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId(const std::string& hint) const
1786 {
1787   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1788   {
1789     if(mAuxiliaryHints[i].first == hint)
1790     {
1791       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1);
1792       return i + 1;
1793     }
1794   }
1795
1796   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str());
1797
1798   return 0;
1799 }
1800
1801 void WindowBaseEcoreWl2::SetInputRegion(const Rect<int>& inputRegion)
1802 {
1803   ecore_wl2_window_input_region_set(mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height);
1804 }
1805
1806 void WindowBaseEcoreWl2::SetType(Dali::WindowType type)
1807 {
1808   Ecore_Wl2_Window_Type windowType;
1809
1810   switch(type)
1811   {
1812     case Dali::WindowType::NORMAL:
1813     {
1814       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1815       break;
1816     }
1817     case Dali::WindowType::NOTIFICATION:
1818     {
1819       windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
1820       break;
1821     }
1822     case Dali::WindowType::UTILITY:
1823     {
1824       windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
1825       break;
1826     }
1827     case Dali::WindowType::DIALOG:
1828     {
1829       windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
1830       break;
1831     }
1832     default:
1833     {
1834       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1835       break;
1836     }
1837   }
1838
1839   ecore_wl2_window_type_set(mEcoreWindow, windowType);
1840 }
1841
1842 bool WindowBaseEcoreWl2::SetNotificationLevel(Dali::WindowNotificationLevel level)
1843 {
1844   while(!mTizenPolicy)
1845   {
1846     wl_display_dispatch_queue(mDisplay, mEventQueue);
1847   }
1848
1849   int notificationLevel;
1850
1851   switch(level)
1852   {
1853     case Dali::WindowNotificationLevel::NONE:
1854     {
1855       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1856       break;
1857     }
1858     case Dali::WindowNotificationLevel::BASE:
1859     {
1860       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1861       break;
1862     }
1863     case Dali::WindowNotificationLevel::MEDIUM:
1864     {
1865       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1866       break;
1867     }
1868     case Dali::WindowNotificationLevel::HIGH:
1869     {
1870       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1871       break;
1872     }
1873     case Dali::WindowNotificationLevel::TOP:
1874     {
1875       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1876       break;
1877     }
1878     default:
1879     {
1880       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level);
1881       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1882       break;
1883     }
1884   }
1885
1886   mNotificationLevelChangeDone = false;
1887   mNotificationChangeState     = TIZEN_POLICY_ERROR_STATE_NONE;
1888
1889   tizen_policy_set_notification_level(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), notificationLevel);
1890
1891   int count = 0;
1892
1893   while(!mNotificationLevelChangeDone && count < 3)
1894   {
1895     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
1896     wl_display_dispatch_queue(mDisplay, mEventQueue);
1897     count++;
1898   }
1899
1900   if(!mNotificationLevelChangeDone)
1901   {
1902     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState);
1903     return false;
1904   }
1905   else if(mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
1906   {
1907     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level);
1908     return false;
1909   }
1910
1911   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel);
1912
1913   return true;
1914 }
1915
1916 Dali::WindowNotificationLevel WindowBaseEcoreWl2::GetNotificationLevel() const
1917 {
1918   while(!mTizenPolicy)
1919   {
1920     wl_display_dispatch_queue(mDisplay, mEventQueue);
1921   }
1922
1923   int count = 0;
1924
1925   while(!mNotificationLevelChangeDone && count < 3)
1926   {
1927     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
1928     wl_display_dispatch_queue(mDisplay, mEventQueue);
1929     count++;
1930   }
1931
1932   if(!mNotificationLevelChangeDone)
1933   {
1934     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState);
1935     return Dali::WindowNotificationLevel::NONE;
1936   }
1937
1938   Dali::WindowNotificationLevel level;
1939
1940   switch(mNotificationLevel)
1941   {
1942     case TIZEN_POLICY_LEVEL_NONE:
1943     {
1944       level = Dali::WindowNotificationLevel::NONE;
1945       break;
1946     }
1947     case TIZEN_POLICY_LEVEL_DEFAULT:
1948     {
1949       level = Dali::WindowNotificationLevel::BASE;
1950       break;
1951     }
1952     case TIZEN_POLICY_LEVEL_MEDIUM:
1953     {
1954       level = Dali::WindowNotificationLevel::MEDIUM;
1955       break;
1956     }
1957     case TIZEN_POLICY_LEVEL_HIGH:
1958     {
1959       level = Dali::WindowNotificationLevel::HIGH;
1960       break;
1961     }
1962     case TIZEN_POLICY_LEVEL_TOP:
1963     {
1964       level = Dali::WindowNotificationLevel::TOP;
1965       break;
1966     }
1967     default:
1968     {
1969       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel);
1970       level = Dali::WindowNotificationLevel::NONE;
1971       break;
1972     }
1973   }
1974
1975   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel);
1976
1977   return level;
1978 }
1979
1980 void WindowBaseEcoreWl2::SetOpaqueState(bool opaque)
1981 {
1982   while(!mTizenPolicy)
1983   {
1984     wl_display_dispatch_queue(mDisplay, mEventQueue);
1985   }
1986
1987   tizen_policy_set_opaque_state(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), (opaque ? 1 : 0));
1988 }
1989
1990 bool WindowBaseEcoreWl2::SetScreenOffMode(WindowScreenOffMode screenOffMode)
1991 {
1992   while(!mTizenPolicy)
1993   {
1994     wl_display_dispatch_queue(mDisplay, mEventQueue);
1995   }
1996
1997   mScreenOffModeChangeDone  = false;
1998   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1999
2000   unsigned int mode = 0;
2001
2002   switch(screenOffMode)
2003   {
2004     case WindowScreenOffMode::TIMEOUT:
2005     {
2006       mode = 0;
2007       break;
2008     }
2009     case WindowScreenOffMode::NEVER:
2010     {
2011       mode = 1;
2012       break;
2013     }
2014   }
2015
2016   tizen_policy_set_window_screen_mode(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), mode);
2017
2018   int count = 0;
2019
2020   while(!mScreenOffModeChangeDone && count < 3)
2021   {
2022     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2023     wl_display_dispatch_queue(mDisplay, mEventQueue);
2024     count++;
2025   }
2026
2027   if(!mScreenOffModeChangeDone)
2028   {
2029     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState);
2030     return false;
2031   }
2032   else if(mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2033   {
2034     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode);
2035     return false;
2036   }
2037
2038   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode);
2039
2040   return true;
2041 }
2042
2043 WindowScreenOffMode WindowBaseEcoreWl2::GetScreenOffMode() const
2044 {
2045   while(!mTizenPolicy)
2046   {
2047     wl_display_dispatch_queue(mDisplay, mEventQueue);
2048   }
2049
2050   int count = 0;
2051
2052   while(!mScreenOffModeChangeDone && count < 3)
2053   {
2054     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2055     wl_display_dispatch_queue(mDisplay, mEventQueue);
2056     count++;
2057   }
2058
2059   if(!mScreenOffModeChangeDone)
2060   {
2061     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState);
2062     return WindowScreenOffMode::TIMEOUT;
2063   }
2064
2065   WindowScreenOffMode screenMode = WindowScreenOffMode::TIMEOUT;
2066
2067   switch(mScreenOffMode)
2068   {
2069     case 0:
2070     {
2071       screenMode = WindowScreenOffMode::TIMEOUT;
2072       break;
2073     }
2074     case 1:
2075     {
2076       screenMode = WindowScreenOffMode::NEVER;
2077       break;
2078     }
2079   }
2080
2081   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode);
2082
2083   return screenMode;
2084 }
2085
2086 bool WindowBaseEcoreWl2::SetBrightness(int brightness)
2087 {
2088   while(!mTizenDisplayPolicy)
2089   {
2090     wl_display_dispatch_queue(mDisplay, mEventQueue);
2091   }
2092
2093   mBrightnessChangeDone  = false;
2094   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2095
2096   tizen_display_policy_set_window_brightness(mTizenDisplayPolicy, ecore_wl2_window_surface_get(mEcoreWindow), brightness);
2097
2098   int count = 0;
2099
2100   while(!mBrightnessChangeDone && count < 3)
2101   {
2102     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2103     wl_display_dispatch_queue(mDisplay, mEventQueue);
2104     count++;
2105   }
2106
2107   if(!mBrightnessChangeDone)
2108   {
2109     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState);
2110     return false;
2111   }
2112   else if(mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2113   {
2114     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness);
2115     return false;
2116   }
2117
2118   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness);
2119
2120   return true;
2121 }
2122
2123 int WindowBaseEcoreWl2::GetBrightness() const
2124 {
2125   while(!mTizenDisplayPolicy)
2126   {
2127     wl_display_dispatch_queue(mDisplay, mEventQueue);
2128   }
2129
2130   int count = 0;
2131
2132   while(!mBrightnessChangeDone && count < 3)
2133   {
2134     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2135     wl_display_dispatch_queue(mDisplay, mEventQueue);
2136     count++;
2137   }
2138
2139   if(!mBrightnessChangeDone)
2140   {
2141     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState);
2142     return 0;
2143   }
2144
2145   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness);
2146
2147   return mBrightness;
2148 }
2149
2150 bool WindowBaseEcoreWl2::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
2151 {
2152   Ecore_Wl2_Window_Keygrab_Mode mode;
2153
2154   switch(grabMode)
2155   {
2156     case KeyGrab::TOPMOST:
2157     {
2158       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2159       break;
2160     }
2161     case KeyGrab::SHARED:
2162     {
2163       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2164       break;
2165     }
2166     case KeyGrab::OVERRIDE_EXCLUSIVE:
2167     {
2168       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2169       break;
2170     }
2171     case KeyGrab::EXCLUSIVE:
2172     {
2173       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2174       break;
2175     }
2176     default:
2177     {
2178       return false;
2179     }
2180   }
2181
2182   return ecore_wl2_window_keygrab_set(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0, 0, mode);
2183 }
2184
2185 bool WindowBaseEcoreWl2::UngrabKey(Dali::KEY key)
2186 {
2187   return ecore_wl2_window_keygrab_unset(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0);
2188 }
2189
2190 bool WindowBaseEcoreWl2::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
2191 {
2192   int keyCount         = key.Count();
2193   int keyGrabModeCount = grabMode.Count();
2194
2195   if(keyCount != keyGrabModeCount || keyCount == 0)
2196   {
2197     return false;
2198   }
2199
2200   eina_init();
2201
2202   Eina_List*                     keyList = NULL;
2203   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2204
2205   for(int index = 0; index < keyCount; ++index)
2206   {
2207     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2208
2209     switch(grabMode[index])
2210     {
2211       case KeyGrab::TOPMOST:
2212       {
2213         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2214         break;
2215       }
2216       case KeyGrab::SHARED:
2217       {
2218         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2219         break;
2220       }
2221       case KeyGrab::OVERRIDE_EXCLUSIVE:
2222       {
2223         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2224         break;
2225       }
2226       case KeyGrab::EXCLUSIVE:
2227       {
2228         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2229         break;
2230       }
2231       default:
2232       {
2233         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2234         break;
2235       }
2236     }
2237
2238     keyList = eina_list_append(keyList, &info);
2239   }
2240
2241   Eina_List* grabList = ecore_wl2_window_keygrab_list_set(mEcoreWindow, keyList);
2242
2243   result.Resize(keyCount, true);
2244
2245   Eina_List* l        = NULL;
2246   Eina_List* m        = NULL;
2247   void*      listData = NULL;
2248   void*      data     = NULL;
2249   if(grabList != NULL)
2250   {
2251     EINA_LIST_FOREACH(grabList, m, data)
2252     {
2253       int index = 0;
2254       EINA_LIST_FOREACH(keyList, l, listData)
2255       {
2256         if(static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key == NULL)
2257         {
2258           DALI_LOG_ERROR("input key list has null data!");
2259           break;
2260         }
2261
2262         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2263         {
2264           result[index] = false;
2265         }
2266         ++index;
2267       }
2268     }
2269   }
2270
2271   delete[] info;
2272
2273   eina_list_free(keyList);
2274   eina_list_free(grabList);
2275   eina_shutdown();
2276
2277   return true;
2278 }
2279
2280 bool WindowBaseEcoreWl2::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
2281 {
2282   int keyCount = key.Count();
2283   if(keyCount == 0)
2284   {
2285     return false;
2286   }
2287
2288   eina_init();
2289
2290   Eina_List*                     keyList = NULL;
2291   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2292
2293   for(int index = 0; index < keyCount; ++index)
2294   {
2295     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2296     keyList         = eina_list_append(keyList, &info);
2297   }
2298
2299   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset(mEcoreWindow, keyList);
2300
2301   result.Resize(keyCount, true);
2302
2303   Eina_List* l        = NULL;
2304   Eina_List* m        = NULL;
2305   void*      listData = NULL;
2306   void*      data     = NULL;
2307
2308   if(ungrabList != NULL)
2309   {
2310     EINA_LIST_FOREACH(ungrabList, m, data)
2311     {
2312       int index = 0;
2313       EINA_LIST_FOREACH(keyList, l, listData)
2314       {
2315         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2316         {
2317           result[index] = false;
2318         }
2319         ++index;
2320       }
2321     }
2322   }
2323
2324   delete[] info;
2325
2326   eina_list_free(keyList);
2327   eina_list_free(ungrabList);
2328   eina_shutdown();
2329
2330   return true;
2331 }
2332
2333 void WindowBaseEcoreWl2::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
2334 {
2335   // calculate DPI
2336   float xres, yres;
2337
2338   Ecore_Wl2_Output* output = ecore_wl2_window_output_find(mEcoreWindow);
2339
2340   // 1 inch = 25.4 millimeters
2341   xres = ecore_wl2_output_dpi_get(output);
2342   yres = ecore_wl2_output_dpi_get(output);
2343
2344   dpiHorizontal = int(xres + 0.5f); // rounding
2345   dpiVertical   = int(yres + 0.5f);
2346 }
2347
2348 int WindowBaseEcoreWl2::GetOrientation() const
2349 {
2350   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2351   if(mSupportedPreProtation)
2352   {
2353     orientation = 0;
2354   }
2355   return orientation;
2356 }
2357
2358 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2359 {
2360   int transform = 0;
2361
2362   if(ecore_wl2_window_ignore_output_transform_get(mEcoreWindow))
2363   {
2364     transform = 0;
2365   }
2366   else
2367   {
2368     transform = ecore_wl2_output_transform_get(ecore_wl2_window_output_find(mEcoreWindow));
2369   }
2370   mScreenRotationAngle = transform * 90;
2371   return mScreenRotationAngle;
2372 }
2373
2374 void WindowBaseEcoreWl2::SetWindowRotationAngle(int degree)
2375 {
2376   mWindowRotationAngle = degree;
2377   ecore_wl2_window_rotation_set(mEcoreWindow, degree);
2378 }
2379
2380 void WindowBaseEcoreWl2::WindowRotationCompleted(int degree, int width, int height)
2381 {
2382   ecore_wl2_window_rotation_change_done_send(mEcoreWindow, degree, width, height);
2383 }
2384
2385 void WindowBaseEcoreWl2::SetTransparency(bool transparent)
2386 {
2387   ecore_wl2_window_alpha_set(mEcoreWindow, transparent);
2388 }
2389
2390 void WindowBaseEcoreWl2::InitializeEcoreElDBus()
2391 {
2392 #ifdef DALI_ELDBUS_AVAILABLE
2393   Eldbus_Object* object;
2394   Eldbus_Proxy*  manager;
2395
2396   if(!(mSystemConnection = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM)))
2397   {
2398     DALI_LOG_ERROR("Unable to get system bus\n");
2399   }
2400
2401   object = eldbus_object_get(mSystemConnection, BUS, PATH);
2402   if(!object)
2403   {
2404     DALI_LOG_ERROR("Getting object failed\n");
2405     return;
2406   }
2407
2408   manager = eldbus_proxy_get(object, INTERFACE);
2409   if(!manager)
2410   {
2411     DALI_LOG_ERROR("Getting proxy failed\n");
2412     return;
2413   }
2414
2415   if(!eldbus_proxy_signal_handler_add(manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this))
2416   {
2417     DALI_LOG_ERROR("No signal handler returned\n");
2418   }
2419 #endif
2420 }
2421
2422 void WindowBaseEcoreWl2::CreateWindow(PositionSize positionSize)
2423 {
2424   Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
2425   if(!display)
2426   {
2427     DALI_ASSERT_ALWAYS(0 && "Failed to get display");
2428   }
2429
2430   ecore_wl2_display_sync(display);
2431
2432   mEcoreWindow = ecore_wl2_window_new(display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2433
2434   if(mEcoreWindow == 0)
2435   {
2436     DALI_ASSERT_ALWAYS(0 && "Failed to create Wayland window");
2437   }
2438
2439   // Set default type
2440   ecore_wl2_window_type_set(mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
2441 }
2442
2443 void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase)
2444 {
2445   Ecore_Wl2_Window* ecoreParent = NULL;
2446   if(parentWinBase)
2447   {
2448     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
2449     ecoreParent                       = winBaseEcore2->mEcoreWindow;
2450   }
2451   ecore_wl2_window_parent_set(mEcoreWindow, ecoreParent);
2452 }
2453
2454 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2455 {
2456   return wl_egl_window_tizen_create_commit_sync_fd(mEglWindow);
2457 }
2458
2459 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2460 {
2461   return wl_egl_window_tizen_create_presentation_sync_fd(mEglWindow);
2462 }
2463
2464 } // namespace Adaptor
2465
2466 } // namespace Internal
2467
2468 } // namespace Dali
2469
2470 #pragma GCC diagnostic pop