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