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_for_ui_thread(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this);
 828   vconf_notify_key_changed_for_ui_thread(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     std::string keyName(keyEvent->keyname);
1188     std::string logicalKey("");
1189     std::string keyString("");
1190     std::string compose("");
1191
1192     DALI_LOG_RELEASE_INFO("OnKeyDown Start [%s]\n", keyName.c_str());
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     DALI_LOG_RELEASE_INFO("OnKeyDown End [%s]\n", keyName.c_str());
1242   }
1243 }
1244
1245 void WindowBaseEcoreWl2::OnKeyUp(void* data, int type, void* event)
1246 {
1247   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1248
1249   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
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     DALI_LOG_RELEASE_INFO("OnKeyUp Start [%s]\n", keyName.c_str());
1266
1267     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1268     if(keyEvent->compose)
1269     {
1270       compose = keyEvent->compose;
1271     }
1272
1273     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1274     if(keyEvent->key)
1275     {
1276       logicalKey = keyEvent->key;
1277     }
1278
1279     int keyCode = 0;
1280     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1281
1282     if(keyCode == 0)
1283     {
1284       // Get a specific key code from dali key look up table.
1285       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1286     }
1287
1288     keyCode = (keyCode == -1) ? 0 : keyCode;
1289     int           modifier(keyEvent->modifiers);
1290     unsigned long time = keyEvent->timestamp;
1291     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1292     {
1293       keyCode = atoi(keyEvent->keyname + 8);
1294     }
1295
1296     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1297     if(keyEvent->string)
1298     {
1299       keyString = keyEvent->string;
1300     }
1301
1302     std::string            deviceName;
1303     Device::Class::Type    deviceClass;
1304     Device::Subclass::Type deviceSubclass;
1305
1306     GetDeviceName(keyEvent, deviceName);
1307     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1308     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1309
1310     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
1311
1312     mKeyEventSignal.Emit(keyEvent);
1313
1314     DALI_LOG_RELEASE_INFO("OnKeyUp End [%s]\n", keyName.c_str());
1315   }
1316 }
1317
1318 void WindowBaseEcoreWl2::OnDataSend(void* data, int type, void* event)
1319 {
1320   mSelectionDataSendSignal.Emit(event);
1321 }
1322
1323 void WindowBaseEcoreWl2::OnDataReceive(void* data, int type, void* event)
1324 {
1325   mSelectionDataReceivedSignal.Emit(event);
1326 }
1327
1328 void WindowBaseEcoreWl2::OnFontNameChanged()
1329 {
1330   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
1331 }
1332
1333 void WindowBaseEcoreWl2::OnFontSizeChanged()
1334 {
1335   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
1336 }
1337
1338 void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
1339 {
1340   mTransitionEffectEventSignal.Emit(state, type);
1341 }
1342
1343 void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
1344 {
1345   mKeyboardRepeatSettingsChangedSignal.Emit();
1346 }
1347
1348 void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
1349 {
1350   mWindowRedrawRequestSignal.Emit();
1351 }
1352
1353 void WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage(void* event)
1354 {
1355   Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
1356   if(message)
1357   {
1358     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, key:%s, value:%s \n", message->key, message->val);
1359     std::string           key(message->key);
1360     std::string           value(message->val);
1361     Dali::Property::Array options;
1362
1363     if(message->options)
1364     {
1365       Eina_List* l;
1366       void*      data;
1367       EINA_LIST_FOREACH(message->options, l, data)
1368       {
1369         DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, option: %s\n", (char*)data);
1370         std::string option(static_cast<char*>(data));
1371         options.Add(option);
1372       }
1373     }
1374
1375     mAuxiliaryMessageSignal.Emit(key, value, options);
1376   }
1377 }
1378
1379 void WindowBaseEcoreWl2::KeymapChanged(void* data, int type, void* event)
1380 {
1381   Ecore_Wl2_Event_Seat_Keymap_Changed* changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>(event);
1382   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id);
1383   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(changed->display);
1384   if(ecoreWlInput)
1385   {
1386     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
1387   }
1388 }
1389
1390 void WindowBaseEcoreWl2::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
1391 {
1392   if(strcmp(interface, tizen_policy_interface.name) == 0)
1393   {
1394     uint32_t clientVersion = std::min(version, MAX_TIZEN_CLIENT_VERSION);
1395
1396     mTizenPolicy = static_cast<tizen_policy*>(wl_registry_bind(registry, name, &tizen_policy_interface, clientVersion));
1397     if(!mTizenPolicy)
1398     {
1399       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n");
1400       return;
1401     }
1402
1403     tizen_policy_add_listener(mTizenPolicy, &tizenPolicyListener, data);
1404
1405     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n");
1406   }
1407   else if(strcmp(interface, tizen_display_policy_interface.name) == 0)
1408   {
1409     mTizenDisplayPolicy = static_cast<tizen_display_policy*>(wl_registry_bind(registry, name, &tizen_display_policy_interface, version));
1410     if(!mTizenDisplayPolicy)
1411     {
1412       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n");
1413       return;
1414     }
1415
1416     tizen_display_policy_add_listener(mTizenDisplayPolicy, &tizenDisplayPolicyListener, data);
1417
1418     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n");
1419   }
1420 }
1421
1422 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
1423 {
1424   mTizenPolicy        = NULL;
1425   mTizenDisplayPolicy = NULL;
1426 }
1427
1428 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
1429 {
1430   mNotificationLevel           = level;
1431   mNotificationChangeState     = state;
1432   mNotificationLevelChangeDone = true;
1433
1434   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state);
1435 }
1436
1437 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
1438 {
1439   mScreenOffMode            = mode;
1440   mScreenOffModeChangeState = state;
1441   mScreenOffModeChangeDone  = true;
1442
1443   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state);
1444 }
1445
1446 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
1447 {
1448   mBrightness            = brightness;
1449   mBrightnessChangeState = state;
1450   mBrightnessChangeDone  = true;
1451
1452   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state);
1453 }
1454
1455 void WindowBaseEcoreWl2::GetKeyCode(std::string keyName, int32_t& keyCode)
1456 {
1457   xkb_keysym_t sym = XKB_KEY_NoSymbol;
1458   KeyCodeMap   foundKeyCode;
1459
1460   sym = xkb_keysym_from_name(keyName.c_str(), XKB_KEYSYM_NO_FLAGS);
1461   if(sym == XKB_KEY_NoSymbol)
1462   {
1463     DALI_LOG_ERROR("Failed to get keysym in WindowBaseEcoreWl2\n");
1464     return;
1465   }
1466
1467   foundKeyCode.keySym    = sym;
1468   foundKeyCode.isKeyCode = false;
1469   xkb_keymap_key_for_each(mKeyMap, FindKeyCode, &foundKeyCode);
1470   keyCode = static_cast<int32_t>(foundKeyCode.keyCode);
1471 }
1472
1473 Any WindowBaseEcoreWl2::GetNativeWindow()
1474 {
1475   return mEcoreWindow;
1476 }
1477
1478 int WindowBaseEcoreWl2::GetNativeWindowId()
1479 {
1480   return ecore_wl2_window_id_get(mEcoreWindow);
1481 }
1482
1483 std::string WindowBaseEcoreWl2::GetNativeWindowResourceId()
1484 {
1485 #ifdef OVER_TIZEN_VERSION_7
1486   return std::to_string(ecore_wl2_window_resource_id_get(mEcoreWindow));
1487 #else
1488   return std::string();
1489 #endif
1490 }
1491
1492 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow(int width, int height)
1493 {
1494   int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
1495   if(totalAngle == 90 || totalAngle == 270)
1496   {
1497     mEglWindow = wl_egl_window_create(mWlSurface, height, width);
1498   }
1499   else
1500   {
1501     mEglWindow = wl_egl_window_create(mWlSurface, width, height);
1502   }
1503
1504   return static_cast<EGLNativeWindowType>(mEglWindow);
1505 }
1506
1507 void WindowBaseEcoreWl2::DestroyEglWindow()
1508 {
1509   if(mEglWindow != NULL)
1510   {
1511     wl_egl_window_destroy(mEglWindow);
1512     mEglWindow = NULL;
1513   }
1514 }
1515
1516 void WindowBaseEcoreWl2::SetEglWindowRotation(int angle)
1517 {
1518   wl_egl_window_tizen_rotation rotation;
1519
1520   switch(angle)
1521   {
1522     case 0:
1523     {
1524       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1525       break;
1526     }
1527     case 90:
1528     {
1529       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
1530       break;
1531     }
1532     case 180:
1533     {
1534       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
1535       break;
1536     }
1537     case 270:
1538     {
1539       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
1540       break;
1541     }
1542     default:
1543     {
1544       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1545       break;
1546     }
1547   }
1548
1549   wl_egl_window_tizen_set_rotation(mEglWindow, rotation);
1550 }
1551
1552 void WindowBaseEcoreWl2::SetEglWindowBufferTransform(int angle)
1553 {
1554   wl_output_transform bufferTransform;
1555
1556   switch(angle)
1557   {
1558     case 0:
1559     {
1560       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1561       break;
1562     }
1563     case 90:
1564     {
1565       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1566       break;
1567     }
1568     case 180:
1569     {
1570       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1571       break;
1572     }
1573     case 270:
1574     {
1575       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1576       break;
1577     }
1578     default:
1579     {
1580       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1581       break;
1582     }
1583   }
1584
1585   wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
1586 }
1587
1588 void WindowBaseEcoreWl2::SetEglWindowTransform(int angle)
1589 {
1590   wl_output_transform windowTransform;
1591
1592   switch(angle)
1593   {
1594     case 0:
1595     {
1596       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1597       break;
1598     }
1599     case 90:
1600     {
1601       windowTransform = WL_OUTPUT_TRANSFORM_90;
1602       break;
1603     }
1604     case 180:
1605     {
1606       windowTransform = WL_OUTPUT_TRANSFORM_180;
1607       break;
1608     }
1609     case 270:
1610     {
1611       windowTransform = WL_OUTPUT_TRANSFORM_270;
1612       break;
1613     }
1614     default:
1615     {
1616       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1617       break;
1618     }
1619   }
1620
1621   wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
1622 }
1623
1624 void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
1625 {
1626   wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
1627
1628   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
1629   if(mMoveResizeSerial != mLastSubmittedMoveResizeSerial)
1630   {
1631     wl_egl_window_tizen_set_window_serial(mEglWindow, mMoveResizeSerial);
1632     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
1633   }
1634 }
1635
1636 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
1637 {
1638   // Check capability
1639   wl_egl_window_tizen_capability capability = static_cast<wl_egl_window_tizen_capability>(wl_egl_window_tizen_get_capabilities(mEglWindow));
1640   if(capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED)
1641   {
1642     mSupportedPreProtation = true;
1643     return true;
1644   }
1645   mSupportedPreProtation = false;
1646   return false;
1647 }
1648
1649 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToSystem(PositionSize positionSize)
1650 {
1651   PositionSize newPositionSize;
1652
1653   if(mWindowRotationAngle == 90)
1654   {
1655     newPositionSize.x      = positionSize.y;
1656     newPositionSize.y      = mScreenHeight - (positionSize.x + positionSize.width);
1657     newPositionSize.width  = positionSize.height;
1658     newPositionSize.height = positionSize.width;
1659   }
1660   else if(mWindowRotationAngle == 180)
1661   {
1662     newPositionSize.x      = mScreenWidth - (positionSize.x + positionSize.width);
1663     newPositionSize.y      = mScreenHeight - (positionSize.y + positionSize.height);
1664     newPositionSize.width  = positionSize.width;
1665     newPositionSize.height = positionSize.height;
1666   }
1667   else if(mWindowRotationAngle == 270)
1668   {
1669     newPositionSize.x      = mScreenWidth - (positionSize.y + positionSize.height);
1670     newPositionSize.y      = positionSize.x;
1671     newPositionSize.width  = positionSize.height;
1672     newPositionSize.height = positionSize.width;
1673   }
1674   else
1675   {
1676     newPositionSize.x      = positionSize.x;
1677     newPositionSize.y      = positionSize.y;
1678     newPositionSize.width  = positionSize.width;
1679     newPositionSize.height = positionSize.height;
1680   }
1681
1682   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);
1683   DALI_LOG_RELEASE_INFO("recalc coord x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1684
1685   return newPositionSize;
1686 }
1687
1688 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToCurrentOrientation(PositionSize positionSize)
1689 {
1690   PositionSize newPositionSize;
1691
1692   if(mWindowRotationAngle == 90)
1693   {
1694     newPositionSize.x      = mScreenHeight - (positionSize.y + positionSize.height);
1695     newPositionSize.y      = positionSize.x;
1696     newPositionSize.width  = positionSize.height;
1697     newPositionSize.height = positionSize.width;
1698   }
1699   else if(mWindowRotationAngle == 180)
1700   {
1701     newPositionSize.x      = mScreenWidth - (positionSize.x + positionSize.width);
1702     newPositionSize.y      = mScreenHeight - (positionSize.y + positionSize.height);
1703     newPositionSize.width  = positionSize.width;
1704     newPositionSize.height = positionSize.height;
1705   }
1706   else if(mWindowRotationAngle == 270)
1707   {
1708     newPositionSize.x      = positionSize.y;
1709     newPositionSize.y      = mScreenWidth - (positionSize.x + positionSize.width);
1710     newPositionSize.width  = positionSize.height;
1711     newPositionSize.height = positionSize.width;
1712   }
1713   else
1714   {
1715     newPositionSize.x      = positionSize.x;
1716     newPositionSize.y      = positionSize.y;
1717     newPositionSize.width  = positionSize.width;
1718     newPositionSize.height = positionSize.height;
1719   }
1720
1721   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);
1722   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);
1723
1724   return newPositionSize;
1725 }
1726
1727 void WindowBaseEcoreWl2::Move(PositionSize positionSize)
1728 {
1729   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1730
1731   mWindowPositionSize = newPositionSize;
1732   DALI_LOG_RELEASE_INFO("ecore_wl2_window_position_set x[%d], y[%d]\n", newPositionSize.x, newPositionSize.y);
1733   ecore_wl2_window_position_set(mEcoreWindow, newPositionSize.x, newPositionSize.y);
1734 }
1735
1736 void WindowBaseEcoreWl2::Resize(PositionSize positionSize)
1737 {
1738   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1739
1740   mWindowPositionSize = newPositionSize;
1741   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);
1742   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1743 }
1744
1745 void WindowBaseEcoreWl2::MoveResize(PositionSize positionSize)
1746 {
1747   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1748
1749   mWindowPositionSize = newPositionSize;
1750   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);
1751   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1752 }
1753
1754 void WindowBaseEcoreWl2::SetClass(const std::string& name, const std::string& className)
1755 {
1756   ecore_wl2_window_title_set(mEcoreWindow, name.c_str());
1757   ecore_wl2_window_class_set(mEcoreWindow, className.c_str());
1758 }
1759
1760 void WindowBaseEcoreWl2::Raise()
1761 {
1762   // Use ecore_wl2_window_activate to prevent the window shown without rendering
1763   ecore_wl2_window_activate(mEcoreWindow);
1764 }
1765
1766 void WindowBaseEcoreWl2::Lower()
1767 {
1768   ecore_wl2_window_lower(mEcoreWindow);
1769 }
1770
1771 void WindowBaseEcoreWl2::Activate()
1772 {
1773   ecore_wl2_window_activate(mEcoreWindow);
1774 }
1775
1776 void WindowBaseEcoreWl2::Maximize(bool maximize)
1777 {
1778   ecore_wl2_window_maximized_set(mEcoreWindow, maximize);
1779 }
1780
1781 bool WindowBaseEcoreWl2::IsMaximized() const
1782 {
1783   return ecore_wl2_window_maximized_get(mEcoreWindow);
1784 }
1785
1786 void WindowBaseEcoreWl2::SetMaximumSize(Dali::Window::WindowSize size)
1787 {
1788   DALI_LOG_RELEASE_INFO("ecore_wl2_window_maximum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
1789   ecore_wl2_window_maximum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
1790 }
1791
1792 void WindowBaseEcoreWl2::Minimize(bool minimize)
1793 {
1794   ecore_wl2_window_iconified_set(mEcoreWindow, minimize);
1795 }
1796
1797 bool WindowBaseEcoreWl2::IsMinimized() const
1798 {
1799   return ecore_wl2_window_iconified_get(mEcoreWindow);
1800 }
1801
1802 void WindowBaseEcoreWl2::SetMimimumSize(Dali::Window::WindowSize size)
1803 {
1804   DALI_LOG_RELEASE_INFO("ecore_wl2_window_minimum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
1805   ecore_wl2_window_minimum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
1806 }
1807
1808 void WindowBaseEcoreWl2::SetAvailableAnlges(const std::vector<int>& angles)
1809 {
1810   int rotations[4] = {0};
1811   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size());
1812   for(std::size_t i = 0; i < angles.size(); ++i)
1813   {
1814     rotations[i] = static_cast<int>(angles[i]);
1815     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "%d ", rotations[i]);
1816   }
1817   ecore_wl2_window_available_rotations_set(mEcoreWindow, rotations, angles.size());
1818 }
1819
1820 void WindowBaseEcoreWl2::SetPreferredAngle(int angle)
1821 {
1822   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetPreferredAngle, angle: %d\n", angle);
1823   ecore_wl2_window_preferred_rotation_set(mEcoreWindow, angle);
1824 }
1825
1826 void WindowBaseEcoreWl2::SetAcceptFocus(bool accept)
1827 {
1828   ecore_wl2_window_focus_skip_set(mEcoreWindow, !accept);
1829 }
1830
1831 void WindowBaseEcoreWl2::Show()
1832 {
1833   if(!mVisible)
1834   {
1835     ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1836   }
1837   mVisible = true;
1838
1839   ecore_wl2_window_show(mEcoreWindow);
1840 }
1841
1842 void WindowBaseEcoreWl2::Hide()
1843 {
1844   mVisible = false;
1845   ecore_wl2_window_hide(mEcoreWindow);
1846 }
1847
1848 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1849 {
1850   return mSupportedAuxiliaryHints.size();
1851 }
1852
1853 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint(unsigned int index) const
1854 {
1855   if(index >= GetSupportedAuxiliaryHintCount())
1856   {
1857     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index);
1858   }
1859
1860   return mSupportedAuxiliaryHints[index];
1861 }
1862
1863 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint(const std::string& hint, const std::string& value)
1864 {
1865   bool supported = false;
1866
1867   // Check if the hint is suppported
1868   for(std::vector<std::string>::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter)
1869   {
1870     if(*iter == hint)
1871     {
1872       supported = true;
1873       break;
1874     }
1875   }
1876
1877   if(!supported)
1878   {
1879     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str());
1880     return 0;
1881   }
1882
1883   // Check if the hint is already added
1884   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1885   {
1886     if(mAuxiliaryHints[i].first == hint)
1887     {
1888       // Just change the value
1889       mAuxiliaryHints[i].second = value;
1890
1891       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1);
1892
1893       return i + 1; // id is index + 1
1894     }
1895   }
1896
1897   // Add the hint
1898   mAuxiliaryHints.push_back(std::pair<std::string, std::string>(hint, value));
1899
1900   unsigned int id = mAuxiliaryHints.size();
1901
1902   ecore_wl2_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
1903
1904   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
1905
1906   return id;
1907 }
1908
1909 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint(unsigned int id)
1910 {
1911   if(id == 0 || id > mAuxiliaryHints.size())
1912   {
1913     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id);
1914     return false;
1915   }
1916
1917   mAuxiliaryHints[id - 1].second = std::string();
1918
1919   ecore_wl2_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
1920
1921   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
1922
1923   return true;
1924 }
1925
1926 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
1927 {
1928   if(id == 0 || id > mAuxiliaryHints.size())
1929   {
1930     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id);
1931     return false;
1932   }
1933
1934   mAuxiliaryHints[id - 1].second = value;
1935
1936   ecore_wl2_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
1937
1938   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());
1939
1940   return true;
1941 }
1942
1943 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue(unsigned int id) const
1944 {
1945   if(id == 0 || id > mAuxiliaryHints.size())
1946   {
1947     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id);
1948     return std::string();
1949   }
1950
1951   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());
1952
1953   return mAuxiliaryHints[id - 1].second;
1954 }
1955
1956 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId(const std::string& hint) const
1957 {
1958   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1959   {
1960     if(mAuxiliaryHints[i].first == hint)
1961     {
1962       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1);
1963       return i + 1;
1964     }
1965   }
1966
1967   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str());
1968
1969   return 0;
1970 }
1971
1972 void WindowBaseEcoreWl2::SetInputRegion(const Rect<int>& inputRegion)
1973 {
1974   ecore_wl2_window_input_region_set(mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height);
1975 }
1976
1977 void WindowBaseEcoreWl2::SetType(Dali::WindowType type)
1978 {
1979   if(mType != type)
1980   {
1981     mType = type;
1982     Ecore_Wl2_Window_Type windowType;
1983
1984     switch(type)
1985     {
1986       case Dali::WindowType::NORMAL:
1987       {
1988         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1989         break;
1990       }
1991       case Dali::WindowType::NOTIFICATION:
1992       {
1993         windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
1994         break;
1995       }
1996       case Dali::WindowType::UTILITY:
1997       {
1998         windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
1999         break;
2000       }
2001       case Dali::WindowType::DIALOG:
2002       {
2003         windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
2004         break;
2005       }
2006       case Dali::WindowType::IME:
2007       {
2008         windowType = ECORE_WL2_WINDOW_TYPE_NONE;
2009         break;
2010       }
2011       default:
2012       {
2013         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2014         break;
2015       }
2016     }
2017     ecore_wl2_window_type_set(mEcoreWindow, windowType);
2018   }
2019 }
2020
2021 Dali::WindowType WindowBaseEcoreWl2::GetType() const
2022 {
2023   return mType;
2024 }
2025
2026 Dali::WindowOperationResult WindowBaseEcoreWl2::SetNotificationLevel(Dali::WindowNotificationLevel level)
2027 {
2028   while(!mTizenPolicy)
2029   {
2030     wl_display_dispatch_queue(mDisplay, mEventQueue);
2031   }
2032
2033   int notificationLevel;
2034
2035   switch(level)
2036   {
2037     case Dali::WindowNotificationLevel::NONE:
2038     {
2039       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
2040       break;
2041     }
2042     case Dali::WindowNotificationLevel::BASE:
2043     {
2044       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2045       break;
2046     }
2047     case Dali::WindowNotificationLevel::MEDIUM:
2048     {
2049       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
2050       break;
2051     }
2052     case Dali::WindowNotificationLevel::HIGH:
2053     {
2054       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
2055       break;
2056     }
2057     case Dali::WindowNotificationLevel::TOP:
2058     {
2059       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
2060       break;
2061     }
2062     default:
2063     {
2064       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level);
2065       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2066       break;
2067     }
2068   }
2069
2070   mNotificationLevelChangeDone = false;
2071   mNotificationChangeState     = TIZEN_POLICY_ERROR_STATE_NONE;
2072
2073   tizen_policy_set_notification_level(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), notificationLevel);
2074
2075   int count = 0;
2076
2077   while(!mNotificationLevelChangeDone && count < 3)
2078   {
2079     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2080     wl_display_dispatch_queue(mDisplay, mEventQueue);
2081     count++;
2082   }
2083
2084   if(!mNotificationLevelChangeDone)
2085   {
2086     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState);
2087     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2088   }
2089   else if(mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2090   {
2091     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level);
2092     return Dali::WindowOperationResult::PERMISSION_DENIED;
2093   }
2094
2095   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel);
2096
2097   return Dali::WindowOperationResult::SUCCEED;
2098 }
2099
2100 Dali::WindowNotificationLevel WindowBaseEcoreWl2::GetNotificationLevel() const
2101 {
2102   while(!mTizenPolicy)
2103   {
2104     wl_display_dispatch_queue(mDisplay, mEventQueue);
2105   }
2106
2107   int count = 0;
2108
2109   while(!mNotificationLevelChangeDone && count < 3)
2110   {
2111     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2112     wl_display_dispatch_queue(mDisplay, mEventQueue);
2113     count++;
2114   }
2115
2116   if(!mNotificationLevelChangeDone)
2117   {
2118     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState);
2119     return Dali::WindowNotificationLevel::NONE;
2120   }
2121
2122   Dali::WindowNotificationLevel level;
2123
2124   switch(mNotificationLevel)
2125   {
2126     case TIZEN_POLICY_LEVEL_NONE:
2127     {
2128       level = Dali::WindowNotificationLevel::NONE;
2129       break;
2130     }
2131     case TIZEN_POLICY_LEVEL_DEFAULT:
2132     {
2133       level = Dali::WindowNotificationLevel::BASE;
2134       break;
2135     }
2136     case TIZEN_POLICY_LEVEL_MEDIUM:
2137     {
2138       level = Dali::WindowNotificationLevel::MEDIUM;
2139       break;
2140     }
2141     case TIZEN_POLICY_LEVEL_HIGH:
2142     {
2143       level = Dali::WindowNotificationLevel::HIGH;
2144       break;
2145     }
2146     case TIZEN_POLICY_LEVEL_TOP:
2147     {
2148       level = Dali::WindowNotificationLevel::TOP;
2149       break;
2150     }
2151     default:
2152     {
2153       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel);
2154       level = Dali::WindowNotificationLevel::NONE;
2155       break;
2156     }
2157   }
2158
2159   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel);
2160
2161   return level;
2162 }
2163
2164 void WindowBaseEcoreWl2::SetOpaqueState(bool opaque)
2165 {
2166   while(!mTizenPolicy)
2167   {
2168     wl_display_dispatch_queue(mDisplay, mEventQueue);
2169   }
2170
2171   tizen_policy_set_opaque_state(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), (opaque ? 1 : 0));
2172 }
2173
2174 Dali::WindowOperationResult WindowBaseEcoreWl2::SetScreenOffMode(WindowScreenOffMode screenOffMode)
2175 {
2176   while(!mTizenPolicy)
2177   {
2178     wl_display_dispatch_queue(mDisplay, mEventQueue);
2179   }
2180
2181   mScreenOffModeChangeDone  = false;
2182   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2183
2184   unsigned int mode = 0;
2185
2186   switch(screenOffMode)
2187   {
2188     case WindowScreenOffMode::TIMEOUT:
2189     {
2190       mode = 0;
2191       break;
2192     }
2193     case WindowScreenOffMode::NEVER:
2194     {
2195       mode = 1;
2196       break;
2197     }
2198   }
2199
2200   tizen_policy_set_window_screen_mode(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), mode);
2201
2202   int count = 0;
2203
2204   while(!mScreenOffModeChangeDone && count < 3)
2205   {
2206     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2207     wl_display_dispatch_queue(mDisplay, mEventQueue);
2208     count++;
2209   }
2210
2211   if(!mScreenOffModeChangeDone)
2212   {
2213     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState);
2214     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2215   }
2216   else if(mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2217   {
2218     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode);
2219     return Dali::WindowOperationResult::PERMISSION_DENIED;
2220   }
2221
2222   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode);
2223
2224   return Dali::WindowOperationResult::SUCCEED;
2225 }
2226
2227 WindowScreenOffMode WindowBaseEcoreWl2::GetScreenOffMode() const
2228 {
2229   while(!mTizenPolicy)
2230   {
2231     wl_display_dispatch_queue(mDisplay, mEventQueue);
2232   }
2233
2234   int count = 0;
2235
2236   while(!mScreenOffModeChangeDone && count < 3)
2237   {
2238     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2239     wl_display_dispatch_queue(mDisplay, mEventQueue);
2240     count++;
2241   }
2242
2243   if(!mScreenOffModeChangeDone)
2244   {
2245     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState);
2246     return WindowScreenOffMode::TIMEOUT;
2247   }
2248
2249   WindowScreenOffMode screenMode = WindowScreenOffMode::TIMEOUT;
2250
2251   switch(mScreenOffMode)
2252   {
2253     case 0:
2254     {
2255       screenMode = WindowScreenOffMode::TIMEOUT;
2256       break;
2257     }
2258     case 1:
2259     {
2260       screenMode = WindowScreenOffMode::NEVER;
2261       break;
2262     }
2263   }
2264
2265   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode);
2266
2267   return screenMode;
2268 }
2269
2270 Dali::WindowOperationResult WindowBaseEcoreWl2::SetBrightness(int brightness)
2271 {
2272   while(!mTizenDisplayPolicy)
2273   {
2274     wl_display_dispatch_queue(mDisplay, mEventQueue);
2275   }
2276
2277   mBrightnessChangeDone  = false;
2278   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2279
2280   tizen_display_policy_set_window_brightness(mTizenDisplayPolicy, ecore_wl2_window_surface_get(mEcoreWindow), brightness);
2281
2282   int count = 0;
2283
2284   while(!mBrightnessChangeDone && count < 3)
2285   {
2286     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2287     wl_display_dispatch_queue(mDisplay, mEventQueue);
2288     count++;
2289   }
2290
2291   if(!mBrightnessChangeDone)
2292   {
2293     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState);
2294     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2295   }
2296   else if(mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2297   {
2298     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness);
2299     return Dali::WindowOperationResult::PERMISSION_DENIED;
2300   }
2301
2302   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness);
2303
2304   return Dali::WindowOperationResult::SUCCEED;
2305 }
2306
2307 int WindowBaseEcoreWl2::GetBrightness() const
2308 {
2309   while(!mTizenDisplayPolicy)
2310   {
2311     wl_display_dispatch_queue(mDisplay, mEventQueue);
2312   }
2313
2314   int count = 0;
2315
2316   while(!mBrightnessChangeDone && count < 3)
2317   {
2318     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2319     wl_display_dispatch_queue(mDisplay, mEventQueue);
2320     count++;
2321   }
2322
2323   if(!mBrightnessChangeDone)
2324   {
2325     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState);
2326     return 0;
2327   }
2328
2329   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness);
2330
2331   return mBrightness;
2332 }
2333
2334 bool WindowBaseEcoreWl2::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
2335 {
2336   Ecore_Wl2_Window_Keygrab_Mode mode;
2337
2338   switch(grabMode)
2339   {
2340     case KeyGrab::TOPMOST:
2341     {
2342       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2343       break;
2344     }
2345     case KeyGrab::SHARED:
2346     {
2347       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2348       break;
2349     }
2350     case KeyGrab::OVERRIDE_EXCLUSIVE:
2351     {
2352       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2353       break;
2354     }
2355     case KeyGrab::EXCLUSIVE:
2356     {
2357       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2358       break;
2359     }
2360     default:
2361     {
2362       return false;
2363     }
2364   }
2365
2366   return ecore_wl2_window_keygrab_set(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0, 0, mode);
2367 }
2368
2369 bool WindowBaseEcoreWl2::UngrabKey(Dali::KEY key)
2370 {
2371   return ecore_wl2_window_keygrab_unset(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0);
2372 }
2373
2374 bool WindowBaseEcoreWl2::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
2375 {
2376   int keyCount         = key.Count();
2377   int keyGrabModeCount = grabMode.Count();
2378
2379   if(keyCount != keyGrabModeCount || keyCount == 0)
2380   {
2381     return false;
2382   }
2383
2384   eina_init();
2385
2386   Eina_List*                     keyList = NULL;
2387   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2388
2389   for(int index = 0; index < keyCount; ++index)
2390   {
2391     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2392
2393     switch(grabMode[index])
2394     {
2395       case KeyGrab::TOPMOST:
2396       {
2397         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2398         break;
2399       }
2400       case KeyGrab::SHARED:
2401       {
2402         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2403         break;
2404       }
2405       case KeyGrab::OVERRIDE_EXCLUSIVE:
2406       {
2407         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2408         break;
2409       }
2410       case KeyGrab::EXCLUSIVE:
2411       {
2412         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2413         break;
2414       }
2415       default:
2416       {
2417         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2418         break;
2419       }
2420     }
2421
2422     keyList = eina_list_append(keyList, &info);
2423   }
2424
2425   Eina_List* grabList = ecore_wl2_window_keygrab_list_set(mEcoreWindow, keyList);
2426
2427   result.Resize(keyCount, true);
2428
2429   Eina_List* l        = NULL;
2430   Eina_List* m        = NULL;
2431   void*      listData = NULL;
2432   void*      data     = NULL;
2433   if(grabList != NULL)
2434   {
2435     EINA_LIST_FOREACH(grabList, m, data)
2436     {
2437       int index = 0;
2438       EINA_LIST_FOREACH(keyList, l, listData)
2439       {
2440         if(static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key == NULL)
2441         {
2442           DALI_LOG_ERROR("input key list has null data!");
2443           break;
2444         }
2445
2446         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2447         {
2448           result[index] = false;
2449         }
2450         ++index;
2451       }
2452     }
2453   }
2454
2455   delete[] info;
2456
2457   eina_list_free(keyList);
2458   eina_list_free(grabList);
2459   eina_shutdown();
2460
2461   return true;
2462 }
2463
2464 bool WindowBaseEcoreWl2::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
2465 {
2466   int keyCount = key.Count();
2467   if(keyCount == 0)
2468   {
2469     return false;
2470   }
2471
2472   eina_init();
2473
2474   Eina_List*                     keyList = NULL;
2475   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2476
2477   for(int index = 0; index < keyCount; ++index)
2478   {
2479     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2480     keyList         = eina_list_append(keyList, &info);
2481   }
2482
2483   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset(mEcoreWindow, keyList);
2484
2485   result.Resize(keyCount, true);
2486
2487   Eina_List* l        = NULL;
2488   Eina_List* m        = NULL;
2489   void*      listData = NULL;
2490   void*      data     = NULL;
2491
2492   if(ungrabList != NULL)
2493   {
2494     EINA_LIST_FOREACH(ungrabList, m, data)
2495     {
2496       int index = 0;
2497       EINA_LIST_FOREACH(keyList, l, listData)
2498       {
2499         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2500         {
2501           result[index] = false;
2502         }
2503         ++index;
2504       }
2505     }
2506   }
2507
2508   delete[] info;
2509
2510   eina_list_free(keyList);
2511   eina_list_free(ungrabList);
2512   eina_shutdown();
2513
2514   return true;
2515 }
2516
2517 void WindowBaseEcoreWl2::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
2518 {
2519   // calculate DPI
2520   float xres, yres;
2521
2522   Ecore_Wl2_Output* output = ecore_wl2_window_output_find(mEcoreWindow);
2523
2524   // 1 inch = 25.4 millimeters
2525   xres = ecore_wl2_output_dpi_get(output);
2526   yres = ecore_wl2_output_dpi_get(output);
2527
2528   dpiHorizontal = int(xres + 0.5f); // rounding
2529   dpiVertical   = int(yres + 0.5f);
2530 }
2531
2532 int WindowBaseEcoreWl2::GetOrientation() const
2533 {
2534   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2535   if(mSupportedPreProtation)
2536   {
2537     orientation = 0;
2538   }
2539   return orientation;
2540 }
2541
2542 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2543 {
2544   int transform = 0;
2545
2546   if(ecore_wl2_window_ignore_output_transform_get(mEcoreWindow))
2547   {
2548     transform = 0;
2549   }
2550   else
2551   {
2552     transform = ecore_wl2_output_transform_get(ecore_wl2_window_output_find(mEcoreWindow));
2553   }
2554   mScreenRotationAngle = transform * 90;
2555   return mScreenRotationAngle;
2556 }
2557
2558 void WindowBaseEcoreWl2::SetWindowRotationAngle(int degree)
2559 {
2560   mWindowRotationAngle = degree;
2561   ecore_wl2_window_rotation_set(mEcoreWindow, degree);
2562 }
2563
2564 void WindowBaseEcoreWl2::WindowRotationCompleted(int degree, int width, int height)
2565 {
2566   ecore_wl2_window_rotation_change_done_send(mEcoreWindow, degree, width, height);
2567 }
2568
2569 void WindowBaseEcoreWl2::SetTransparency(bool transparent)
2570 {
2571   ecore_wl2_window_alpha_set(mEcoreWindow, transparent);
2572 }
2573
2574 void WindowBaseEcoreWl2::CreateWindow(PositionSize positionSize)
2575 {
2576   Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
2577   if(!display)
2578   {
2579     DALI_ASSERT_ALWAYS(0 && "Failed to get display");
2580   }
2581
2582   ecore_wl2_display_sync(display);
2583
2584   mEcoreWindow = ecore_wl2_window_new(display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2585
2586   if(mEcoreWindow == 0)
2587   {
2588     DALI_ASSERT_ALWAYS(0 && "Failed to create Wayland window");
2589   }
2590
2591   // Set default type
2592   ecore_wl2_window_type_set(mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
2593
2594   // Get Screen width, height
2595   ecore_wl2_display_screen_size_get(display, &mScreenWidth, &mScreenHeight);
2596 }
2597
2598 void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase, bool belowParent)
2599 {
2600   Ecore_Wl2_Window* ecoreParent = NULL;
2601   if(parentWinBase)
2602   {
2603     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
2604     ecoreParent                       = winBaseEcore2->mEcoreWindow;
2605   }
2606   ecore_wl2_window_transient_parent_set(mEcoreWindow, ecoreParent, belowParent);
2607 }
2608
2609 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2610 {
2611   return wl_egl_window_tizen_create_commit_sync_fd(mEglWindow);
2612 }
2613
2614 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2615 {
2616   return wl_egl_window_tizen_create_presentation_sync_fd(mEglWindow);
2617 }
2618
2619 void WindowBaseEcoreWl2::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
2620 {
2621   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);
2622   ecore_wl2_window_rotation_geometry_set(mEcoreWindow, angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2623 }
2624
2625 void WindowBaseEcoreWl2::InitializeIme()
2626 {
2627   Eina_Iterator*      globals;
2628   struct wl_registry* registry;
2629   Ecore_Wl2_Global*   global;
2630   Ecore_Wl2_Display*  ecoreWl2Display;
2631
2632   if(!(ecoreWl2Display = ecore_wl2_connected_display_get(NULL)))
2633   {
2634     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 connected display\n");
2635     return;
2636   }
2637
2638   DALI_LOG_RELEASE_INFO("InitializeIme:  Ecore_Wl2_Display: %p, ecore wl window: %p\n", ecoreWl2Display, mEcoreWindow);
2639
2640   if(!(registry = ecore_wl2_display_registry_get(ecoreWl2Display)))
2641   {
2642     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 display registry\n");
2643     return;
2644   }
2645
2646   if(!(globals = ecore_wl2_display_globals_get(ecoreWl2Display)))
2647   {
2648     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 globals\n");
2649     return;
2650   }
2651
2652   EINA_ITERATOR_FOREACH(globals, global)
2653   {
2654 #ifdef OVER_TIZEN_VERSION_7
2655     if(strcmp(global->interface, "zwp_input_panel_v1") == 0)
2656     {
2657       mWlInputPanel = (zwp_input_panel_v1*)wl_registry_bind(registry, global->id, &zwp_input_panel_v1_interface, 1);
2658     }
2659 #else
2660     if(strcmp(global->interface, "wl_input_panel") == 0)
2661     {
2662       mWlInputPanel = (wl_input_panel*)wl_registry_bind(registry, global->id, &wl_input_panel_interface, 1);
2663     }
2664 #endif
2665     else if(strcmp(global->interface, "wl_output") == 0)
2666     {
2667       mWlOutput = (wl_output*)wl_registry_bind(registry, global->id, &wl_output_interface, 1);
2668     }
2669   }
2670
2671   if(!mWlInputPanel)
2672   {
2673     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel interface\n");
2674     return;
2675   }
2676
2677   if(!mWlOutput)
2678   {
2679     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland output panel interface\n");
2680     return;
2681   }
2682 #ifdef OVER_TIZEN_VERSION_7
2683   mWlInputPanelSurface = zwp_input_panel_v1_get_input_panel_surface(mWlInputPanel, mWlSurface);
2684 #else
2685   mWlInputPanelSurface = wl_input_panel_get_input_panel_surface(mWlInputPanel, mWlSurface);
2686 #endif
2687   if(!mWlInputPanelSurface)
2688   {
2689     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel surface\n");
2690     return;
2691   }
2692 #ifdef OVER_TIZEN_VERSION_7
2693   zwp_input_panel_surface_v1_set_toplevel(mWlInputPanelSurface, mWlOutput, ZWP_INPUT_PANEL_SURFACE_V1_POSITION_CENTER_BOTTOM);
2694 #else
2695   wl_input_panel_surface_set_toplevel(mWlInputPanelSurface, mWlOutput, WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
2696 #endif
2697 }
2698
2699 void WindowBaseEcoreWl2::ImeWindowReadyToRender()
2700 {
2701   if(!mWlInputPanelSurface)
2702   {
2703     DALI_LOG_ERROR("WindowBaseEcoreWl2::ImeWindowReadyToRender(), wayland input panel surface is null\n");
2704     return;
2705   }
2706 #ifdef OVER_TIZEN_VERSION_7
2707   zwp_input_panel_surface_v1_set_ready(mWlInputPanelSurface, 1);
2708 #else
2709   wl_input_panel_surface_set_ready(mWlInputPanelSurface, 1);
2710 #endif
2711 }
2712
2713 void WindowBaseEcoreWl2::RequestMoveToServer()
2714 {
2715   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2716   if(!display)
2717   {
2718     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get ecore_wl2_display\n");
2719     return;
2720   }
2721
2722   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2723   if(!input)
2724   {
2725     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get default Ecore_Wl2_Input\n");
2726     return;
2727   }
2728
2729   ecore_wl2_window_move(mEcoreWindow, input);
2730   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestMoveToServer, starts the window[%p] is moved by server\n", mEcoreWindow);
2731 }
2732
2733 void WindowBaseEcoreWl2::RequestResizeToServer(WindowResizeDirection direction)
2734 {
2735   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2736   if(!display)
2737   {
2738     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get ecore_wl2_display\n");
2739     return;
2740   }
2741
2742   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2743   if(!input)
2744   {
2745     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get default Ecore_Wl2_Input\n");
2746     return;
2747   }
2748
2749   int location = 0;
2750   switch(direction)
2751   {
2752     case WindowResizeDirection::TOP_LEFT:
2753     {
2754       location = 5;
2755       break;
2756     }
2757     case WindowResizeDirection::TOP:
2758     {
2759       location = 1;
2760       break;
2761     }
2762     case WindowResizeDirection::TOP_RIGHT:
2763     {
2764       location = 9;
2765       break;
2766     }
2767     case WindowResizeDirection::LEFT:
2768     {
2769       location = 4;
2770       break;
2771     }
2772     case WindowResizeDirection::RIGHT:
2773     {
2774       location = 8;
2775       break;
2776     }
2777     case WindowResizeDirection::BOTTOM_LEFT:
2778     {
2779       location = 6;
2780       break;
2781     }
2782     case WindowResizeDirection::BOTTOM:
2783     {
2784       location = 2;
2785       break;
2786     }
2787     case WindowResizeDirection::BOTTOM_RIGHT:
2788     {
2789       location = 10;
2790       break;
2791     }
2792     default:
2793     {
2794       location = 0;
2795       break;
2796     }
2797   }
2798
2799   ecore_wl2_window_resize(mEcoreWindow, input, location);
2800   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestResizeToServer, starts the window[%p] is resized by server, mode:%d\n", mEcoreWindow, location);
2801 }
2802
2803 void WindowBaseEcoreWl2::EnableFloatingMode(bool enable)
2804 {
2805   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EnableFloatingMode, floating mode flag: [%p], enable [%d]\n", mEcoreWindow, enable);
2806   if(enable == true)
2807   {
2808     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_TRUE);
2809   }
2810   else
2811   {
2812     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_FALSE);
2813   }
2814 }
2815
2816 bool WindowBaseEcoreWl2::IsFloatingModeEnabled() const
2817 {
2818   return ecore_wl2_window_floating_mode_get(mEcoreWindow);
2819 }
2820
2821 void WindowBaseEcoreWl2::IncludeInputRegion(const Rect<int>& inputRegion)
2822 {
2823   Eina_Rectangle rect;
2824   rect.x = inputRegion.x;
2825   rect.y = inputRegion.y;
2826   rect.w = inputRegion.width;
2827   rect.h = inputRegion.height;
2828
2829   ecore_wl2_window_input_rect_add(mEcoreWindow, &rect);
2830   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2831 }
2832
2833 void WindowBaseEcoreWl2::ExcludeInputRegion(const Rect<int>& inputRegion)
2834 {
2835   Eina_Rectangle rect;
2836   rect.x = inputRegion.x;
2837   rect.y = inputRegion.y;
2838   rect.w = inputRegion.width;
2839   rect.h = inputRegion.height;
2840
2841   ecore_wl2_window_input_rect_subtract(mEcoreWindow, &rect);
2842   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2843 }
2844
2845 } // namespace Adaptor
2846
2847 } // namespace Internal
2848
2849 } // namespace Dali
2850
2851 #pragma GCC diagnostic pop