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