dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // Ecore is littered with C style cast
  19 #pragma GCC diagnostic push
  20 #pragma GCC diagnostic ignored "-Wold-style-cast"
  21
  22 // CLASS HEADER
  23 #include <dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.h>
  24
  25 // INTERNAL HEADERS
  26 #include <dali/internal/input/common/key-impl.h>
  27 #include <dali/internal/window-system/common/window-impl.h>
  28 #include <dali/internal/window-system/common/window-render-surface.h>
  29 #include <dali/internal/window-system/common/window-system.h>
  30
  31 // EXTERNAL_HEADERS
  32 #include <Ecore_Input.h>
  33 #include <dali/integration-api/debug.h>
  34 #include <dali/integration-api/trace.h>
  35 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  36 #include <dali/public-api/events/mouse-button.h>
  37 #include <dali/public-api/object/any.h>
  38
  39 #if defined(VCONF_ENABLED)
  40 #include <vconf-keys.h>
  41 #include <vconf.h>
  42 #endif
  43
  44 #include <wayland-egl-tizen.h>
  45
  46 namespace Dali
  47 {
  48 namespace Internal
  49 {
  50 namespace Adaptor
  51 {
  52 namespace
  53 {
  54 #if defined(DEBUG_ENABLED)
  55 Debug::Filter* gWindowBaseLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW_BASE");
  56 #endif
  57
  58 DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
  59
  60 const uint32_t     MAX_TIZEN_CLIENT_VERSION = 7;
  61 const unsigned int PRIMARY_TOUCH_BUTTON_ID  = 1;
  62
  63 #if defined(VCONF_ENABLED)
  64 const char* DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME = "db/setting/accessibility/font_name"; // It will be update at vconf-key.h and replaced.
  65 #endif
  66
  67 struct KeyCodeMap
  68 {
  69   xkb_keysym_t  keySym;
  70   xkb_keycode_t keyCode;
  71   bool          isKeyCode;
  72 };
  73
  74 /**
  75  * Get the device name from the provided ecore key event
  76  */
  77 void GetDeviceName(Ecore_Event_Key* keyEvent, std::string& result)
  78 {
  79   const char* ecoreDeviceName = ecore_device_name_get(keyEvent->dev);
  80
  81   if(ecoreDeviceName)
  82   {
  83     result = ecoreDeviceName;
  84   }
  85 }
  86
  87 /**
  88  * Get the device class from the provided ecore event
  89  */
  90 void GetDeviceClass(Ecore_Device_Class ecoreDeviceClass, Device::Class::Type& deviceClass)
  91 {
  92   switch(ecoreDeviceClass)
  93   {
  94     case ECORE_DEVICE_CLASS_SEAT:
  95     {
  96       deviceClass = Device::Class::USER;
  97       break;
  98     }
  99     case ECORE_DEVICE_CLASS_KEYBOARD:
 100     {
 101       deviceClass = Device::Class::KEYBOARD;
 102       break;
 103     }
 104     case ECORE_DEVICE_CLASS_MOUSE:
 105     {
 106       deviceClass = Device::Class::MOUSE;
 107       break;
 108     }
 109     case ECORE_DEVICE_CLASS_TOUCH:
 110     {
 111       deviceClass = Device::Class::TOUCH;
 112       break;
 113     }
 114     case ECORE_DEVICE_CLASS_PEN:
 115     {
 116       deviceClass = Device::Class::PEN;
 117       break;
 118     }
 119     case ECORE_DEVICE_CLASS_POINTER:
 120     {
 121       deviceClass = Device::Class::POINTER;
 122       break;
 123     }
 124     case ECORE_DEVICE_CLASS_GAMEPAD:
 125     {
 126       deviceClass = Device::Class::GAMEPAD;
 127       break;
 128     }
 129     default:
 130     {
 131       deviceClass = Device::Class::NONE;
 132       break;
 133     }
 134   }
 135 }
 136
 137 void GetDeviceSubclass(Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subclass::Type& deviceSubclass)
 138 {
 139   switch(ecoreDeviceSubclass)
 140   {
 141     case ECORE_DEVICE_SUBCLASS_FINGER:
 142     {
 143       deviceSubclass = Device::Subclass::FINGER;
 144       break;
 145     }
 146     case ECORE_DEVICE_SUBCLASS_FINGERNAIL:
 147     {
 148       deviceSubclass = Device::Subclass::FINGERNAIL;
 149       break;
 150     }
 151     case ECORE_DEVICE_SUBCLASS_KNUCKLE:
 152     {
 153       deviceSubclass = Device::Subclass::KNUCKLE;
 154       break;
 155     }
 156     case ECORE_DEVICE_SUBCLASS_PALM:
 157     {
 158       deviceSubclass = Device::Subclass::PALM;
 159       break;
 160     }
 161     case ECORE_DEVICE_SUBCLASS_HAND_SIZE:
 162     {
 163       deviceSubclass = Device::Subclass::HAND_SIDE;
 164       break;
 165     }
 166     case ECORE_DEVICE_SUBCLASS_HAND_FLAT:
 167     {
 168       deviceSubclass = Device::Subclass::HAND_FLAT;
 169       break;
 170     }
 171     case ECORE_DEVICE_SUBCLASS_PEN_TIP:
 172     {
 173       deviceSubclass = Device::Subclass::PEN_TIP;
 174       break;
 175     }
 176     case ECORE_DEVICE_SUBCLASS_TRACKPAD:
 177     {
 178       deviceSubclass = Device::Subclass::TRACKPAD;
 179       break;
 180     }
 181     case ECORE_DEVICE_SUBCLASS_TRACKPOINT:
 182     {
 183       deviceSubclass = Device::Subclass::TRACKPOINT;
 184       break;
 185     }
 186     case ECORE_DEVICE_SUBCLASS_TRACKBALL:
 187     {
 188       deviceSubclass = Device::Subclass::TRACKBALL;
 189       break;
 190     }
 191     case ECORE_DEVICE_SUBCLASS_REMOCON:
 192     {
 193       deviceSubclass = Device::Subclass::REMOCON;
 194       break;
 195     }
 196     case ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD:
 197     {
 198       deviceSubclass = Device::Subclass::VIRTUAL_KEYBOARD;
 199       break;
 200     }
 201     default:
 202     {
 203       deviceSubclass = Device::Subclass::NONE;
 204       break;
 205     }
 206   }
 207 }
 208
 209 void FindKeyCode(struct xkb_keymap* keyMap, xkb_keycode_t key, void* data)
 210 {
 211   KeyCodeMap* foundKeyCode = static_cast<KeyCodeMap*>(data);
 212   if(foundKeyCode->isKeyCode)
 213   {
 214     return;
 215   }
 216
 217   xkb_keysym_t        keySym  = foundKeyCode->keySym;
 218   int                 nsyms   = 0;
 219   const xkb_keysym_t* symsOut = NULL;
 220
 221   nsyms = xkb_keymap_key_get_syms_by_level(keyMap, key, 0, 0, &symsOut);
 222
 223   if(nsyms && symsOut)
 224   {
 225     if(*symsOut == keySym)
 226     {
 227       foundKeyCode->keyCode   = key;
 228       foundKeyCode->isKeyCode = true;
 229     }
 230   }
 231 }
 232
 233 /////////////////////////////////////////////////////////////////////////////////////////////////
 234 // Window Callbacks
 235 /////////////////////////////////////////////////////////////////////////////////////////////////
 236
 237 /// Called when the window iconify state is changed.
 238 static Eina_Bool EcoreEventWindowIconifyStateChanged(void* data, int type, void* event)
 239 {
 240   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 241   if(windowBase)
 242   {
 243     return windowBase->OnIconifyStateChanged(data, type, event);
 244   }
 245
 246   return ECORE_CALLBACK_PASS_ON;
 247 }
 248
 249 /// Called when the window gains focus
 250 static Eina_Bool EcoreEventWindowFocusIn(void* data, int type, void* event)
 251 {
 252   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 253   if(windowBase)
 254   {
 255     return windowBase->OnFocusIn(data, type, event);
 256   }
 257
 258   return ECORE_CALLBACK_PASS_ON;
 259 }
 260
 261 /// Called when the window loses focus
 262 static Eina_Bool EcoreEventWindowFocusOut(void* data, int type, void* event)
 263 {
 264   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 265   if(windowBase)
 266   {
 267     return windowBase->OnFocusOut(data, type, event);
 268   }
 269
 270   return ECORE_CALLBACK_PASS_ON;
 271 }
 272
 273 /// Called when the output is transformed
 274 static Eina_Bool EcoreEventOutputTransform(void* data, int type, void* event)
 275 {
 276   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 277   if(windowBase)
 278   {
 279     return windowBase->OnOutputTransform(data, type, event);
 280   }
 281
 282   return ECORE_CALLBACK_PASS_ON;
 283 }
 284
 285 /// Called when the output transform should be ignored
 286 static Eina_Bool EcoreEventIgnoreOutputTransform(void* data, int type, void* event)
 287 {
 288   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 289   if(windowBase)
 290   {
 291     return windowBase->OnIgnoreOutputTransform(data, type, event);
 292   }
 293
 294   return ECORE_CALLBACK_PASS_ON;
 295 }
 296
 297 /**
 298  * Called when rotate event is recevied.
 299  */
 300 static Eina_Bool EcoreEventRotate(void* data, int type, void* event)
 301 {
 302   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 303   if(windowBase)
 304   {
 305     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EcoreEventRotate\n");
 306     windowBase->OnRotation(data, type, event);
 307   }
 308   return ECORE_CALLBACK_PASS_ON;
 309 }
 310
 311 /**
 312  * Called when configure event is recevied.
 313  */
 314 static Eina_Bool EcoreEventConfigure(void* data, int type, void* event)
 315 {
 316   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 317   if(windowBase)
 318   {
 319     windowBase->OnConfiguration(data, type, event);
 320   }
 321   return ECORE_CALLBACK_PASS_ON;
 322 }
 323
 324 /////////////////////////////////////////////////////////////////////////////////////////////////
 325 // Touch Callbacks
 326 /////////////////////////////////////////////////////////////////////////////////////////////////
 327
 328 /**
 329  * Called when a touch down is received.
 330  */
 331 static Eina_Bool EcoreEventMouseButtonDown(void* data, int type, void* event)
 332 {
 333   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 334   if(windowBase)
 335   {
 336     windowBase->OnMouseButtonDown(data, type, event);
 337   }
 338   return ECORE_CALLBACK_PASS_ON;
 339 }
 340
 341 /**
 342  * Called when a touch up is received.
 343  */
 344 static Eina_Bool EcoreEventMouseButtonUp(void* data, int type, void* event)
 345 {
 346   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 347   if(windowBase)
 348   {
 349     windowBase->OnMouseButtonUp(data, type, event);
 350   }
 351   return ECORE_CALLBACK_PASS_ON;
 352 }
 353
 354 /**
 355  * Called when a touch motion is received.
 356  */
 357 static Eina_Bool EcoreEventMouseButtonMove(void* data, int type, void* event)
 358 {
 359   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 360   if(windowBase)
 361   {
 362     windowBase->OnMouseButtonMove(data, type, event);
 363   }
 364   return ECORE_CALLBACK_PASS_ON;
 365 }
 366
 367 /**
 368  * Called when a touch is canceled.
 369  */
 370 static Eina_Bool EcoreEventMouseButtonCancel(void* data, int type, void* event)
 371 {
 372   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 373   if(windowBase)
 374   {
 375     windowBase->OnMouseButtonCancel(data, type, event);
 376   }
 377   return ECORE_CALLBACK_PASS_ON;
 378 }
 379
 380 /**
 381  * Called when a mouse wheel is received.
 382  */
 383 static Eina_Bool EcoreEventMouseWheel(void* data, int type, void* event)
 384 {
 385   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 386   if(windowBase)
 387   {
 388     windowBase->OnMouseWheel(data, type, event);
 389   }
 390   return ECORE_CALLBACK_PASS_ON;
 391 }
 392
 393 /**
 394  * Called when a detent rotation event is recevied.
 395  */
 396 static Eina_Bool EcoreEventDetentRotation(void* data, int type, void* event)
 397 {
 398   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 399   if(windowBase)
 400   {
 401     windowBase->OnDetentRotation(data, type, event);
 402   }
 403   return ECORE_CALLBACK_PASS_ON;
 404 }
 405
 406 /////////////////////////////////////////////////////////////////////////////////////////////////
 407 // Key Callbacks
 408 /////////////////////////////////////////////////////////////////////////////////////////////////
 409
 410 /**
 411  * Called when a key down is received.
 412  */
 413 static Eina_Bool EcoreEventKeyDown(void* data, int type, void* event)
 414 {
 415   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 416   if(windowBase)
 417   {
 418     windowBase->OnKeyDown(data, type, event);
 419   }
 420   return ECORE_CALLBACK_PASS_ON;
 421 }
 422
 423 /**
 424  * Called when a key up is received.
 425  */
 426 static Eina_Bool EcoreEventKeyUp(void* data, int type, void* event)
 427 {
 428   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 429   if(windowBase)
 430   {
 431     windowBase->OnKeyUp(data, type, event);
 432   }
 433   return ECORE_CALLBACK_PASS_ON;
 434 }
 435
 436 /////////////////////////////////////////////////////////////////////////////////////////////////
 437 // Selection Callbacks
 438 /////////////////////////////////////////////////////////////////////////////////////////////////
 439
 440 /**
 441  * Called when the source window notifies us the content in clipboard is selected.
 442  */
 443 static Eina_Bool EcoreEventDataSend(void* data, int type, void* event)
 444 {
 445   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 446   if(windowBase)
 447   {
 448     windowBase->OnDataSend(data, type, event);
 449   }
 450   return ECORE_CALLBACK_PASS_ON;
 451 }
 452
 453 /**
 454  * Called when the source window sends us about the selected content.
 455  * For example, when item is selected in the clipboard.
 456  */
 457 static Eina_Bool EcoreEventDataReceive(void* data, int type, void* event)
 458 {
 459   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 460   if(windowBase)
 461   {
 462     windowBase->OnDataReceive(data, type, event);
 463   }
 464   return ECORE_CALLBACK_PASS_ON;
 465 }
 466
 467 /////////////////////////////////////////////////////////////////////////////////////////////////
 468 // Effect Start/End Callbacks
 469 /////////////////////////////////////////////////////////////////////////////////////////////////
 470
 471 /**
 472  * Called when transition animation of the window's shown/hidden is started by window manager.
 473  */
 474 static Eina_Bool EcoreEventEffectStart(void* data, int type, void* event)
 475 {
 476   WindowBaseEcoreWl2*           windowBase  = static_cast<WindowBaseEcoreWl2*>(data);
 477   Ecore_Wl2_Event_Effect_Start* effectStart = static_cast<Ecore_Wl2_Event_Effect_Start*>(event);
 478   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventEffectStart, effect type[ %d ]\n", effectStart->type);
 479   if(windowBase)
 480   {
 481     if(effectStart->type < 3) // only under restack
 482     {
 483       windowBase->OnTransitionEffectEvent(WindowEffectState::START, static_cast<WindowEffectType>(effectStart->type));
 484     }
 485   }
 486   return ECORE_CALLBACK_PASS_ON;
 487 }
 488
 489 /**
 490  * Called when transition animation of the window's shown/hidden is ended by window manager.
 491  */
 492 static Eina_Bool EcoreEventEffectEnd(void* data, int type, void* event)
 493 {
 494   Ecore_Wl2_Event_Effect_Start* effectEnd  = static_cast<Ecore_Wl2_Event_Effect_Start*>(event);
 495   WindowBaseEcoreWl2*           windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 496   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventEffectEnd, effect type[ %d ]\n", effectEnd->type);
 497   if(windowBase)
 498   {
 499     if(effectEnd->type < 3) // only under restack
 500     {
 501       windowBase->OnTransitionEffectEvent(WindowEffectState::END, static_cast<WindowEffectType>(effectEnd->type));
 502     }
 503   }
 504   return ECORE_CALLBACK_PASS_ON;
 505 }
 506
 507 /////////////////////////////////////////////////////////////////////////////////////////////////
 508 // Keyboard Repeat Settings Changed Callbacks
 509 /////////////////////////////////////////////////////////////////////////////////////////////////
 510
 511 static Eina_Bool EcoreEventSeatKeyboardRepeatChanged(void* data, int type, void* event)
 512 {
 513   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 514   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventSeatKeyboardRepeatChanged, id[ %d ]\n", static_cast<Ecore_Wl2_Event_Seat_Keyboard_Repeat_Changed*>(event)->id);
 515   if(windowBase)
 516   {
 517     windowBase->OnKeyboardRepeatSettingsChanged();
 518   }
 519
 520   return ECORE_CALLBACK_RENEW;
 521 }
 522
 523 /////////////////////////////////////////////////////////////////////////////////////////////////
 524 // Keymap Changed Callbacks
 525 /////////////////////////////////////////////////////////////////////////////////////////////////
 526
 527 static Eina_Bool EcoreEventSeatKeymapChanged(void* data, int type, void* event)
 528 {
 529   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 530   if(windowBase)
 531   {
 532     windowBase->KeymapChanged(data, type, event);
 533   }
 534
 535   return ECORE_CALLBACK_RENEW;
 536 }
 537
 538 /////////////////////////////////////////////////////////////////////////////////////////////////
 539 // Font Callbacks
 540 /////////////////////////////////////////////////////////////////////////////////////////////////
 541
 542 #if defined(VCONF_ENABLED)
 543 /**
 544  * Called when a font name is changed.
 545  */
 546 static void VconfNotifyFontNameChanged(keynode_t* node, void* data)
 547 {
 548   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 549   if(windowBase)
 550   {
 551     windowBase->OnFontNameChanged();
 552   }
 553 }
 554
 555 /**
 556  * Called when a font size is changed.
 557  */
 558 static void VconfNotifyFontSizeChanged(keynode_t* node, void* data)
 559 {
 560   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 561   if(windowBase)
 562   {
 563     windowBase->OnFontSizeChanged();
 564   }
 565 }
 566 #endif
 567
 568 /////////////////////////////////////////////////////////////////////////////////////////////////
 569 // Window Redraw Request Event Callbacks
 570 /////////////////////////////////////////////////////////////////////////////////////////////////
 571
 572 static Eina_Bool EcoreEventWindowRedrawRequest(void* data, int type, void* event)
 573 {
 574   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 575   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventWindowRedrawRequest, window[ %d ]\n", static_cast<Ecore_Wl2_Event_Window_Redraw_Request*>(event)->win);
 576   if(windowBase)
 577   {
 578     windowBase->OnEcoreEventWindowRedrawRequest();
 579   }
 580
 581   return ECORE_CALLBACK_RENEW;
 582 }
 583
 584 /////////////////////////////////////////////////////////////////////////////////////////////////
 585 // Window Auxiliary Message Callbacks
 586 /////////////////////////////////////////////////////////////////////////////////////////////////
 587 static Eina_Bool EcoreEventWindowAuxiliaryMessage(void* data, int type, void* event)
 588 {
 589   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 590   if(windowBase)
 591   {
 592     windowBase->OnEcoreEventWindowAuxiliaryMessage(event);
 593   }
 594   return ECORE_CALLBACK_RENEW;
 595 }
 596
 597 static void RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
 598 {
 599   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 600   if(windowBase)
 601   {
 602     windowBase->RegistryGlobalCallback(data, registry, name, interface, version);
 603   }
 604 }
 605
 606 static void RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
 607 {
 608   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 609   if(windowBase)
 610   {
 611     windowBase->RegistryGlobalCallbackRemove(data, registry, id);
 612   }
 613 }
 614
 615 static void TizenPolicyConformant(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t isConformant)
 616 {
 617 }
 618
 619 static void TizenPolicyConformantArea(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
 620 {
 621 }
 622
 623 static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
 624 {
 625   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 626   if(windowBase)
 627   {
 628     windowBase->TizenPolicyNotificationChangeDone(data, tizenPolicy, surface, level, state);
 629   }
 630 }
 631
 632 static void TizenPolicyTransientForDone(void* data, struct tizen_policy* tizenPolicy, uint32_t childId)
 633 {
 634 }
 635
 636 static void TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
 637 {
 638   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 639   if(windowBase)
 640   {
 641     windowBase->TizenPolicyScreenModeChangeDone(data, tizenPolicy, surface, mode, state);
 642   }
 643 }
 644
 645 static void TizenPolicyIconifyStateChanged(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t iconified, uint32_t force)
 646 {
 647 }
 648
 649 static void TizenPolicySupportedAuxiliaryHints(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, struct wl_array* hints, uint32_t numNints)
 650 {
 651 }
 652
 653 static void TizenPolicyAllowedAuxiliaryHint(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int id)
 654 {
 655 }
 656
 657 static void TizenPolicyAuxiliaryMessage(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, const char* key, const char* val, struct wl_array* options)
 658 {
 659 }
 660
 661 static void TizenPolicyConformantRegion(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial)
 662 {
 663 }
 664
 665 static void DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
 666 {
 667   WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
 668   if(windowBase)
 669   {
 670     windowBase->DisplayPolicyBrightnessChangeDone(data, displayPolicy, surface, brightness, state);
 671   }
 672 }
 673
 674 const struct wl_registry_listener registryListener =
 675   {
 676     RegistryGlobalCallback,
 677     RegistryGlobalCallbackRemove};
 678
 679 const struct tizen_policy_listener tizenPolicyListener =
 680   {
 681     TizenPolicyConformant,
 682     TizenPolicyConformantArea,
 683     TizenPolicyNotificationChangeDone,
 684     TizenPolicyTransientForDone,
 685     TizenPolicyScreenModeChangeDone,
 686     TizenPolicyIconifyStateChanged,
 687     TizenPolicySupportedAuxiliaryHints,
 688     TizenPolicyAllowedAuxiliaryHint,
 689     TizenPolicyAuxiliaryMessage,
 690     TizenPolicyConformantRegion};
 691
 692 const struct tizen_display_policy_listener tizenDisplayPolicyListener =
 693   {
 694     DisplayPolicyBrightnessChangeDone};
 695
 696 } // unnamed namespace
 697
 698 WindowBaseEcoreWl2::WindowBaseEcoreWl2(Dali::PositionSize positionSize, Any surface, bool isTransparent)
 699 : mEcoreEventHandler(),
 700   mEcoreWindow(nullptr),
 701   mWlSurface(nullptr),
 702   mWlInputPanel(nullptr),
 703   mWlOutput(nullptr),
 704   mWlInputPanelSurface(nullptr),
 705   mEglWindow(nullptr),
 706   mDisplay(nullptr),
 707   mEventQueue(nullptr),
 708   mTizenPolicy(nullptr),
 709   mTizenDisplayPolicy(nullptr),
 710   mKeyMap(nullptr),
 711   mSupportedAuxiliaryHints(),
 712   mWindowPositionSize(positionSize),
 713   mAuxiliaryHints(),
 714   mType(WindowType::NORMAL),
 715   mNotificationLevel(-1),
 716   mScreenOffMode(0),
 717   mBrightness(0),
 718   mWindowRotationAngle(0),
 719   mScreenRotationAngle(0),
 720   mSupportedPreProtation(0),
 721   mScreenWidth(0),
 722   mScreenHeight(0),
 723   mNotificationChangeState(0),
 724   mScreenOffModeChangeState(0),
 725   mBrightnessChangeState(0),
 726   mLastSubmittedMoveResizeSerial(0),
 727   mMoveResizeSerial(0),
 728   mNotificationLevelChangeDone(true),
 729   mScreenOffModeChangeDone(true),
 730   mVisible(true),
 731   mOwnSurface(false),
 732   mBrightnessChangeDone(true)
 733 {
 734   Initialize(positionSize, surface, isTransparent);
 735 }
 736
 737 WindowBaseEcoreWl2::~WindowBaseEcoreWl2()
 738 {
 739 #if defined(VCONF_ENABLED)
 740   vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged);
 741   vconf_ignore_key_changed(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged);
 742 #endif
 743
 744   for(Dali::Vector<Ecore_Event_Handler*>::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter)
 745   {
 746     ecore_event_handler_del(*iter);
 747   }
 748   mEcoreEventHandler.Clear();
 749
 750   if(mEventQueue)
 751   {
 752     wl_event_queue_destroy(mEventQueue);
 753   }
 754
 755   mSupportedAuxiliaryHints.clear();
 756   mAuxiliaryHints.clear();
 757
 758   if(mEglWindow != NULL)
 759   {
 760     wl_egl_window_destroy(mEglWindow);
 761     mEglWindow = NULL;
 762   }
 763
 764   if(mOwnSurface)
 765   {
 766     ecore_wl2_window_free(mEcoreWindow);
 767
 768     WindowSystem::Shutdown();
 769   }
 770 }
 771
 772 void WindowBaseEcoreWl2::Initialize(PositionSize positionSize, Any surface, bool isTransparent)
 773 {
 774   if(surface.Empty() == false)
 775   {
 776     // check we have a valid type
 777     DALI_ASSERT_ALWAYS((surface.GetType() == typeid(Ecore_Wl2_Window*)) && "Surface type is invalid");
 778
 779     mEcoreWindow = AnyCast<Ecore_Wl2_Window*>(surface);
 780   }
 781   else
 782   {
 783     // we own the surface about to created
 784     WindowSystem::Initialize();
 785
 786     mOwnSurface = true;
 787     CreateWindow(positionSize);
 788   }
 789
 790   mWlSurface = ecore_wl2_window_surface_get(mEcoreWindow);
 791
 792   SetTransparency(isTransparent);
 793
 794   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this));
 795   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this));
 796   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this));
 797   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this));
 798   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_IGNORE_OUTPUT_TRANSFORM, EcoreEventIgnoreOutputTransform, this));
 799
 800   // Register Rotate event
 801   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_ROTATE, EcoreEventRotate, this));
 802
 803   // Register Configure event
 804   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_CONFIGURE, EcoreEventConfigure, this));
 805
 806   // Register Touch events
 807   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, EcoreEventMouseButtonDown, this));
 808   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, EcoreEventMouseButtonUp, this));
 809   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, EcoreEventMouseButtonMove, this));
 810   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, EcoreEventMouseButtonCancel, this));
 811
 812   // Register Mouse wheel events
 813   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL, EcoreEventMouseWheel, this));
 814
 815   // Register Detent event
 816   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_DETENT_ROTATE, EcoreEventDetentRotation, this));
 817
 818   // Register Key events
 819   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, EcoreEventKeyDown, this));
 820   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_KEY_UP, EcoreEventKeyUp, this));
 821
 822   // Register Selection event - clipboard selection
 823   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_SEND, EcoreEventDataSend, this));
 824   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SELECTION_DATA_READY, EcoreEventDataReceive, this));
 825
 826   // Register Effect Start/End event
 827   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_EFFECT_START, EcoreEventEffectStart, this));
 828   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_EFFECT_END, EcoreEventEffectEnd, this));
 829
 830   // Register Keyboard repeat event
 831   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_KEYBOARD_REPEAT_CHANGED, EcoreEventSeatKeyboardRepeatChanged, this));
 832
 833   // Register Window redraw request event
 834   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_REDRAW_REQUEST, EcoreEventWindowRedrawRequest, this));
 835
 836   // Register Window auxiliary event
 837   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_AUX_MESSAGE, EcoreEventWindowAuxiliaryMessage, this));
 838
 839 #if defined(VCONF_ENABLED)
 840   // Register Vconf notify - font name and size
 841   vconf_notify_key_changed_for_ui_thread(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this);
 842   vconf_notify_key_changed_for_ui_thread(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this);
 843 #endif
 844
 845   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
 846   mDisplay                   = ecore_wl2_display_get(display);
 847
 848   if(mDisplay)
 849   {
 850     wl_display* displayWrapper = static_cast<wl_display*>(wl_proxy_create_wrapper(mDisplay));
 851     if(displayWrapper)
 852     {
 853       mEventQueue = wl_display_create_queue(mDisplay);
 854       if(mEventQueue)
 855       {
 856         wl_proxy_set_queue(reinterpret_cast<wl_proxy*>(displayWrapper), mEventQueue);
 857
 858         wl_registry* registry = wl_display_get_registry(displayWrapper);
 859         wl_registry_add_listener(registry, &registryListener, this);
 860       }
 861
 862       wl_proxy_wrapper_destroy(displayWrapper);
 863     }
 864   }
 865
 866   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(display);
 867
 868   if(ecoreWlInput)
 869   {
 870     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
 871
 872     mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this));
 873   }
 874
 875   // get auxiliary hint
 876   Eina_List* hints = ecore_wl2_window_aux_hints_supported_get(mEcoreWindow);
 877   if(hints)
 878   {
 879     Eina_List* l    = NULL;
 880     char*      hint = NULL;
 881
 882     for(l = hints, (hint = static_cast<char*>(eina_list_data_get(l))); l; l = eina_list_next(l), (hint = static_cast<char*>(eina_list_data_get(l))))
 883     {
 884       mSupportedAuxiliaryHints.push_back(hint);
 885
 886       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::Initialize: %s\n", hint);
 887     }
 888   }
 889 }
 890
 891 Eina_Bool WindowBaseEcoreWl2::OnIconifyStateChanged(void* data, int type, void* event)
 892 {
 893   Ecore_Wl2_Event_Window_Iconify_State_Change* iconifyChangedEvent(static_cast<Ecore_Wl2_Event_Window_Iconify_State_Change*>(event));
 894   Eina_Bool                                    handled(ECORE_CALLBACK_PASS_ON);
 895
 896   if(iconifyChangedEvent->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 897   {
 898     if(iconifyChangedEvent->iconified == EINA_TRUE)
 899     {
 900       mIconifyChangedSignal.Emit(true);
 901     }
 902     else
 903     {
 904       mIconifyChangedSignal.Emit(false);
 905     }
 906     handled = ECORE_CALLBACK_DONE;
 907   }
 908
 909   return handled;
 910 }
 911
 912 Eina_Bool WindowBaseEcoreWl2::OnFocusIn(void* data, int type, void* event)
 913 {
 914   Ecore_Wl2_Event_Focus_In* focusInEvent(static_cast<Ecore_Wl2_Event_Focus_In*>(event));
 915
 916   if(focusInEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 917   {
 918     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n");
 919
 920     mFocusChangedSignal.Emit(true);
 921   }
 922
 923   return ECORE_CALLBACK_PASS_ON;
 924 }
 925
 926 Eina_Bool WindowBaseEcoreWl2::OnFocusOut(void* data, int type, void* event)
 927 {
 928   Ecore_Wl2_Event_Focus_Out* focusOutEvent(static_cast<Ecore_Wl2_Event_Focus_Out*>(event));
 929
 930   if(focusOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 931   {
 932     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n");
 933
 934     mFocusChangedSignal.Emit(false);
 935   }
 936
 937   return ECORE_CALLBACK_PASS_ON;
 938 }
 939
 940 Eina_Bool WindowBaseEcoreWl2::OnOutputTransform(void* data, int type, void* event)
 941 {
 942   Ecore_Wl2_Event_Output_Transform* transformEvent(static_cast<Ecore_Wl2_Event_Output_Transform*>(event));
 943
 944   if(transformEvent->output == ecore_wl2_window_output_find(mEcoreWindow))
 945   {
 946     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
 947
 948     mScreenRotationAngle = GetScreenRotationAngle();
 949
 950     mOutputTransformedSignal.Emit();
 951   }
 952
 953   return ECORE_CALLBACK_PASS_ON;
 954 }
 955
 956 Eina_Bool WindowBaseEcoreWl2::OnIgnoreOutputTransform(void* data, int type, void* event)
 957 {
 958   Ecore_Wl2_Event_Ignore_Output_Transform* ignoreTransformEvent(static_cast<Ecore_Wl2_Event_Ignore_Output_Transform*>(event));
 959
 960   if(ignoreTransformEvent->win == mEcoreWindow)
 961   {
 962     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
 963
 964     mScreenRotationAngle = GetScreenRotationAngle();
 965
 966     mOutputTransformedSignal.Emit();
 967   }
 968
 969   return ECORE_CALLBACK_PASS_ON;
 970 }
 971
 972 void WindowBaseEcoreWl2::OnRotation(void* data, int type, void* event)
 973 {
 974   Ecore_Wl2_Event_Window_Rotation* ev(static_cast<Ecore_Wl2_Event_Window_Rotation*>(event));
 975
 976   if(ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
 977   {
 978     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h);
 979
 980     RotationEvent rotationEvent;
 981     rotationEvent.angle     = ev->angle;
 982     rotationEvent.winResize = 0;
 983
 984     if(ev->w == 0 || ev->h == 0)
 985     {
 986       // When rotation event does not have the window width or height,
 987       // previous DALi side window's size are used.
 988       ev->w = mWindowPositionSize.width;
 989       ev->h = mWindowPositionSize.height;
 990     }
 991
 992     mWindowRotationAngle = ev->angle;
 993
 994     mWindowPositionSize.width  = ev->w;
 995     mWindowPositionSize.height = ev->h;
 996
 997     PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(mWindowPositionSize);
 998
 999     rotationEvent.x      = newPositionSize.x;
1000     rotationEvent.y      = newPositionSize.y;
1001     rotationEvent.width  = newPositionSize.width;
1002     rotationEvent.height = newPositionSize.height;
1003
1004     mRotationSignal.Emit(rotationEvent);
1005   }
1006 }
1007
1008 void WindowBaseEcoreWl2::OnConfiguration(void* data, int type, void* event)
1009 {
1010   Ecore_Wl2_Event_Window_Configure* ev(static_cast<Ecore_Wl2_Event_Window_Configure*>(event));
1011
1012   if(ev && ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1013   {
1014     // Note: To comply with the wayland protocol, Dali should make an ack_configure
1015     // by calling ecore_wl2_window_commit
1016
1017     int tempWidth  = ev->w;
1018     int tempHeight = ev->h;
1019
1020     // Initialize with previous size for skip resize when new size is 0.
1021     // When window is just moved or window is resized by client application,
1022     // The configure notification event's size will be 0.
1023     // If new size is 0, the resized work should be skip.
1024     int  newWidth    = mWindowPositionSize.width;
1025     int  newHeight   = mWindowPositionSize.height;
1026     bool windowMoved = false, windowResized = false;
1027
1028     if(ev->x != mWindowPositionSize.x || ev->y != mWindowPositionSize.y)
1029     {
1030       windowMoved = true;
1031     }
1032
1033     if(tempWidth != 0 && tempHeight != 0 && (tempWidth != mWindowPositionSize.width || tempHeight != mWindowPositionSize.height))
1034     {
1035       windowResized = true;
1036       newWidth      = tempWidth;
1037       newHeight     = tempHeight;
1038     }
1039
1040     if(windowMoved || windowResized)
1041     {
1042       mWindowPositionSize.x      = ev->x;
1043       mWindowPositionSize.y      = ev->y;
1044       mWindowPositionSize.width  = newWidth;
1045       mWindowPositionSize.height = newHeight;
1046       DALI_LOG_RELEASE_INFO("Update position & resize signal by server, current angle [%d] x[%d] y[%d] w[%d] h[%d]\n", mWindowRotationAngle, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1047
1048       ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1049
1050       Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(mWindowPositionSize);
1051       mUpdatePositionSizeSignal.Emit(newPositionSize);
1052     }
1053
1054     mMaximizeChangedSignal.Emit(static_cast<bool>(ev->states & ECORE_WL2_WINDOW_STATE_MAXIMIZED));
1055
1056     ecore_wl2_window_commit(mEcoreWindow, EINA_FALSE);
1057   }
1058 }
1059
1060 void WindowBaseEcoreWl2::OnMouseButtonDown(void* data, int type, void* event)
1061 {
1062   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1063
1064   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1065   {
1066     Device::Class::Type    deviceClass;
1067     Device::Subclass::Type deviceSubclass;
1068
1069     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1070     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1071
1072     PointState::Type state(PointState::DOWN);
1073
1074     if(deviceClass != Device::Class::Type::MOUSE)
1075     {
1076       // Check if the buttons field is set and ensure it's the primary touch button.
1077       // If this event was triggered by buttons other than the primary button (used for touch), then
1078       // just send an interrupted event to Core.
1079       if(touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID))
1080       {
1081         state = PointState::INTERRUPTED;
1082       }
1083     }
1084
1085     Integration::Point point;
1086     point.SetDeviceId(touchEvent->multi.device);
1087     point.SetState(state);
1088     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1089     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1090     point.SetPressure(touchEvent->multi.pressure);
1091     point.SetAngle(Degree(touchEvent->multi.angle));
1092     point.SetDeviceClass(deviceClass);
1093     point.SetDeviceSubclass(deviceSubclass);
1094     point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
1095
1096     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1097   }
1098 }
1099
1100 void WindowBaseEcoreWl2::OnMouseButtonUp(void* data, int type, void* event)
1101 {
1102   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1103
1104   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1105   {
1106     Device::Class::Type    deviceClass;
1107     Device::Subclass::Type deviceSubclass;
1108
1109     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1110     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1111
1112     Integration::Point point;
1113     point.SetDeviceId(touchEvent->multi.device);
1114     point.SetState(PointState::UP);
1115     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1116     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1117     point.SetPressure(touchEvent->multi.pressure);
1118     point.SetAngle(Degree(touchEvent->multi.angle));
1119     point.SetDeviceClass(deviceClass);
1120     point.SetDeviceSubclass(deviceSubclass);
1121     point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
1122
1123     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1124   }
1125 }
1126
1127 void WindowBaseEcoreWl2::OnMouseButtonMove(void* data, int type, void* event)
1128 {
1129   Ecore_Event_Mouse_Move* touchEvent = static_cast<Ecore_Event_Mouse_Move*>(event);
1130
1131   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1132   {
1133     Device::Class::Type    deviceClass;
1134     Device::Subclass::Type deviceSubclass;
1135
1136     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1137     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1138
1139     Integration::Point point;
1140     point.SetDeviceId(touchEvent->multi.device);
1141     point.SetState(PointState::MOTION);
1142     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1143     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1144     point.SetPressure(touchEvent->multi.pressure);
1145     point.SetAngle(Degree(touchEvent->multi.angle));
1146     point.SetDeviceClass(deviceClass);
1147     point.SetDeviceSubclass(deviceSubclass);
1148
1149     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1150   }
1151 }
1152
1153 void WindowBaseEcoreWl2::OnMouseButtonCancel(void* data, int type, void* event)
1154 {
1155   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1156
1157   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1158   {
1159     Integration::Point point;
1160     point.SetDeviceId(touchEvent->multi.device);
1161     point.SetState(PointState::INTERRUPTED);
1162     point.SetScreenPosition(Vector2(0.0f, 0.0f));
1163
1164     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1165
1166     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseButtonCancel\n");
1167   }
1168 }
1169
1170 void WindowBaseEcoreWl2::OnMouseWheel(void* data, int type, void* event)
1171 {
1172   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast<Ecore_Event_Mouse_Wheel*>(event);
1173
1174   if(mouseWheelEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1175   {
1176     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);
1177
1178     Integration::WheelEvent wheelEvent(Integration::WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp);
1179
1180     mWheelEventSignal.Emit(wheelEvent);
1181   }
1182 }
1183
1184 void WindowBaseEcoreWl2::OnDetentRotation(void* data, int type, void* event)
1185 {
1186   Ecore_Event_Detent_Rotate* detentEvent = static_cast<Ecore_Event_Detent_Rotate*>(event);
1187
1188   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n");
1189
1190   int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
1191
1192   Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, detentEvent->direction, 0, Vector2(0.0f, 0.0f), clockwise, detentEvent->timestamp);
1193
1194   mWheelEventSignal.Emit(wheelEvent);
1195 }
1196
1197 void WindowBaseEcoreWl2::OnKeyDown(void* data, int type, void* event)
1198 {
1199   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1200
1201   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1202   {
1203     std::string keyName(keyEvent->keyname);
1204     std::string logicalKey("");
1205     std::string keyString("");
1206     std::string compose("");
1207
1208 #ifdef TRACE_ENABLED
1209     std::ostringstream stream;
1210     if(gTraceFilter->IsTraceEnabled())
1211     {
1212       stream << "DALI_ON_KEY_DOWN [" << keyName << "]";
1213       DALI_TRACE_BEGIN(gTraceFilter, stream.str().c_str());
1214     }
1215 #endif
1216
1217     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1218     if(keyEvent->compose)
1219     {
1220       compose = keyEvent->compose;
1221     }
1222
1223     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1224     if(keyEvent->key)
1225     {
1226       logicalKey = keyEvent->key;
1227     }
1228
1229     int keyCode = 0;
1230     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1231
1232     if(keyCode == 0)
1233     {
1234       // Get a specific key code from dali key look up table.
1235       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1236     }
1237
1238     keyCode = (keyCode == -1) ? 0 : keyCode;
1239     int           modifier(keyEvent->modifiers);
1240     unsigned long time = keyEvent->timestamp;
1241     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1242     {
1243       keyCode = atoi(keyEvent->keyname + 8);
1244     }
1245
1246     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1247     if(keyEvent->string)
1248     {
1249       keyString = keyEvent->string;
1250     }
1251
1252     std::string            deviceName;
1253     Device::Class::Type    deviceClass;
1254     Device::Subclass::Type deviceSubclass;
1255
1256     GetDeviceName(keyEvent, deviceName);
1257     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1258     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1259
1260     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass);
1261
1262     mKeyEventSignal.Emit(keyEvent);
1263
1264 #ifdef TRACE_ENABLED
1265     if(gTraceFilter->IsTraceEnabled())
1266     {
1267       DALI_TRACE_END(gTraceFilter, stream.str().c_str());
1268     }
1269 #endif
1270   }
1271 }
1272
1273 void WindowBaseEcoreWl2::OnKeyUp(void* data, int type, void* event)
1274 {
1275   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1276
1277   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1278   {
1279 #if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
1280     // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
1281     if(keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL)
1282     {
1283       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp: This event flag indicates the event is canceled. \n");
1284       return;
1285     }
1286 #endif // Since ecore 1.23 version
1287
1288     std::string keyName(keyEvent->keyname);
1289     std::string logicalKey("");
1290     std::string keyString("");
1291     std::string compose("");
1292
1293 #ifdef TRACE_ENABLED
1294     std::ostringstream stream;
1295     if(gTraceFilter->IsTraceEnabled())
1296     {
1297       stream << "DALI_ON_KEY_UP [" << keyName << "]";
1298       DALI_TRACE_BEGIN(gTraceFilter, stream.str().c_str());
1299     }
1300 #endif
1301
1302     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1303     if(keyEvent->compose)
1304     {
1305       compose = keyEvent->compose;
1306     }
1307
1308     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1309     if(keyEvent->key)
1310     {
1311       logicalKey = keyEvent->key;
1312     }
1313
1314     int keyCode = 0;
1315     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1316
1317     if(keyCode == 0)
1318     {
1319       // Get a specific key code from dali key look up table.
1320       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1321     }
1322
1323     keyCode = (keyCode == -1) ? 0 : keyCode;
1324     int           modifier(keyEvent->modifiers);
1325     unsigned long time = keyEvent->timestamp;
1326     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1327     {
1328       keyCode = atoi(keyEvent->keyname + 8);
1329     }
1330
1331     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1332     if(keyEvent->string)
1333     {
1334       keyString = keyEvent->string;
1335     }
1336
1337     std::string            deviceName;
1338     Device::Class::Type    deviceClass;
1339     Device::Subclass::Type deviceSubclass;
1340
1341     GetDeviceName(keyEvent, deviceName);
1342     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1343     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1344
1345     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
1346
1347     mKeyEventSignal.Emit(keyEvent);
1348
1349 #ifdef TRACE_ENABLED
1350     if(gTraceFilter->IsTraceEnabled())
1351     {
1352       DALI_TRACE_END(gTraceFilter, stream.str().c_str());
1353     }
1354 #endif
1355   }
1356 }
1357
1358 void WindowBaseEcoreWl2::OnDataSend(void* data, int type, void* event)
1359 {
1360   mSelectionDataSendSignal.Emit(event);
1361 }
1362
1363 void WindowBaseEcoreWl2::OnDataReceive(void* data, int type, void* event)
1364 {
1365   mSelectionDataReceivedSignal.Emit(event);
1366 }
1367
1368 void WindowBaseEcoreWl2::OnFontNameChanged()
1369 {
1370   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
1371 }
1372
1373 void WindowBaseEcoreWl2::OnFontSizeChanged()
1374 {
1375   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
1376 }
1377
1378 void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
1379 {
1380   mTransitionEffectEventSignal.Emit(state, type);
1381 }
1382
1383 void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
1384 {
1385   mKeyboardRepeatSettingsChangedSignal.Emit();
1386 }
1387
1388 void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
1389 {
1390   mWindowRedrawRequestSignal.Emit();
1391 }
1392
1393 void WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage(void* event)
1394 {
1395   Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
1396   if(message)
1397   {
1398     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, key:%s, value:%s \n", message->key, message->val);
1399     std::string           key(message->key);
1400     std::string           value(message->val);
1401     Dali::Property::Array options;
1402
1403     if(message->options)
1404     {
1405       Eina_List* l;
1406       void*      data;
1407       EINA_LIST_FOREACH(message->options, l, data)
1408       {
1409         DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, option: %s\n", (char*)data);
1410         std::string option(static_cast<char*>(data));
1411         options.Add(option);
1412       }
1413     }
1414
1415     mAuxiliaryMessageSignal.Emit(key, value, options);
1416   }
1417 }
1418
1419 void WindowBaseEcoreWl2::KeymapChanged(void* data, int type, void* event)
1420 {
1421   Ecore_Wl2_Event_Seat_Keymap_Changed* changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>(event);
1422   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id);
1423   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(changed->display);
1424   if(ecoreWlInput)
1425   {
1426     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
1427   }
1428 }
1429
1430 void WindowBaseEcoreWl2::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
1431 {
1432   if(strcmp(interface, tizen_policy_interface.name) == 0)
1433   {
1434     uint32_t clientVersion = std::min(version, MAX_TIZEN_CLIENT_VERSION);
1435
1436     mTizenPolicy = static_cast<tizen_policy*>(wl_registry_bind(registry, name, &tizen_policy_interface, clientVersion));
1437     if(!mTizenPolicy)
1438     {
1439       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n");
1440       return;
1441     }
1442
1443     tizen_policy_add_listener(mTizenPolicy, &tizenPolicyListener, data);
1444
1445     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n");
1446   }
1447   else if(strcmp(interface, tizen_display_policy_interface.name) == 0)
1448   {
1449     mTizenDisplayPolicy = static_cast<tizen_display_policy*>(wl_registry_bind(registry, name, &tizen_display_policy_interface, version));
1450     if(!mTizenDisplayPolicy)
1451     {
1452       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n");
1453       return;
1454     }
1455
1456     tizen_display_policy_add_listener(mTizenDisplayPolicy, &tizenDisplayPolicyListener, data);
1457
1458     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n");
1459   }
1460 }
1461
1462 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
1463 {
1464   mTizenPolicy        = NULL;
1465   mTizenDisplayPolicy = NULL;
1466 }
1467
1468 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
1469 {
1470   mNotificationLevel           = level;
1471   mNotificationChangeState     = state;
1472   mNotificationLevelChangeDone = true;
1473
1474   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state);
1475 }
1476
1477 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
1478 {
1479   mScreenOffMode            = mode;
1480   mScreenOffModeChangeState = state;
1481   mScreenOffModeChangeDone  = true;
1482
1483   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state);
1484 }
1485
1486 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
1487 {
1488   mBrightness            = brightness;
1489   mBrightnessChangeState = state;
1490   mBrightnessChangeDone  = true;
1491
1492   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state);
1493 }
1494
1495 void WindowBaseEcoreWl2::GetKeyCode(std::string keyName, int32_t& keyCode)
1496 {
1497   xkb_keysym_t sym = XKB_KEY_NoSymbol;
1498   KeyCodeMap   foundKeyCode;
1499
1500   sym = xkb_keysym_from_name(keyName.c_str(), XKB_KEYSYM_NO_FLAGS);
1501   if(sym == XKB_KEY_NoSymbol)
1502   {
1503     DALI_LOG_ERROR("Failed to get keysym in WindowBaseEcoreWl2\n");
1504     return;
1505   }
1506
1507   foundKeyCode.keySym    = sym;
1508   foundKeyCode.isKeyCode = false;
1509   xkb_keymap_key_for_each(mKeyMap, FindKeyCode, &foundKeyCode);
1510   keyCode = static_cast<int32_t>(foundKeyCode.keyCode);
1511 }
1512
1513 Any WindowBaseEcoreWl2::GetNativeWindow()
1514 {
1515   return mEcoreWindow;
1516 }
1517
1518 int WindowBaseEcoreWl2::GetNativeWindowId()
1519 {
1520   return ecore_wl2_window_id_get(mEcoreWindow);
1521 }
1522
1523 std::string WindowBaseEcoreWl2::GetNativeWindowResourceId()
1524 {
1525 #ifdef OVER_TIZEN_VERSION_7
1526   return std::to_string(ecore_wl2_window_resource_id_get(mEcoreWindow));
1527 #else
1528   return std::string();
1529 #endif
1530 }
1531
1532 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow(int width, int height)
1533 {
1534   int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
1535   if(totalAngle == 90 || totalAngle == 270)
1536   {
1537     mEglWindow = wl_egl_window_create(mWlSurface, height, width);
1538   }
1539   else
1540   {
1541     mEglWindow = wl_egl_window_create(mWlSurface, width, height);
1542   }
1543
1544   return static_cast<EGLNativeWindowType>(mEglWindow);
1545 }
1546
1547 void WindowBaseEcoreWl2::DestroyEglWindow()
1548 {
1549   if(mEglWindow != NULL)
1550   {
1551     wl_egl_window_destroy(mEglWindow);
1552     mEglWindow = NULL;
1553   }
1554 }
1555
1556 void WindowBaseEcoreWl2::SetEglWindowRotation(int angle)
1557 {
1558   wl_egl_window_tizen_rotation rotation;
1559
1560   switch(angle)
1561   {
1562     case 0:
1563     {
1564       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1565       break;
1566     }
1567     case 90:
1568     {
1569       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
1570       break;
1571     }
1572     case 180:
1573     {
1574       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
1575       break;
1576     }
1577     case 270:
1578     {
1579       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
1580       break;
1581     }
1582     default:
1583     {
1584       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1585       break;
1586     }
1587   }
1588
1589   wl_egl_window_tizen_set_rotation(mEglWindow, rotation);
1590 }
1591
1592 void WindowBaseEcoreWl2::SetEglWindowBufferTransform(int angle)
1593 {
1594   wl_output_transform bufferTransform;
1595
1596   switch(angle)
1597   {
1598     case 0:
1599     {
1600       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1601       break;
1602     }
1603     case 90:
1604     {
1605       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1606       break;
1607     }
1608     case 180:
1609     {
1610       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1611       break;
1612     }
1613     case 270:
1614     {
1615       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1616       break;
1617     }
1618     default:
1619     {
1620       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1621       break;
1622     }
1623   }
1624
1625   DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_buffer_transform() with buffer Transform [%d]\n", bufferTransform);
1626   wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
1627 }
1628
1629 void WindowBaseEcoreWl2::SetEglWindowTransform(int angle)
1630 {
1631   wl_output_transform windowTransform;
1632
1633   switch(angle)
1634   {
1635     case 0:
1636     {
1637       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1638       break;
1639     }
1640     case 90:
1641     {
1642       windowTransform = WL_OUTPUT_TRANSFORM_90;
1643       break;
1644     }
1645     case 180:
1646     {
1647       windowTransform = WL_OUTPUT_TRANSFORM_180;
1648       break;
1649     }
1650     case 270:
1651     {
1652       windowTransform = WL_OUTPUT_TRANSFORM_270;
1653       break;
1654     }
1655     default:
1656     {
1657       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1658       break;
1659     }
1660   }
1661
1662   DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_window_transform() with window Transform [%d]\n", windowTransform);
1663   wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
1664 }
1665
1666 void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
1667 {
1668   DALI_LOG_RELEASE_INFO("wl_egl_window_resize(), (%d, %d) [%d x %d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height);
1669   wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
1670
1671   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
1672   if(mMoveResizeSerial != mLastSubmittedMoveResizeSerial)
1673   {
1674     wl_egl_window_tizen_set_window_serial(mEglWindow, mMoveResizeSerial);
1675     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
1676   }
1677 }
1678
1679 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
1680 {
1681   // Check capability
1682   wl_egl_window_tizen_capability capability = static_cast<wl_egl_window_tizen_capability>(wl_egl_window_tizen_get_capabilities(mEglWindow));
1683   if(capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED)
1684   {
1685     mSupportedPreProtation = true;
1686     return true;
1687   }
1688   mSupportedPreProtation = false;
1689   return false;
1690 }
1691
1692 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToSystem(PositionSize positionSize)
1693 {
1694   PositionSize newPositionSize;
1695
1696   if(mWindowRotationAngle == 90)
1697   {
1698     newPositionSize.x      = positionSize.y;
1699     newPositionSize.y      = mScreenHeight - (positionSize.x + positionSize.width);
1700     newPositionSize.width  = positionSize.height;
1701     newPositionSize.height = positionSize.width;
1702   }
1703   else if(mWindowRotationAngle == 180)
1704   {
1705     newPositionSize.x      = mScreenWidth - (positionSize.x + positionSize.width);
1706     newPositionSize.y      = mScreenHeight - (positionSize.y + positionSize.height);
1707     newPositionSize.width  = positionSize.width;
1708     newPositionSize.height = positionSize.height;
1709   }
1710   else if(mWindowRotationAngle == 270)
1711   {
1712     newPositionSize.x      = mScreenWidth - (positionSize.y + positionSize.height);
1713     newPositionSize.y      = positionSize.x;
1714     newPositionSize.width  = positionSize.height;
1715     newPositionSize.height = positionSize.width;
1716   }
1717   else
1718   {
1719     newPositionSize.x      = positionSize.x;
1720     newPositionSize.y      = positionSize.y;
1721     newPositionSize.width  = positionSize.width;
1722     newPositionSize.height = positionSize.height;
1723   }
1724
1725   return newPositionSize;
1726 }
1727
1728 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToCurrentOrientation(PositionSize positionSize)
1729 {
1730   PositionSize newPositionSize;
1731
1732   if(mWindowRotationAngle == 90)
1733   {
1734     newPositionSize.x      = mScreenHeight - (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      = mScreenWidth - (positionSize.x + positionSize.width);
1742     newPositionSize.y      = mScreenHeight - (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      = mScreenWidth - (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   // Get Screen width, height
2641   ecore_wl2_display_screen_size_get(display, &mScreenWidth, &mScreenHeight);
2642 }
2643
2644 void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase, bool belowParent)
2645 {
2646   Ecore_Wl2_Window* ecoreParent = NULL;
2647   if(parentWinBase)
2648   {
2649     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
2650     ecoreParent                       = winBaseEcore2->mEcoreWindow;
2651   }
2652   ecore_wl2_window_transient_parent_set(mEcoreWindow, ecoreParent, belowParent);
2653 }
2654
2655 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2656 {
2657   return wl_egl_window_tizen_create_commit_sync_fd(mEglWindow);
2658 }
2659
2660 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2661 {
2662   return wl_egl_window_tizen_create_presentation_sync_fd(mEglWindow);
2663 }
2664
2665 void WindowBaseEcoreWl2::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
2666 {
2667   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);
2668   ecore_wl2_window_rotation_geometry_set(mEcoreWindow, angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2669 }
2670
2671 void WindowBaseEcoreWl2::InitializeIme()
2672 {
2673   Eina_Iterator*      globals;
2674   struct wl_registry* registry;
2675   Ecore_Wl2_Global*   global;
2676   Ecore_Wl2_Display*  ecoreWl2Display;
2677
2678   if(!(ecoreWl2Display = ecore_wl2_connected_display_get(NULL)))
2679   {
2680     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 connected display\n");
2681     return;
2682   }
2683
2684   DALI_LOG_RELEASE_INFO("InitializeIme:  Ecore_Wl2_Display: %p, ecore wl window: %p\n", ecoreWl2Display, mEcoreWindow);
2685
2686   if(!(registry = ecore_wl2_display_registry_get(ecoreWl2Display)))
2687   {
2688     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 display registry\n");
2689     return;
2690   }
2691
2692   if(!(globals = ecore_wl2_display_globals_get(ecoreWl2Display)))
2693   {
2694     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 globals\n");
2695     return;
2696   }
2697
2698   EINA_ITERATOR_FOREACH(globals, global)
2699   {
2700 #ifdef OVER_TIZEN_VERSION_7
2701     if(strcmp(global->interface, "zwp_input_panel_v1") == 0)
2702     {
2703       mWlInputPanel = (zwp_input_panel_v1*)wl_registry_bind(registry, global->id, &zwp_input_panel_v1_interface, 1);
2704     }
2705 #else
2706     if(strcmp(global->interface, "wl_input_panel") == 0)
2707     {
2708       mWlInputPanel = (wl_input_panel*)wl_registry_bind(registry, global->id, &wl_input_panel_interface, 1);
2709     }
2710 #endif
2711     else if(strcmp(global->interface, "wl_output") == 0)
2712     {
2713       mWlOutput = (wl_output*)wl_registry_bind(registry, global->id, &wl_output_interface, 1);
2714     }
2715   }
2716
2717   if(!mWlInputPanel)
2718   {
2719     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel interface\n");
2720     return;
2721   }
2722
2723   if(!mWlOutput)
2724   {
2725     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland output panel interface\n");
2726     return;
2727   }
2728 #ifdef OVER_TIZEN_VERSION_7
2729   mWlInputPanelSurface = zwp_input_panel_v1_get_input_panel_surface(mWlInputPanel, mWlSurface);
2730 #else
2731   mWlInputPanelSurface = wl_input_panel_get_input_panel_surface(mWlInputPanel, mWlSurface);
2732 #endif
2733   if(!mWlInputPanelSurface)
2734   {
2735     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel surface\n");
2736     return;
2737   }
2738 #ifdef OVER_TIZEN_VERSION_7
2739   zwp_input_panel_surface_v1_set_toplevel(mWlInputPanelSurface, mWlOutput, ZWP_INPUT_PANEL_SURFACE_V1_POSITION_CENTER_BOTTOM);
2740 #else
2741   wl_input_panel_surface_set_toplevel(mWlInputPanelSurface, mWlOutput, WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
2742 #endif
2743 }
2744
2745 void WindowBaseEcoreWl2::ImeWindowReadyToRender()
2746 {
2747   if(!mWlInputPanelSurface)
2748   {
2749     DALI_LOG_ERROR("WindowBaseEcoreWl2::ImeWindowReadyToRender(), wayland input panel surface is null\n");
2750     return;
2751   }
2752 #ifdef OVER_TIZEN_VERSION_7
2753   zwp_input_panel_surface_v1_set_ready(mWlInputPanelSurface, 1);
2754 #else
2755   wl_input_panel_surface_set_ready(mWlInputPanelSurface, 1);
2756 #endif
2757 }
2758
2759 void WindowBaseEcoreWl2::RequestMoveToServer()
2760 {
2761   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2762   if(!display)
2763   {
2764     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get ecore_wl2_display\n");
2765     return;
2766   }
2767
2768   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2769   if(!input)
2770   {
2771     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get default Ecore_Wl2_Input\n");
2772     return;
2773   }
2774
2775   ecore_wl2_window_move(mEcoreWindow, input);
2776   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestMoveToServer, starts the window[%p] is moved by server\n", mEcoreWindow);
2777 }
2778
2779 void WindowBaseEcoreWl2::RequestResizeToServer(WindowResizeDirection direction)
2780 {
2781   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2782   if(!display)
2783   {
2784     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get ecore_wl2_display\n");
2785     return;
2786   }
2787
2788   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2789   if(!input)
2790   {
2791     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get default Ecore_Wl2_Input\n");
2792     return;
2793   }
2794
2795   int location = 0;
2796   switch(direction)
2797   {
2798     case WindowResizeDirection::TOP_LEFT:
2799     {
2800       location = 5;
2801       break;
2802     }
2803     case WindowResizeDirection::TOP:
2804     {
2805       location = 1;
2806       break;
2807     }
2808     case WindowResizeDirection::TOP_RIGHT:
2809     {
2810       location = 9;
2811       break;
2812     }
2813     case WindowResizeDirection::LEFT:
2814     {
2815       location = 4;
2816       break;
2817     }
2818     case WindowResizeDirection::RIGHT:
2819     {
2820       location = 8;
2821       break;
2822     }
2823     case WindowResizeDirection::BOTTOM_LEFT:
2824     {
2825       location = 6;
2826       break;
2827     }
2828     case WindowResizeDirection::BOTTOM:
2829     {
2830       location = 2;
2831       break;
2832     }
2833     case WindowResizeDirection::BOTTOM_RIGHT:
2834     {
2835       location = 10;
2836       break;
2837     }
2838     default:
2839     {
2840       location = 0;
2841       break;
2842     }
2843   }
2844
2845   ecore_wl2_window_resize(mEcoreWindow, input, location);
2846   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestResizeToServer, starts the window[%p] is resized by server, mode:%d\n", mEcoreWindow, location);
2847 }
2848
2849 void WindowBaseEcoreWl2::EnableFloatingMode(bool enable)
2850 {
2851   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EnableFloatingMode, floating mode flag: [%p], enable [%d]\n", mEcoreWindow, enable);
2852   if(enable == true)
2853   {
2854     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_TRUE);
2855   }
2856   else
2857   {
2858     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_FALSE);
2859   }
2860 }
2861
2862 bool WindowBaseEcoreWl2::IsFloatingModeEnabled() const
2863 {
2864   return ecore_wl2_window_floating_mode_get(mEcoreWindow);
2865 }
2866
2867 void WindowBaseEcoreWl2::IncludeInputRegion(const Rect<int>& inputRegion)
2868 {
2869   Eina_Rectangle rect;
2870   rect.x = inputRegion.x;
2871   rect.y = inputRegion.y;
2872   rect.w = inputRegion.width;
2873   rect.h = inputRegion.height;
2874
2875   ecore_wl2_window_input_rect_add(mEcoreWindow, &rect);
2876   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2877 }
2878
2879 void WindowBaseEcoreWl2::ExcludeInputRegion(const Rect<int>& inputRegion)
2880 {
2881   Eina_Rectangle rect;
2882   rect.x = inputRegion.x;
2883   rect.y = inputRegion.y;
2884   rect.w = inputRegion.width;
2885   rect.h = inputRegion.height;
2886
2887   ecore_wl2_window_input_rect_subtract(mEcoreWindow, &rect);
2888   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2889 }
2890
2891 } // namespace Adaptor
2892
2893 } // namespace Internal
2894
2895 } // namespace Dali
2896
2897 #pragma GCC diagnostic pop