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   mScreenWidth(0),
 734   mScreenHeight(0),
 735   mNotificationChangeState(0),
 736   mScreenOffModeChangeState(0),
 737   mBrightnessChangeState(0),
 738   mLastSubmittedMoveResizeSerial(0),
 739   mMoveResizeSerial(0),
 740   mNotificationLevelChangeDone(true),
 741   mScreenOffModeChangeDone(true),
 742   mVisible(true),
 743   mOwnSurface(false),
 744   mBrightnessChangeDone(true)
 745 #ifdef DALI_ELDBUS_AVAILABLE
 746   ,
 747   mSystemConnection(NULL)
 748 #endif
 749 {
 750   Initialize(positionSize, surface, isTransparent);
 751 }
 752
 753 WindowBaseEcoreWl2::~WindowBaseEcoreWl2()
 754 {
 755 #ifdef DALI_ELDBUS_AVAILABLE
 756   // Close down ElDBus connections.
 757   if(mSystemConnection)
 758   {
 759     eldbus_connection_unref(mSystemConnection);
 760   }
 761 #endif // DALI_ELDBUS_AVAILABLE
 762
 763   vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged);
 764   vconf_ignore_key_changed(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged);
 765
 766   for(Dali::Vector<Ecore_Event_Handler*>::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter)
 767   {
 768     ecore_event_handler_del(*iter);
 769   }
 770   mEcoreEventHandler.Clear();
 771
 772   if(mEventQueue)
 773   {
 774     wl_event_queue_destroy(mEventQueue);
 775   }
 776
 777   mSupportedAuxiliaryHints.clear();
 778   mAuxiliaryHints.clear();
 779
 780   if(mEglWindow != NULL)
 781   {
 782     wl_egl_window_destroy(mEglWindow);
 783     mEglWindow = NULL;
 784   }
 785
 786   if(mOwnSurface)
 787   {
 788     ecore_wl2_window_free(mEcoreWindow);
 789
 790     WindowSystem::Shutdown();
 791   }
 792 }
 793
 794 void WindowBaseEcoreWl2::Initialize(PositionSize positionSize, Any surface, bool isTransparent)
 795 {
 796   if(surface.Empty() == false)
 797   {
 798     // check we have a valid type
 799     DALI_ASSERT_ALWAYS((surface.GetType() == typeid(Ecore_Wl2_Window*)) && "Surface type is invalid");
 800
 801     mEcoreWindow = AnyCast<Ecore_Wl2_Window*>(surface);
 802   }
 803   else
 804   {
 805     // we own the surface about to created
 806     WindowSystem::Initialize();
 807
 808     mOwnSurface = true;
 809     CreateWindow(positionSize);
 810   }
 811
 812   mWlSurface = ecore_wl2_window_surface_get(mEcoreWindow);
 813
 814   SetTransparency(isTransparent);
 815
 816   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this));
 817   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this));
 818   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this));
 819   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this));
 820   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_IGNORE_OUTPUT_TRANSFORM, EcoreEventIgnoreOutputTransform, this));
 821
 822   // Register Rotate event
 823   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_ROTATE, EcoreEventRotate, this));
 824
 825   // Register Configure event
 826   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_CONFIGURE, EcoreEventConfigure, this));
 827
 828   // Register Touch events
 829   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, EcoreEventMouseButtonDown, this));
 830   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, EcoreEventMouseButtonUp, this));
 831   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, EcoreEventMouseButtonMove, this));
 832   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, EcoreEventMouseButtonCancel, this));
 833
 834   // Register Mouse wheel events
 835   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL, EcoreEventMouseWheel, this));
 836
 837   // Register Detent event
 838   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_DETENT_ROTATE, EcoreEventDetentRotation, this));
 839
 840   // Register Key events
 841   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, EcoreEventKeyDown, this));
 842   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_KEY_UP, EcoreEventKeyUp, this));
 843
 844   // Register Selection event - clipboard selection
 845   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_SEND, EcoreEventDataSend, this));
 846   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SELECTION_DATA_READY, EcoreEventDataReceive, this));
 847
 848   // Register Effect Start/End event
 849   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_EFFECT_START, EcoreEventEffectStart, this));
 850   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_EFFECT_END, EcoreEventEffectEnd, this));
 851
 852   // Register Keyboard repeat event
 853   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_KEYBOARD_REPEAT_CHANGED, EcoreEventSeatKeyboardRepeatChanged, this));
 854
 855   // Register Window redraw request event
 856   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_REDRAW_REQUEST, EcoreEventWindowRedrawRequest, this));
 857
 858   // Register Window auxiliary event
 859   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_AUX_MESSAGE, EcoreEventWindowAuxiliaryMessage, this));
 860
 861   // Register Vconf notify - font name and size
 862   vconf_notify_key_changed(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this);
 863   vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this);
 864
 865   InitializeEcoreElDBus();
 866
 867   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
 868   mDisplay                   = ecore_wl2_display_get(display);
 869
 870   if(mDisplay)
 871   {
 872     wl_display* displayWrapper = static_cast<wl_display*>(wl_proxy_create_wrapper(mDisplay));
 873     if(displayWrapper)
 874     {
 875       mEventQueue = wl_display_create_queue(mDisplay);
 876       if(mEventQueue)
 877       {
 878         wl_proxy_set_queue(reinterpret_cast<wl_proxy*>(displayWrapper), mEventQueue);
 879
 880         wl_registry* registry = wl_display_get_registry(displayWrapper);
 881         wl_registry_add_listener(registry, &registryListener, this);
 882       }
 883
 884       wl_proxy_wrapper_destroy(displayWrapper);
 885     }
 886   }
 887
 888   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(display);
 889
 890   if(ecoreWlInput)
 891   {
 892     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
 893
 894     mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this));
 895   }
 896
 897   // get auxiliary hint
 898   Eina_List* hints = ecore_wl2_window_aux_hints_supported_get(mEcoreWindow);
 899   if(hints)
 900   {
 901     Eina_List* l    = NULL;
 902     char*      hint = NULL;
 903
 904     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))))
 905     {
 906       mSupportedAuxiliaryHints.push_back(hint);
 907
 908       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::Initialize: %s\n", hint);
 909     }
 910   }
 911 }
 912
 913 Eina_Bool WindowBaseEcoreWl2::OnIconifyStateChanged(void* data, int type, void* event)
 914 {
 915   Ecore_Wl2_Event_Window_Iconify_State_Change* iconifyChangedEvent(static_cast<Ecore_Wl2_Event_Window_Iconify_State_Change*>(event));
 916   Eina_Bool                                    handled(ECORE_CALLBACK_PASS_ON);
 917
 918   if(iconifyChangedEvent->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 919   {
 920     if(iconifyChangedEvent->iconified == EINA_TRUE)
 921     {
 922       mIconifyChangedSignal.Emit(true);
 923     }
 924     else
 925     {
 926       mIconifyChangedSignal.Emit(false);
 927     }
 928     handled = ECORE_CALLBACK_DONE;
 929   }
 930
 931   return handled;
 932 }
 933
 934 Eina_Bool WindowBaseEcoreWl2::OnFocusIn(void* data, int type, void* event)
 935 {
 936   Ecore_Wl2_Event_Focus_In* focusInEvent(static_cast<Ecore_Wl2_Event_Focus_In*>(event));
 937
 938   if(focusInEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 939   {
 940     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n");
 941
 942     mFocusChangedSignal.Emit(true);
 943   }
 944
 945   return ECORE_CALLBACK_PASS_ON;
 946 }
 947
 948 Eina_Bool WindowBaseEcoreWl2::OnFocusOut(void* data, int type, void* event)
 949 {
 950   Ecore_Wl2_Event_Focus_Out* focusOutEvent(static_cast<Ecore_Wl2_Event_Focus_Out*>(event));
 951
 952   if(focusOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 953   {
 954     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n");
 955
 956     mFocusChangedSignal.Emit(false);
 957   }
 958
 959   return ECORE_CALLBACK_PASS_ON;
 960 }
 961
 962 Eina_Bool WindowBaseEcoreWl2::OnOutputTransform(void* data, int type, void* event)
 963 {
 964   Ecore_Wl2_Event_Output_Transform* transformEvent(static_cast<Ecore_Wl2_Event_Output_Transform*>(event));
 965
 966   if(transformEvent->output == ecore_wl2_window_output_find(mEcoreWindow))
 967   {
 968     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
 969
 970     mScreenRotationAngle = GetScreenRotationAngle();
 971
 972     mOutputTransformedSignal.Emit();
 973   }
 974
 975   return ECORE_CALLBACK_PASS_ON;
 976 }
 977
 978 Eina_Bool WindowBaseEcoreWl2::OnIgnoreOutputTransform(void* data, int type, void* event)
 979 {
 980   Ecore_Wl2_Event_Ignore_Output_Transform* ignoreTransformEvent(static_cast<Ecore_Wl2_Event_Ignore_Output_Transform*>(event));
 981
 982   if(ignoreTransformEvent->win == mEcoreWindow)
 983   {
 984     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
 985
 986     mScreenRotationAngle = GetScreenRotationAngle();
 987
 988     mOutputTransformedSignal.Emit();
 989   }
 990
 991   return ECORE_CALLBACK_PASS_ON;
 992 }
 993
 994 void WindowBaseEcoreWl2::OnRotation(void* data, int type, void* event)
 995 {
 996   Ecore_Wl2_Event_Window_Rotation* ev(static_cast<Ecore_Wl2_Event_Window_Rotation*>(event));
 997
 998   if(ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 999   {
1000     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h);
1001
1002     RotationEvent rotationEvent;
1003     rotationEvent.angle     = ev->angle;
1004     rotationEvent.winResize = 0;
1005
1006     if(ev->w == 0 || ev->h == 0)
1007     {
1008       // When rotation event does not have the window width or height,
1009       // previous DALi side window's size are used.
1010       ev->w = mWindowPositionSize.width;
1011       ev->h = mWindowPositionSize.height;
1012     }
1013
1014     mWindowRotationAngle = ev->angle;
1015
1016     mWindowPositionSize.width  = ev->w;
1017     mWindowPositionSize.height = ev->h;
1018
1019     PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(mWindowPositionSize);
1020
1021     rotationEvent.x      = newPositionSize.x;
1022     rotationEvent.y      = newPositionSize.y;
1023     rotationEvent.width  = newPositionSize.width;
1024     rotationEvent.height = newPositionSize.height;
1025
1026     mRotationSignal.Emit(rotationEvent);
1027   }
1028 }
1029
1030 void WindowBaseEcoreWl2::OnConfiguration(void* data, int type, void* event)
1031 {
1032   Ecore_Wl2_Event_Window_Configure* ev(static_cast<Ecore_Wl2_Event_Window_Configure*>(event));
1033
1034   if(ev && ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1035   {
1036     // Note: To comply with the wayland protocol, Dali should make an ack_configure
1037     // by calling ecore_wl2_window_commit
1038
1039     int tempWidth  = static_cast<int>(ev->w);
1040     int tempHeight = static_cast<int>(ev->h);
1041
1042     // Initialize with previous size for skip resize when new size is 0.
1043     // When window is just moved or window is resized by client application,
1044     // The configure notification event's size will be 0.
1045     // If new size is 0, the resized work should be skip.
1046     int  newWidth    = mWindowPositionSize.width;
1047     int  newHeight   = mWindowPositionSize.height;
1048     bool windowMoved = false, windowResized = false;
1049
1050     if(ev->x != mWindowPositionSize.x || ev->y != mWindowPositionSize.y)
1051     {
1052       windowMoved = true;
1053     }
1054
1055     if(tempWidth != 0 && tempHeight != 0 && (tempWidth != mWindowPositionSize.width || tempHeight != mWindowPositionSize.height))
1056     {
1057       windowResized = true;
1058       newWidth      = tempWidth;
1059       newHeight     = tempHeight;
1060     }
1061
1062     if(windowMoved || windowResized)
1063     {
1064       mWindowPositionSize.x = ev->x;
1065       mWindowPositionSize.y = ev->y;
1066       mWindowPositionSize.width = newWidth;
1067       mWindowPositionSize.height = newHeight;
1068       DALI_LOG_RELEASE_INFO("Update position & resize signal by server, current angle [%d] x[%d] y[%d] w[%d] h[%d]\n", mWindowRotationAngle, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1069
1070       Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(mWindowPositionSize);
1071       DALI_LOG_RELEASE_INFO("emit signal to update window's position and size, x[%d] y[%d] w[%d] h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1072       mUpdatePositionSizeSignal.Emit(newPositionSize);
1073     }
1074
1075     ecore_wl2_window_commit(mEcoreWindow, EINA_FALSE);
1076   }
1077 }
1078
1079 void WindowBaseEcoreWl2::OnMouseButtonDown(void* data, int type, void* event)
1080 {
1081   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1082
1083   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1084   {
1085     Device::Class::Type    deviceClass;
1086     Device::Subclass::Type deviceSubclass;
1087
1088     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1089     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1090
1091     PointState::Type state(PointState::DOWN);
1092
1093     if(deviceClass != Device::Class::Type::MOUSE)
1094     {
1095       // Check if the buttons field is set and ensure it's the primary touch button.
1096       // If this event was triggered by buttons other than the primary button (used for touch), then
1097       // just send an interrupted event to Core.
1098       if(touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID))
1099       {
1100         state = PointState::INTERRUPTED;
1101       }
1102     }
1103
1104     Integration::Point point;
1105     point.SetDeviceId(touchEvent->multi.device);
1106     point.SetState(state);
1107     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1108     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1109     point.SetPressure(touchEvent->multi.pressure);
1110     point.SetAngle(Degree(touchEvent->multi.angle));
1111     point.SetDeviceClass(deviceClass);
1112     point.SetDeviceSubclass(deviceSubclass);
1113     point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
1114
1115     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1116   }
1117 }
1118
1119 void WindowBaseEcoreWl2::OnMouseButtonUp(void* data, int type, void* event)
1120 {
1121   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1122
1123   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1124   {
1125     Device::Class::Type    deviceClass;
1126     Device::Subclass::Type deviceSubclass;
1127
1128     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1129     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1130
1131     Integration::Point point;
1132     point.SetDeviceId(touchEvent->multi.device);
1133     point.SetState(PointState::UP);
1134     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1135     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1136     point.SetPressure(touchEvent->multi.pressure);
1137     point.SetAngle(Degree(touchEvent->multi.angle));
1138     point.SetDeviceClass(deviceClass);
1139     point.SetDeviceSubclass(deviceSubclass);
1140     point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
1141
1142     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1143   }
1144 }
1145
1146 void WindowBaseEcoreWl2::OnMouseButtonMove(void* data, int type, void* event)
1147 {
1148   Ecore_Event_Mouse_Move* touchEvent = static_cast<Ecore_Event_Mouse_Move*>(event);
1149
1150   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1151   {
1152     Device::Class::Type    deviceClass;
1153     Device::Subclass::Type deviceSubclass;
1154
1155     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1156     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1157
1158     Integration::Point point;
1159     point.SetDeviceId(touchEvent->multi.device);
1160     point.SetState(PointState::MOTION);
1161     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1162     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1163     point.SetPressure(touchEvent->multi.pressure);
1164     point.SetAngle(Degree(touchEvent->multi.angle));
1165     point.SetDeviceClass(deviceClass);
1166     point.SetDeviceSubclass(deviceSubclass);
1167
1168     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1169   }
1170 }
1171
1172 void WindowBaseEcoreWl2::OnMouseButtonCancel(void* data, int type, void* event)
1173 {
1174   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1175
1176   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1177   {
1178     Integration::Point point;
1179     point.SetDeviceId(touchEvent->multi.device);
1180     point.SetState(PointState::INTERRUPTED);
1181     point.SetScreenPosition(Vector2(0.0f, 0.0f));
1182
1183     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1184
1185     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseButtonCancel\n");
1186   }
1187 }
1188
1189 void WindowBaseEcoreWl2::OnMouseWheel(void* data, int type, void* event)
1190 {
1191   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast<Ecore_Event_Mouse_Wheel*>(event);
1192
1193   if(mouseWheelEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1194   {
1195     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);
1196
1197     Integration::WheelEvent wheelEvent(Integration::WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp);
1198
1199     mWheelEventSignal.Emit(wheelEvent);
1200   }
1201 }
1202
1203 void WindowBaseEcoreWl2::OnDetentRotation(void* data, int type, void* event)
1204 {
1205   Ecore_Event_Detent_Rotate* detentEvent = static_cast<Ecore_Event_Detent_Rotate*>(event);
1206
1207   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n");
1208
1209   int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
1210
1211   Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, detentEvent->direction, 0, Vector2(0.0f, 0.0f), clockwise, detentEvent->timestamp);
1212
1213   mWheelEventSignal.Emit(wheelEvent);
1214 }
1215
1216 void WindowBaseEcoreWl2::OnKeyDown(void* data, int type, void* event)
1217 {
1218   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1219
1220   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1221   {
1222     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyDown\n");
1223
1224     std::string keyName(keyEvent->keyname);
1225     std::string logicalKey("");
1226     std::string keyString("");
1227     std::string compose("");
1228
1229     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1230     if(keyEvent->compose)
1231     {
1232       compose = keyEvent->compose;
1233     }
1234
1235     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1236     if(keyEvent->key)
1237     {
1238       logicalKey = keyEvent->key;
1239     }
1240
1241     int keyCode = 0;
1242     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1243
1244     if(keyCode == 0)
1245     {
1246       // Get a specific key code from dali key look up table.
1247       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1248     }
1249
1250     keyCode = (keyCode == -1) ? 0 : keyCode;
1251     int           modifier(keyEvent->modifiers);
1252     unsigned long time = keyEvent->timestamp;
1253     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1254     {
1255       keyCode = atoi(keyEvent->keyname + 8);
1256     }
1257
1258     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1259     if(keyEvent->string)
1260     {
1261       keyString = keyEvent->string;
1262     }
1263
1264     std::string            deviceName;
1265     Device::Class::Type    deviceClass;
1266     Device::Subclass::Type deviceSubclass;
1267
1268     GetDeviceName(keyEvent, deviceName);
1269     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1270     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1271
1272     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass);
1273
1274     mKeyEventSignal.Emit(keyEvent);
1275   }
1276 }
1277
1278 void WindowBaseEcoreWl2::OnKeyUp(void* data, int type, void* event)
1279 {
1280   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1281
1282   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1283   {
1284     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp\n");
1285
1286 #if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
1287     // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
1288     if(keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL)
1289     {
1290       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp: This event flag indicates the event is canceled. \n");
1291       return;
1292     }
1293 #endif // Since ecore 1.23 version
1294
1295     std::string keyName(keyEvent->keyname);
1296     std::string logicalKey("");
1297     std::string keyString("");
1298     std::string compose("");
1299
1300     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1301     if(keyEvent->compose)
1302     {
1303       compose = keyEvent->compose;
1304     }
1305
1306     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1307     if(keyEvent->key)
1308     {
1309       logicalKey = keyEvent->key;
1310     }
1311
1312     int keyCode = 0;
1313     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1314
1315     if(keyCode == 0)
1316     {
1317       // Get a specific key code from dali key look up table.
1318       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1319     }
1320
1321     keyCode = (keyCode == -1) ? 0 : keyCode;
1322     int           modifier(keyEvent->modifiers);
1323     unsigned long time = keyEvent->timestamp;
1324     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1325     {
1326       keyCode = atoi(keyEvent->keyname + 8);
1327     }
1328
1329     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1330     if(keyEvent->string)
1331     {
1332       keyString = keyEvent->string;
1333     }
1334
1335     std::string            deviceName;
1336     Device::Class::Type    deviceClass;
1337     Device::Subclass::Type deviceSubclass;
1338
1339     GetDeviceName(keyEvent, deviceName);
1340     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1341     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1342
1343     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
1344
1345     mKeyEventSignal.Emit(keyEvent);
1346   }
1347 }
1348
1349 void WindowBaseEcoreWl2::OnDataSend(void* data, int type, void* event)
1350 {
1351   mSelectionDataSendSignal.Emit(event);
1352 }
1353
1354 void WindowBaseEcoreWl2::OnDataReceive(void* data, int type, void* event)
1355 {
1356   mSelectionDataReceivedSignal.Emit(event);
1357 }
1358
1359 void WindowBaseEcoreWl2::OnFontNameChanged()
1360 {
1361   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
1362 }
1363
1364 void WindowBaseEcoreWl2::OnFontSizeChanged()
1365 {
1366   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
1367 }
1368
1369 #ifdef DALI_ELDBUS_AVAILABLE
1370 void WindowBaseEcoreWl2::OnEcoreElDBusAccessibilityNotification(void* context, const Eldbus_Message* message)
1371 {
1372   AccessibilityInfo info;
1373
1374   // The string defines the arg-list's respective types.
1375   if(!eldbus_message_arguments_get(message, "iiiiiiu", &info.gestureValue, &info.startX, &info.startY, &info.endX, &info.endY, &info.state, &info.eventTime))
1376   {
1377     DALI_LOG_ERROR("OnEcoreElDBusAccessibilityNotification: Error getting arguments\n");
1378   }
1379
1380   mAccessibilitySignal.Emit(info);
1381 }
1382 #endif // DALI_ELDBUS_AVAILABLE
1383
1384 void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
1385 {
1386   mTransitionEffectEventSignal.Emit(state, type);
1387 }
1388
1389 void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
1390 {
1391   mKeyboardRepeatSettingsChangedSignal.Emit();
1392 }
1393
1394 void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
1395 {
1396   mWindowRedrawRequestSignal.Emit();
1397 }
1398
1399 void WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage(void* event)
1400 {
1401   Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
1402   if(message)
1403   {
1404     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, key:%s, value:%s \n", message->key, message->val);
1405     std::string           key(message->key);
1406     std::string           value(message->val);
1407     Dali::Property::Array options;
1408
1409     if(message->options)
1410     {
1411       Eina_List* l;
1412       void*      data;
1413       EINA_LIST_FOREACH(message->options, l, data)
1414       {
1415         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, option: %s\n", (char*)data);
1416         std::string option(static_cast<char*>(data));
1417         options.Add(option);
1418       }
1419     }
1420
1421     mAuxiliaryMessageSignal.Emit(key, value, options);
1422   }
1423 }
1424
1425 void WindowBaseEcoreWl2::KeymapChanged(void* data, int type, void* event)
1426 {
1427   Ecore_Wl2_Event_Seat_Keymap_Changed* changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>(event);
1428   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id);
1429   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(changed->display);
1430   if(ecoreWlInput)
1431   {
1432     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
1433   }
1434 }
1435
1436 void WindowBaseEcoreWl2::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
1437 {
1438   if(strcmp(interface, tizen_policy_interface.name) == 0)
1439   {
1440     uint32_t clientVersion = std::min(version, MAX_TIZEN_CLIENT_VERSION);
1441
1442     mTizenPolicy = static_cast<tizen_policy*>(wl_registry_bind(registry, name, &tizen_policy_interface, clientVersion));
1443     if(!mTizenPolicy)
1444     {
1445       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n");
1446       return;
1447     }
1448
1449     tizen_policy_add_listener(mTizenPolicy, &tizenPolicyListener, data);
1450
1451     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n");
1452   }
1453   else if(strcmp(interface, tizen_display_policy_interface.name) == 0)
1454   {
1455     mTizenDisplayPolicy = static_cast<tizen_display_policy*>(wl_registry_bind(registry, name, &tizen_display_policy_interface, version));
1456     if(!mTizenDisplayPolicy)
1457     {
1458       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n");
1459       return;
1460     }
1461
1462     tizen_display_policy_add_listener(mTizenDisplayPolicy, &tizenDisplayPolicyListener, data);
1463
1464     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n");
1465   }
1466 }
1467
1468 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
1469 {
1470   mTizenPolicy        = NULL;
1471   mTizenDisplayPolicy = NULL;
1472 }
1473
1474 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
1475 {
1476   mNotificationLevel           = level;
1477   mNotificationChangeState     = state;
1478   mNotificationLevelChangeDone = true;
1479
1480   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state);
1481 }
1482
1483 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
1484 {
1485   mScreenOffMode            = mode;
1486   mScreenOffModeChangeState = state;
1487   mScreenOffModeChangeDone  = true;
1488
1489   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state);
1490 }
1491
1492 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
1493 {
1494   mBrightness            = brightness;
1495   mBrightnessChangeState = state;
1496   mBrightnessChangeDone  = true;
1497
1498   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state);
1499 }
1500
1501 void WindowBaseEcoreWl2::GetKeyCode(std::string keyName, int32_t& keyCode)
1502 {
1503   xkb_keysym_t sym = XKB_KEY_NoSymbol;
1504   KeyCodeMap   foundKeyCode;
1505
1506   sym = xkb_keysym_from_name(keyName.c_str(), XKB_KEYSYM_NO_FLAGS);
1507   if(sym == XKB_KEY_NoSymbol)
1508   {
1509     DALI_LOG_ERROR("Failed to get keysym in WindowBaseEcoreWl2\n");
1510     return;
1511   }
1512
1513   foundKeyCode.keySym    = sym;
1514   foundKeyCode.isKeyCode = false;
1515   xkb_keymap_key_for_each(mKeyMap, FindKeyCode, &foundKeyCode);
1516   keyCode = static_cast<int32_t>(foundKeyCode.keyCode);
1517 }
1518
1519 Any WindowBaseEcoreWl2::GetNativeWindow()
1520 {
1521   return mEcoreWindow;
1522 }
1523
1524 int WindowBaseEcoreWl2::GetNativeWindowId()
1525 {
1526   return ecore_wl2_window_id_get(mEcoreWindow);
1527 }
1528
1529 std::string WindowBaseEcoreWl2::GetNativeWindowResourceId()
1530 {
1531 #ifdef OVER_TIZEN_VERSION_7
1532   return std::to_string(ecore_wl2_window_resource_id_get(mEcoreWindow));
1533 #else
1534   return std::string();
1535 #endif
1536 }
1537
1538 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow(int width, int height)
1539 {
1540   int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
1541   if(totalAngle == 90 || totalAngle == 270)
1542   {
1543     mEglWindow = wl_egl_window_create(mWlSurface, height, width);
1544   }
1545   else
1546   {
1547     mEglWindow = wl_egl_window_create(mWlSurface, width, height);
1548   }
1549
1550   return static_cast<EGLNativeWindowType>(mEglWindow);
1551 }
1552
1553 void WindowBaseEcoreWl2::DestroyEglWindow()
1554 {
1555   if(mEglWindow != NULL)
1556   {
1557     wl_egl_window_destroy(mEglWindow);
1558     mEglWindow = NULL;
1559   }
1560 }
1561
1562 void WindowBaseEcoreWl2::SetEglWindowRotation(int angle)
1563 {
1564   wl_egl_window_tizen_rotation rotation;
1565
1566   switch(angle)
1567   {
1568     case 0:
1569     {
1570       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1571       break;
1572     }
1573     case 90:
1574     {
1575       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
1576       break;
1577     }
1578     case 180:
1579     {
1580       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
1581       break;
1582     }
1583     case 270:
1584     {
1585       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
1586       break;
1587     }
1588     default:
1589     {
1590       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1591       break;
1592     }
1593   }
1594
1595   wl_egl_window_tizen_set_rotation(mEglWindow, rotation);
1596 }
1597
1598 void WindowBaseEcoreWl2::SetEglWindowBufferTransform(int angle)
1599 {
1600   wl_output_transform bufferTransform;
1601
1602   switch(angle)
1603   {
1604     case 0:
1605     {
1606       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1607       break;
1608     }
1609     case 90:
1610     {
1611       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1612       break;
1613     }
1614     case 180:
1615     {
1616       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1617       break;
1618     }
1619     case 270:
1620     {
1621       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1622       break;
1623     }
1624     default:
1625     {
1626       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1627       break;
1628     }
1629   }
1630
1631   wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
1632 }
1633
1634 void WindowBaseEcoreWl2::SetEglWindowTransform(int angle)
1635 {
1636   wl_output_transform windowTransform;
1637
1638   switch(angle)
1639   {
1640     case 0:
1641     {
1642       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1643       break;
1644     }
1645     case 90:
1646     {
1647       windowTransform = WL_OUTPUT_TRANSFORM_90;
1648       break;
1649     }
1650     case 180:
1651     {
1652       windowTransform = WL_OUTPUT_TRANSFORM_180;
1653       break;
1654     }
1655     case 270:
1656     {
1657       windowTransform = WL_OUTPUT_TRANSFORM_270;
1658       break;
1659     }
1660     default:
1661     {
1662       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1663       break;
1664     }
1665   }
1666
1667   wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
1668 }
1669
1670 void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
1671 {
1672   wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
1673
1674   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
1675   if(mMoveResizeSerial != mLastSubmittedMoveResizeSerial)
1676   {
1677     wl_egl_window_tizen_set_window_serial(mEglWindow, mMoveResizeSerial);
1678     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
1679   }
1680 }
1681
1682 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
1683 {
1684   // Check capability
1685   wl_egl_window_tizen_capability capability = static_cast<wl_egl_window_tizen_capability>(wl_egl_window_tizen_get_capabilities(mEglWindow));
1686   if(capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED)
1687   {
1688     mSupportedPreProtation = true;
1689     return true;
1690   }
1691   mSupportedPreProtation = false;
1692   return false;
1693 }
1694
1695 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToSystem(PositionSize positionSize)
1696 {
1697   PositionSize newPositionSize;
1698
1699   if(mWindowRotationAngle == 90)
1700   {
1701     newPositionSize.x      = positionSize.y;
1702     newPositionSize.y      = mScreenHeight - (positionSize.x + positionSize.width);
1703     newPositionSize.width  = positionSize.height;
1704     newPositionSize.height = positionSize.width;
1705   }
1706   else if(mWindowRotationAngle == 180)
1707   {
1708     newPositionSize.x      = mScreenWidth - (positionSize.x + positionSize.width);
1709     newPositionSize.y      = mScreenHeight - (positionSize.y + positionSize.height);
1710     newPositionSize.width  = positionSize.width;
1711     newPositionSize.height = positionSize.height;
1712   }
1713   else if(mWindowRotationAngle == 270)
1714   {
1715     newPositionSize.x      = mScreenWidth - (positionSize.y + positionSize.height);
1716     newPositionSize.y      = positionSize.x;
1717     newPositionSize.width  = positionSize.height;
1718     newPositionSize.height = positionSize.width;
1719   }
1720   else
1721   {
1722     newPositionSize.x      = positionSize.x;
1723     newPositionSize.y      = positionSize.y;
1724     newPositionSize.width  = positionSize.width;
1725     newPositionSize.height = positionSize.height;
1726   }
1727
1728   DALI_LOG_RELEASE_INFO("input coord x[%d], y[%d], w{%d], h[%d], screen w[%d], h[%d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height, mScreenWidth, mScreenHeight);
1729   DALI_LOG_RELEASE_INFO("recalc coord x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1730
1731   return newPositionSize;
1732 }
1733
1734 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToCurrentOrientation(PositionSize positionSize)
1735 {
1736   PositionSize newPositionSize;
1737
1738   if(mWindowRotationAngle == 90)
1739   {
1740     newPositionSize.x      = mScreenHeight - (positionSize.y + positionSize.height);
1741     newPositionSize.y      = positionSize.x;
1742     newPositionSize.width  = positionSize.height;
1743     newPositionSize.height = positionSize.width;
1744   }
1745   else if(mWindowRotationAngle == 180)
1746   {
1747     newPositionSize.x      = mScreenWidth - (positionSize.x + positionSize.width);
1748     newPositionSize.y      = mScreenHeight - (positionSize.y + positionSize.height);
1749     newPositionSize.width  = positionSize.width;
1750     newPositionSize.height = positionSize.height;
1751   }
1752   else if(mWindowRotationAngle == 270)
1753   {
1754     newPositionSize.x      = positionSize.y;
1755     newPositionSize.y      = mScreenWidth - (positionSize.x + positionSize.width);
1756     newPositionSize.width  = positionSize.height;
1757     newPositionSize.height = positionSize.width;
1758   }
1759   else
1760   {
1761     newPositionSize.x      = positionSize.x;
1762     newPositionSize.y      = positionSize.y;
1763     newPositionSize.width  = positionSize.width;
1764     newPositionSize.height = positionSize.height;
1765   }
1766
1767   DALI_LOG_RELEASE_INFO("input coord x[%d], y[%d], w{%d], h[%d], screen w[%d], h[%d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height, mScreenWidth, mScreenHeight);
1768   DALI_LOG_RELEASE_INFO("recalc by current orientation coord x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1769
1770   return newPositionSize;
1771 }
1772
1773 void WindowBaseEcoreWl2::Move(PositionSize positionSize)
1774 {
1775   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1776
1777   mWindowPositionSize = newPositionSize;
1778   DALI_LOG_RELEASE_INFO("ecore_wl2_window_position_set x[%d], y[%d]\n", newPositionSize.x, newPositionSize.y);
1779   ecore_wl2_window_position_set(mEcoreWindow, newPositionSize.x, newPositionSize.y);
1780 }
1781
1782 void WindowBaseEcoreWl2::Resize(PositionSize positionSize)
1783 {
1784   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1785
1786   mWindowPositionSize = newPositionSize;
1787   DALI_LOG_RELEASE_INFO("ecore_wl2_window_sync_geometry_set, x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1788   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1789 }
1790
1791 void WindowBaseEcoreWl2::MoveResize(PositionSize positionSize)
1792 {
1793   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1794
1795   mWindowPositionSize = newPositionSize;
1796   DALI_LOG_RELEASE_INFO("ecore_wl2_window_sync_geometry_set, x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1797   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1798 }
1799
1800 void WindowBaseEcoreWl2::SetClass(const std::string& name, const std::string& className)
1801 {
1802   ecore_wl2_window_title_set(mEcoreWindow, name.c_str());
1803   ecore_wl2_window_class_set(mEcoreWindow, className.c_str());
1804 }
1805
1806 void WindowBaseEcoreWl2::Raise()
1807 {
1808   // Use ecore_wl2_window_activate to prevent the window shown without rendering
1809   ecore_wl2_window_activate(mEcoreWindow);
1810 }
1811
1812 void WindowBaseEcoreWl2::Lower()
1813 {
1814   ecore_wl2_window_lower(mEcoreWindow);
1815 }
1816
1817 void WindowBaseEcoreWl2::Activate()
1818 {
1819   ecore_wl2_window_activate(mEcoreWindow);
1820 }
1821
1822 void WindowBaseEcoreWl2::Maximize(bool maximize)
1823 {
1824   ecore_wl2_window_maximized_set(mEcoreWindow, maximize);
1825 }
1826
1827 bool WindowBaseEcoreWl2::IsMaximized() const
1828 {
1829   return ecore_wl2_window_maximized_get(mEcoreWindow);
1830 }
1831
1832 void WindowBaseEcoreWl2::Minimize(bool minimize)
1833 {
1834   ecore_wl2_window_iconified_set(mEcoreWindow, minimize);
1835 }
1836
1837 bool WindowBaseEcoreWl2::IsMinimized() const
1838 {
1839   return ecore_wl2_window_iconified_get(mEcoreWindow);
1840 }
1841
1842 void WindowBaseEcoreWl2::SetAvailableAnlges(const std::vector<int>& angles)
1843 {
1844   int rotations[4] = {0};
1845   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size());
1846   for(std::size_t i = 0; i < angles.size(); ++i)
1847   {
1848     rotations[i] = static_cast<int>(angles[i]);
1849     DALI_LOG_RELEASE_INFO("%d ", rotations[i]);
1850   }
1851   ecore_wl2_window_available_rotations_set(mEcoreWindow, rotations, angles.size());
1852 }
1853
1854 void WindowBaseEcoreWl2::SetPreferredAngle(int angle)
1855 {
1856   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetPreferredAngle, angle: %d\n", angle);
1857   ecore_wl2_window_preferred_rotation_set(mEcoreWindow, angle);
1858 }
1859
1860 void WindowBaseEcoreWl2::SetAcceptFocus(bool accept)
1861 {
1862   ecore_wl2_window_focus_skip_set(mEcoreWindow, !accept);
1863 }
1864
1865 void WindowBaseEcoreWl2::Show()
1866 {
1867   if(!mVisible)
1868   {
1869     ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1870   }
1871   mVisible = true;
1872
1873   ecore_wl2_window_show(mEcoreWindow);
1874 }
1875
1876 void WindowBaseEcoreWl2::Hide()
1877 {
1878   mVisible = false;
1879   ecore_wl2_window_hide(mEcoreWindow);
1880 }
1881
1882 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1883 {
1884   return mSupportedAuxiliaryHints.size();
1885 }
1886
1887 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint(unsigned int index) const
1888 {
1889   if(index >= GetSupportedAuxiliaryHintCount())
1890   {
1891     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index);
1892   }
1893
1894   return mSupportedAuxiliaryHints[index];
1895 }
1896
1897 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint(const std::string& hint, const std::string& value)
1898 {
1899   bool supported = false;
1900
1901   // Check if the hint is suppported
1902   for(std::vector<std::string>::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter)
1903   {
1904     if(*iter == hint)
1905     {
1906       supported = true;
1907       break;
1908     }
1909   }
1910
1911   if(!supported)
1912   {
1913     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str());
1914     return 0;
1915   }
1916
1917   // Check if the hint is already added
1918   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1919   {
1920     if(mAuxiliaryHints[i].first == hint)
1921     {
1922       // Just change the value
1923       mAuxiliaryHints[i].second = value;
1924
1925       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1);
1926
1927       return i + 1; // id is index + 1
1928     }
1929   }
1930
1931   // Add the hint
1932   mAuxiliaryHints.push_back(std::pair<std::string, std::string>(hint, value));
1933
1934   unsigned int id = mAuxiliaryHints.size();
1935
1936   ecore_wl2_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
1937
1938   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
1939
1940   return id;
1941 }
1942
1943 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint(unsigned int id)
1944 {
1945   if(id == 0 || id > mAuxiliaryHints.size())
1946   {
1947     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id);
1948     return false;
1949   }
1950
1951   mAuxiliaryHints[id - 1].second = std::string();
1952
1953   ecore_wl2_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
1954
1955   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
1956
1957   return true;
1958 }
1959
1960 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
1961 {
1962   if(id == 0 || id > mAuxiliaryHints.size())
1963   {
1964     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id);
1965     return false;
1966   }
1967
1968   mAuxiliaryHints[id - 1].second = value;
1969
1970   ecore_wl2_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
1971
1972   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());
1973
1974   return true;
1975 }
1976
1977 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue(unsigned int id) const
1978 {
1979   if(id == 0 || id > mAuxiliaryHints.size())
1980   {
1981     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id);
1982     return std::string();
1983   }
1984
1985   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());
1986
1987   return mAuxiliaryHints[id - 1].second;
1988 }
1989
1990 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId(const std::string& hint) const
1991 {
1992   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1993   {
1994     if(mAuxiliaryHints[i].first == hint)
1995     {
1996       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1);
1997       return i + 1;
1998     }
1999   }
2000
2001   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str());
2002
2003   return 0;
2004 }
2005
2006 void WindowBaseEcoreWl2::SetInputRegion(const Rect<int>& inputRegion)
2007 {
2008   ecore_wl2_window_input_region_set(mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height);
2009 }
2010
2011 void WindowBaseEcoreWl2::SetType(Dali::WindowType type)
2012 {
2013   if(mType != type)
2014   {
2015     mType = type;
2016     Ecore_Wl2_Window_Type windowType;
2017
2018     switch(type)
2019     {
2020       case Dali::WindowType::NORMAL:
2021       {
2022         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2023         break;
2024       }
2025       case Dali::WindowType::NOTIFICATION:
2026       {
2027         windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
2028         break;
2029       }
2030       case Dali::WindowType::UTILITY:
2031       {
2032         windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
2033         break;
2034       }
2035       case Dali::WindowType::DIALOG:
2036       {
2037         windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
2038         break;
2039       }
2040       case Dali::WindowType::IME:
2041       {
2042         windowType = ECORE_WL2_WINDOW_TYPE_NONE;
2043         break;
2044       }
2045       default:
2046       {
2047         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2048         break;
2049       }
2050     }
2051     ecore_wl2_window_type_set(mEcoreWindow, windowType);
2052   }
2053 }
2054
2055 Dali::WindowType WindowBaseEcoreWl2::GetType() const
2056 {
2057   return mType;
2058 }
2059
2060 Dali::WindowOperationResult WindowBaseEcoreWl2::SetNotificationLevel(Dali::WindowNotificationLevel level)
2061 {
2062   while(!mTizenPolicy)
2063   {
2064     wl_display_dispatch_queue(mDisplay, mEventQueue);
2065   }
2066
2067   int notificationLevel;
2068
2069   switch(level)
2070   {
2071     case Dali::WindowNotificationLevel::NONE:
2072     {
2073       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
2074       break;
2075     }
2076     case Dali::WindowNotificationLevel::BASE:
2077     {
2078       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2079       break;
2080     }
2081     case Dali::WindowNotificationLevel::MEDIUM:
2082     {
2083       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
2084       break;
2085     }
2086     case Dali::WindowNotificationLevel::HIGH:
2087     {
2088       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
2089       break;
2090     }
2091     case Dali::WindowNotificationLevel::TOP:
2092     {
2093       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
2094       break;
2095     }
2096     default:
2097     {
2098       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level);
2099       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2100       break;
2101     }
2102   }
2103
2104   mNotificationLevelChangeDone = false;
2105   mNotificationChangeState     = TIZEN_POLICY_ERROR_STATE_NONE;
2106
2107   tizen_policy_set_notification_level(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), notificationLevel);
2108
2109   int count = 0;
2110
2111   while(!mNotificationLevelChangeDone && count < 3)
2112   {
2113     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2114     wl_display_dispatch_queue(mDisplay, mEventQueue);
2115     count++;
2116   }
2117
2118   if(!mNotificationLevelChangeDone)
2119   {
2120     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState);
2121     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2122   }
2123   else if(mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2124   {
2125     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level);
2126     return Dali::WindowOperationResult::PERMISSION_DENIED;
2127   }
2128
2129   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel);
2130
2131   return Dali::WindowOperationResult::SUCCEED;
2132 }
2133
2134 Dali::WindowNotificationLevel WindowBaseEcoreWl2::GetNotificationLevel() const
2135 {
2136   while(!mTizenPolicy)
2137   {
2138     wl_display_dispatch_queue(mDisplay, mEventQueue);
2139   }
2140
2141   int count = 0;
2142
2143   while(!mNotificationLevelChangeDone && count < 3)
2144   {
2145     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2146     wl_display_dispatch_queue(mDisplay, mEventQueue);
2147     count++;
2148   }
2149
2150   if(!mNotificationLevelChangeDone)
2151   {
2152     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState);
2153     return Dali::WindowNotificationLevel::NONE;
2154   }
2155
2156   Dali::WindowNotificationLevel level;
2157
2158   switch(mNotificationLevel)
2159   {
2160     case TIZEN_POLICY_LEVEL_NONE:
2161     {
2162       level = Dali::WindowNotificationLevel::NONE;
2163       break;
2164     }
2165     case TIZEN_POLICY_LEVEL_DEFAULT:
2166     {
2167       level = Dali::WindowNotificationLevel::BASE;
2168       break;
2169     }
2170     case TIZEN_POLICY_LEVEL_MEDIUM:
2171     {
2172       level = Dali::WindowNotificationLevel::MEDIUM;
2173       break;
2174     }
2175     case TIZEN_POLICY_LEVEL_HIGH:
2176     {
2177       level = Dali::WindowNotificationLevel::HIGH;
2178       break;
2179     }
2180     case TIZEN_POLICY_LEVEL_TOP:
2181     {
2182       level = Dali::WindowNotificationLevel::TOP;
2183       break;
2184     }
2185     default:
2186     {
2187       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel);
2188       level = Dali::WindowNotificationLevel::NONE;
2189       break;
2190     }
2191   }
2192
2193   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel);
2194
2195   return level;
2196 }
2197
2198 void WindowBaseEcoreWl2::SetOpaqueState(bool opaque)
2199 {
2200   while(!mTizenPolicy)
2201   {
2202     wl_display_dispatch_queue(mDisplay, mEventQueue);
2203   }
2204
2205   tizen_policy_set_opaque_state(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), (opaque ? 1 : 0));
2206 }
2207
2208 Dali::WindowOperationResult WindowBaseEcoreWl2::SetScreenOffMode(WindowScreenOffMode screenOffMode)
2209 {
2210   while(!mTizenPolicy)
2211   {
2212     wl_display_dispatch_queue(mDisplay, mEventQueue);
2213   }
2214
2215   mScreenOffModeChangeDone  = false;
2216   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2217
2218   unsigned int mode = 0;
2219
2220   switch(screenOffMode)
2221   {
2222     case WindowScreenOffMode::TIMEOUT:
2223     {
2224       mode = 0;
2225       break;
2226     }
2227     case WindowScreenOffMode::NEVER:
2228     {
2229       mode = 1;
2230       break;
2231     }
2232   }
2233
2234   tizen_policy_set_window_screen_mode(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), mode);
2235
2236   int count = 0;
2237
2238   while(!mScreenOffModeChangeDone && count < 3)
2239   {
2240     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2241     wl_display_dispatch_queue(mDisplay, mEventQueue);
2242     count++;
2243   }
2244
2245   if(!mScreenOffModeChangeDone)
2246   {
2247     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState);
2248     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2249   }
2250   else if(mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2251   {
2252     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode);
2253     return Dali::WindowOperationResult::PERMISSION_DENIED;
2254   }
2255
2256   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode);
2257
2258   return Dali::WindowOperationResult::SUCCEED;
2259 }
2260
2261 WindowScreenOffMode WindowBaseEcoreWl2::GetScreenOffMode() const
2262 {
2263   while(!mTizenPolicy)
2264   {
2265     wl_display_dispatch_queue(mDisplay, mEventQueue);
2266   }
2267
2268   int count = 0;
2269
2270   while(!mScreenOffModeChangeDone && count < 3)
2271   {
2272     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2273     wl_display_dispatch_queue(mDisplay, mEventQueue);
2274     count++;
2275   }
2276
2277   if(!mScreenOffModeChangeDone)
2278   {
2279     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState);
2280     return WindowScreenOffMode::TIMEOUT;
2281   }
2282
2283   WindowScreenOffMode screenMode = WindowScreenOffMode::TIMEOUT;
2284
2285   switch(mScreenOffMode)
2286   {
2287     case 0:
2288     {
2289       screenMode = WindowScreenOffMode::TIMEOUT;
2290       break;
2291     }
2292     case 1:
2293     {
2294       screenMode = WindowScreenOffMode::NEVER;
2295       break;
2296     }
2297   }
2298
2299   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode);
2300
2301   return screenMode;
2302 }
2303
2304 Dali::WindowOperationResult WindowBaseEcoreWl2::SetBrightness(int brightness)
2305 {
2306   while(!mTizenDisplayPolicy)
2307   {
2308     wl_display_dispatch_queue(mDisplay, mEventQueue);
2309   }
2310
2311   mBrightnessChangeDone  = false;
2312   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2313
2314   tizen_display_policy_set_window_brightness(mTizenDisplayPolicy, ecore_wl2_window_surface_get(mEcoreWindow), brightness);
2315
2316   int count = 0;
2317
2318   while(!mBrightnessChangeDone && count < 3)
2319   {
2320     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2321     wl_display_dispatch_queue(mDisplay, mEventQueue);
2322     count++;
2323   }
2324
2325   if(!mBrightnessChangeDone)
2326   {
2327     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState);
2328     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2329   }
2330   else if(mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2331   {
2332     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness);
2333     return Dali::WindowOperationResult::PERMISSION_DENIED;
2334   }
2335
2336   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness);
2337
2338   return Dali::WindowOperationResult::SUCCEED;
2339 }
2340
2341 int WindowBaseEcoreWl2::GetBrightness() const
2342 {
2343   while(!mTizenDisplayPolicy)
2344   {
2345     wl_display_dispatch_queue(mDisplay, mEventQueue);
2346   }
2347
2348   int count = 0;
2349
2350   while(!mBrightnessChangeDone && count < 3)
2351   {
2352     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2353     wl_display_dispatch_queue(mDisplay, mEventQueue);
2354     count++;
2355   }
2356
2357   if(!mBrightnessChangeDone)
2358   {
2359     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState);
2360     return 0;
2361   }
2362
2363   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness);
2364
2365   return mBrightness;
2366 }
2367
2368 bool WindowBaseEcoreWl2::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
2369 {
2370   Ecore_Wl2_Window_Keygrab_Mode mode;
2371
2372   switch(grabMode)
2373   {
2374     case KeyGrab::TOPMOST:
2375     {
2376       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2377       break;
2378     }
2379     case KeyGrab::SHARED:
2380     {
2381       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2382       break;
2383     }
2384     case KeyGrab::OVERRIDE_EXCLUSIVE:
2385     {
2386       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2387       break;
2388     }
2389     case KeyGrab::EXCLUSIVE:
2390     {
2391       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2392       break;
2393     }
2394     default:
2395     {
2396       return false;
2397     }
2398   }
2399
2400   return ecore_wl2_window_keygrab_set(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0, 0, mode);
2401 }
2402
2403 bool WindowBaseEcoreWl2::UngrabKey(Dali::KEY key)
2404 {
2405   return ecore_wl2_window_keygrab_unset(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0);
2406 }
2407
2408 bool WindowBaseEcoreWl2::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
2409 {
2410   int keyCount         = key.Count();
2411   int keyGrabModeCount = grabMode.Count();
2412
2413   if(keyCount != keyGrabModeCount || keyCount == 0)
2414   {
2415     return false;
2416   }
2417
2418   eina_init();
2419
2420   Eina_List*                     keyList = NULL;
2421   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2422
2423   for(int index = 0; index < keyCount; ++index)
2424   {
2425     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2426
2427     switch(grabMode[index])
2428     {
2429       case KeyGrab::TOPMOST:
2430       {
2431         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2432         break;
2433       }
2434       case KeyGrab::SHARED:
2435       {
2436         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2437         break;
2438       }
2439       case KeyGrab::OVERRIDE_EXCLUSIVE:
2440       {
2441         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2442         break;
2443       }
2444       case KeyGrab::EXCLUSIVE:
2445       {
2446         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2447         break;
2448       }
2449       default:
2450       {
2451         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2452         break;
2453       }
2454     }
2455
2456     keyList = eina_list_append(keyList, &info);
2457   }
2458
2459   Eina_List* grabList = ecore_wl2_window_keygrab_list_set(mEcoreWindow, keyList);
2460
2461   result.Resize(keyCount, true);
2462
2463   Eina_List* l        = NULL;
2464   Eina_List* m        = NULL;
2465   void*      listData = NULL;
2466   void*      data     = NULL;
2467   if(grabList != NULL)
2468   {
2469     EINA_LIST_FOREACH(grabList, m, data)
2470     {
2471       int index = 0;
2472       EINA_LIST_FOREACH(keyList, l, listData)
2473       {
2474         if(static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key == NULL)
2475         {
2476           DALI_LOG_ERROR("input key list has null data!");
2477           break;
2478         }
2479
2480         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2481         {
2482           result[index] = false;
2483         }
2484         ++index;
2485       }
2486     }
2487   }
2488
2489   delete[] info;
2490
2491   eina_list_free(keyList);
2492   eina_list_free(grabList);
2493   eina_shutdown();
2494
2495   return true;
2496 }
2497
2498 bool WindowBaseEcoreWl2::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
2499 {
2500   int keyCount = key.Count();
2501   if(keyCount == 0)
2502   {
2503     return false;
2504   }
2505
2506   eina_init();
2507
2508   Eina_List*                     keyList = NULL;
2509   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2510
2511   for(int index = 0; index < keyCount; ++index)
2512   {
2513     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2514     keyList         = eina_list_append(keyList, &info);
2515   }
2516
2517   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset(mEcoreWindow, keyList);
2518
2519   result.Resize(keyCount, true);
2520
2521   Eina_List* l        = NULL;
2522   Eina_List* m        = NULL;
2523   void*      listData = NULL;
2524   void*      data     = NULL;
2525
2526   if(ungrabList != NULL)
2527   {
2528     EINA_LIST_FOREACH(ungrabList, m, data)
2529     {
2530       int index = 0;
2531       EINA_LIST_FOREACH(keyList, l, listData)
2532       {
2533         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2534         {
2535           result[index] = false;
2536         }
2537         ++index;
2538       }
2539     }
2540   }
2541
2542   delete[] info;
2543
2544   eina_list_free(keyList);
2545   eina_list_free(ungrabList);
2546   eina_shutdown();
2547
2548   return true;
2549 }
2550
2551 void WindowBaseEcoreWl2::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
2552 {
2553   // calculate DPI
2554   float xres, yres;
2555
2556   Ecore_Wl2_Output* output = ecore_wl2_window_output_find(mEcoreWindow);
2557
2558   // 1 inch = 25.4 millimeters
2559   xres = ecore_wl2_output_dpi_get(output);
2560   yres = ecore_wl2_output_dpi_get(output);
2561
2562   dpiHorizontal = int(xres + 0.5f); // rounding
2563   dpiVertical   = int(yres + 0.5f);
2564 }
2565
2566 int WindowBaseEcoreWl2::GetOrientation() const
2567 {
2568   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2569   if(mSupportedPreProtation)
2570   {
2571     orientation = 0;
2572   }
2573   return orientation;
2574 }
2575
2576 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2577 {
2578   int transform = 0;
2579
2580   if(ecore_wl2_window_ignore_output_transform_get(mEcoreWindow))
2581   {
2582     transform = 0;
2583   }
2584   else
2585   {
2586     transform = ecore_wl2_output_transform_get(ecore_wl2_window_output_find(mEcoreWindow));
2587   }
2588   mScreenRotationAngle = transform * 90;
2589   return mScreenRotationAngle;
2590 }
2591
2592 void WindowBaseEcoreWl2::SetWindowRotationAngle(int degree)
2593 {
2594   mWindowRotationAngle = degree;
2595   ecore_wl2_window_rotation_set(mEcoreWindow, degree);
2596 }
2597
2598 void WindowBaseEcoreWl2::WindowRotationCompleted(int degree, int width, int height)
2599 {
2600   ecore_wl2_window_rotation_change_done_send(mEcoreWindow, degree, width, height);
2601 }
2602
2603 void WindowBaseEcoreWl2::SetTransparency(bool transparent)
2604 {
2605   ecore_wl2_window_alpha_set(mEcoreWindow, transparent);
2606 }
2607
2608 void WindowBaseEcoreWl2::InitializeEcoreElDBus()
2609 {
2610 #ifdef DALI_ELDBUS_AVAILABLE
2611   Eldbus_Object* object;
2612   Eldbus_Proxy*  manager;
2613
2614   if(!(mSystemConnection = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM)))
2615   {
2616     DALI_LOG_ERROR("Unable to get system bus\n");
2617   }
2618
2619   object = eldbus_object_get(mSystemConnection, BUS, PATH);
2620   if(!object)
2621   {
2622     DALI_LOG_ERROR("Getting object failed\n");
2623     return;
2624   }
2625
2626   manager = eldbus_proxy_get(object, INTERFACE);
2627   if(!manager)
2628   {
2629     DALI_LOG_ERROR("Getting proxy failed\n");
2630     return;
2631   }
2632
2633   if(!eldbus_proxy_signal_handler_add(manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this))
2634   {
2635     DALI_LOG_ERROR("No signal handler returned\n");
2636   }
2637 #endif
2638 }
2639
2640 void WindowBaseEcoreWl2::CreateWindow(PositionSize positionSize)
2641 {
2642   Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
2643   if(!display)
2644   {
2645     DALI_ASSERT_ALWAYS(0 && "Failed to get display");
2646   }
2647
2648   ecore_wl2_display_sync(display);
2649
2650   mEcoreWindow = ecore_wl2_window_new(display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2651
2652   if(mEcoreWindow == 0)
2653   {
2654     DALI_ASSERT_ALWAYS(0 && "Failed to create Wayland window");
2655   }
2656
2657   // Set default type
2658   ecore_wl2_window_type_set(mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
2659
2660   // Get Screen width, height
2661   ecore_wl2_display_screen_size_get(display, &mScreenWidth, &mScreenHeight);
2662 }
2663
2664 void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase, bool belowParent)
2665 {
2666   Ecore_Wl2_Window* ecoreParent = NULL;
2667   if(parentWinBase)
2668   {
2669     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
2670     ecoreParent                       = winBaseEcore2->mEcoreWindow;
2671   }
2672   ecore_wl2_window_transient_parent_set(mEcoreWindow, ecoreParent, belowParent);
2673 }
2674
2675 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2676 {
2677   return wl_egl_window_tizen_create_commit_sync_fd(mEglWindow);
2678 }
2679
2680 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2681 {
2682   return wl_egl_window_tizen_create_presentation_sync_fd(mEglWindow);
2683 }
2684
2685 void WindowBaseEcoreWl2::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
2686 {
2687   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);
2688   ecore_wl2_window_rotation_geometry_set(mEcoreWindow, angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2689 }
2690
2691 void WindowBaseEcoreWl2::InitializeIme()
2692 {
2693   Eina_Iterator*      globals;
2694   struct wl_registry* registry;
2695   Ecore_Wl2_Global*   global;
2696   Ecore_Wl2_Display*  ecoreWl2Display;
2697
2698   if(!(ecoreWl2Display = ecore_wl2_connected_display_get(NULL)))
2699   {
2700     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 connected display\n");
2701     return;
2702   }
2703
2704   DALI_LOG_RELEASE_INFO("InitializeIme:  Ecore_Wl2_Display: %p, ecore wl window: %p\n", ecoreWl2Display, mEcoreWindow);
2705
2706   if(!(registry = ecore_wl2_display_registry_get(ecoreWl2Display)))
2707   {
2708     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 display registry\n");
2709     return;
2710   }
2711
2712   if(!(globals = ecore_wl2_display_globals_get(ecoreWl2Display)))
2713   {
2714     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 globals\n");
2715     return;
2716   }
2717
2718   EINA_ITERATOR_FOREACH(globals, global)
2719   {
2720 #ifdef OVER_TIZEN_VERSION_7
2721     if(strcmp(global->interface, "zwp_input_panel_v1") == 0)
2722     {
2723       mWlInputPanel = (zwp_input_panel_v1*)wl_registry_bind(registry, global->id, &zwp_input_panel_v1_interface, 1);
2724     }
2725 #else
2726     if(strcmp(global->interface, "wl_input_panel") == 0)
2727     {
2728       mWlInputPanel = (wl_input_panel*)wl_registry_bind(registry, global->id, &wl_input_panel_interface, 1);
2729     }
2730 #endif
2731     else if(strcmp(global->interface, "wl_output") == 0)
2732     {
2733       mWlOutput = (wl_output*)wl_registry_bind(registry, global->id, &wl_output_interface, 1);
2734     }
2735   }
2736
2737   if(!mWlInputPanel)
2738   {
2739     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel interface\n");
2740     return;
2741   }
2742
2743   if(!mWlOutput)
2744   {
2745     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland output panel interface\n");
2746     return;
2747   }
2748 #ifdef OVER_TIZEN_VERSION_7
2749   mWlInputPanelSurface = zwp_input_panel_v1_get_input_panel_surface(mWlInputPanel, mWlSurface);
2750 #else
2751   mWlInputPanelSurface = wl_input_panel_get_input_panel_surface(mWlInputPanel, mWlSurface);
2752 #endif
2753   if(!mWlInputPanelSurface)
2754   {
2755     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel surface\n");
2756     return;
2757   }
2758 #ifdef OVER_TIZEN_VERSION_7
2759   zwp_input_panel_surface_v1_set_toplevel(mWlInputPanelSurface, mWlOutput, ZWP_INPUT_PANEL_SURFACE_V1_POSITION_CENTER_BOTTOM);
2760 #else
2761   wl_input_panel_surface_set_toplevel(mWlInputPanelSurface, mWlOutput, WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
2762 #endif
2763 }
2764
2765 void WindowBaseEcoreWl2::ImeWindowReadyToRender()
2766 {
2767   if(!mWlInputPanelSurface)
2768   {
2769     DALI_LOG_ERROR("WindowBaseEcoreWl2::ImeWindowReadyToRender(), wayland input panel surface is null\n");
2770     return;
2771   }
2772 #ifdef OVER_TIZEN_VERSION_7
2773   zwp_input_panel_surface_v1_set_ready(mWlInputPanelSurface, 1);
2774 #else
2775   wl_input_panel_surface_set_ready(mWlInputPanelSurface, 1);
2776 #endif
2777 }
2778
2779 void WindowBaseEcoreWl2::RequestMoveToServer()
2780 {
2781   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2782   if(!display)
2783   {
2784     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get ecore_wl2_display\n");
2785     return;
2786   }
2787
2788   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2789   if(!input)
2790   {
2791     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get default Ecore_Wl2_Input\n");
2792     return;
2793   }
2794
2795   ecore_wl2_window_move(mEcoreWindow, input);
2796   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestMoveToServer, starts the window[%p] is moved by server\n", mEcoreWindow);
2797 }
2798
2799 void WindowBaseEcoreWl2::RequestResizeToServer(WindowResizeDirection direction)
2800 {
2801   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2802   if(!display)
2803   {
2804     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get ecore_wl2_display\n");
2805     return;
2806   }
2807
2808   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2809   if(!input)
2810   {
2811     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get default Ecore_Wl2_Input\n");
2812     return;
2813   }
2814
2815   int location = 0;
2816   switch(direction)
2817   {
2818     case WindowResizeDirection::TOP_LEFT:
2819     {
2820       location = 5;
2821       break;
2822     }
2823     case WindowResizeDirection::TOP:
2824     {
2825       location = 1;
2826       break;
2827     }
2828     case WindowResizeDirection::TOP_RIGHT:
2829     {
2830       location = 9;
2831       break;
2832     }
2833     case WindowResizeDirection::LEFT:
2834     {
2835       location = 4;
2836       break;
2837     }
2838     case WindowResizeDirection::RIGHT:
2839     {
2840       location = 8;
2841       break;
2842     }
2843     case WindowResizeDirection::BOTTOM_LEFT:
2844     {
2845       location = 6;
2846       break;
2847     }
2848     case WindowResizeDirection::BOTTOM:
2849     {
2850       location = 2;
2851       break;
2852     }
2853     case WindowResizeDirection::BOTTOM_RIGHT:
2854     {
2855       location = 10;
2856       break;
2857     }
2858     default:
2859     {
2860       location = 0;
2861       break;
2862     }
2863   }
2864
2865   ecore_wl2_window_resize(mEcoreWindow, input, location);
2866   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestResizeToServer, starts the window[%p] is resized by server, mode:%d\n", mEcoreWindow, location);
2867 }
2868
2869 void WindowBaseEcoreWl2::EnableFloatingMode(bool enable)
2870 {
2871   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EnableFloatingMode, floating mode flag: [%p], enable [%d]\n", mEcoreWindow, enable);
2872   if(enable == true)
2873   {
2874     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_TRUE);
2875   }
2876   else
2877   {
2878     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_FALSE);
2879   }
2880 }
2881
2882 bool WindowBaseEcoreWl2::IsFloatingModeEnabled() const
2883 {
2884   return ecore_wl2_window_floating_mode_get(mEcoreWindow);
2885 }
2886
2887 void WindowBaseEcoreWl2::IncludeInputRegion(const Rect<int>& inputRegion)
2888 {
2889   Eina_Rectangle rect;
2890   rect.x = inputRegion.x;
2891   rect.y = inputRegion.y;
2892   rect.w = inputRegion.width;
2893   rect.h = inputRegion.height;
2894
2895   ecore_wl2_window_input_rect_add(mEcoreWindow, &rect);
2896   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2897 }
2898
2899 void WindowBaseEcoreWl2::ExcludeInputRegion(const Rect<int>& inputRegion)
2900 {
2901   Eina_Rectangle rect;
2902   rect.x = inputRegion.x;
2903   rect.y = inputRegion.y;
2904   rect.w = inputRegion.width;
2905   rect.h = inputRegion.height;
2906
2907   ecore_wl2_window_input_rect_subtract(mEcoreWindow, &rect);
2908   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2909 }
2910
2911 } // namespace Adaptor
2912
2913 } // namespace Internal
2914
2915 } // namespace Dali
2916
2917 #pragma GCC diagnostic pop