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

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