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