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

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