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