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