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

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