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