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