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