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

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