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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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) && Dali::Adaptor::IsAvailable())
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 && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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)) && Dali::Adaptor::IsAvailable())
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   if(Dali::Adaptor::IsAvailable())
1488   {
1489     int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
1490
1491     Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, detentEvent->direction, 0, Vector2(0.0f, 0.0f), clockwise, detentEvent->timestamp);
1492
1493     mWheelEventSignal.Emit(wheelEvent);
1494   }
1495 }
1496
1497 void WindowBaseEcoreWl2::OnKeyDown(void* data, int type, void* event)
1498 {
1499   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1500
1501   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
1502   {
1503     std::string keyName(keyEvent->keyname);
1504     std::string logicalKey("");
1505     std::string keyString("");
1506     std::string compose("");
1507
1508     DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_KEY_DOWN");
1509
1510     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1511     if(keyEvent->compose)
1512     {
1513       compose = keyEvent->compose;
1514     }
1515
1516     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1517     if(keyEvent->key)
1518     {
1519       logicalKey = keyEvent->key;
1520     }
1521
1522     int keyCode = 0;
1523     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1524
1525     if(keyCode == 0)
1526     {
1527       // Get a specific key code from dali key look up table.
1528       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1529     }
1530
1531     keyCode = (keyCode == -1) ? 0 : keyCode;
1532     int           modifier(keyEvent->modifiers);
1533     unsigned long time = keyEvent->timestamp;
1534     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1535     {
1536       keyCode = atoi(keyEvent->keyname + 8);
1537     }
1538
1539     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1540     if(keyEvent->string)
1541     {
1542       keyString = keyEvent->string;
1543     }
1544
1545     std::string            deviceName;
1546     Device::Class::Type    deviceClass;
1547     Device::Subclass::Type deviceSubclass;
1548
1549     GetDeviceName(keyEvent, deviceName);
1550     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1551     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1552
1553     bool isRepeat = false;
1554 #ifdef OVER_TIZEN_VERSION_8
1555     if(keyEvent->event_flags & ECORE_EVENT_FLAG_REPEAT)
1556     {
1557       isRepeat = true;
1558     }
1559 #endif
1560
1561     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass);
1562     keyEvent.isRepeat = isRepeat;
1563     keyEvent.windowId = GetNativeWindowId();
1564
1565     mKeyEventSignal.Emit(keyEvent);
1566   }
1567 }
1568
1569 void WindowBaseEcoreWl2::OnKeyUp(void* data, int type, void* event)
1570 {
1571   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1572
1573   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
1574   {
1575 #if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
1576     // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
1577     if(keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL)
1578     {
1579       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp: This event flag indicates the event is canceled. \n");
1580       return;
1581     }
1582 #endif // Since ecore 1.23 version
1583
1584     std::string keyName(keyEvent->keyname);
1585     std::string logicalKey("");
1586     std::string keyString("");
1587     std::string compose("");
1588
1589     DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_KEY_UP");
1590
1591     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1592     if(keyEvent->compose)
1593     {
1594       compose = keyEvent->compose;
1595     }
1596
1597     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1598     if(keyEvent->key)
1599     {
1600       logicalKey = keyEvent->key;
1601     }
1602
1603     int keyCode = 0;
1604     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1605
1606     if(keyCode == 0)
1607     {
1608       // Get a specific key code from dali key look up table.
1609       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1610     }
1611
1612     keyCode = (keyCode == -1) ? 0 : keyCode;
1613     int           modifier(keyEvent->modifiers);
1614     unsigned long time = keyEvent->timestamp;
1615     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1616     {
1617       keyCode = atoi(keyEvent->keyname + 8);
1618     }
1619
1620     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1621     if(keyEvent->string)
1622     {
1623       keyString = keyEvent->string;
1624     }
1625
1626     std::string            deviceName;
1627     Device::Class::Type    deviceClass;
1628     Device::Subclass::Type deviceSubclass;
1629
1630     GetDeviceName(keyEvent, deviceName);
1631     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1632     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1633
1634     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
1635     keyEvent.windowId = GetNativeWindowId();
1636
1637     mKeyEventSignal.Emit(keyEvent);
1638   }
1639 }
1640
1641 void WindowBaseEcoreWl2::OnDataSend(void* data, int type, void* event)
1642 {
1643   if(Dali::Adaptor::IsAvailable())
1644   {
1645     mSelectionDataSendSignal.Emit(event);
1646   }
1647 }
1648
1649 void WindowBaseEcoreWl2::OnDataReceive(void* data, int type, void* event)
1650 {
1651   if(Dali::Adaptor::IsAvailable())
1652   {
1653     mSelectionDataReceivedSignal.Emit(event);
1654   }
1655 }
1656
1657 void WindowBaseEcoreWl2::OnFontNameChanged()
1658 {
1659   if(Dali::Adaptor::IsAvailable())
1660   {
1661     mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
1662   }
1663 }
1664
1665 void WindowBaseEcoreWl2::OnFontSizeChanged()
1666 {
1667   if(Dali::Adaptor::IsAvailable())
1668   {
1669     mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
1670   }
1671 }
1672
1673 void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
1674 {
1675   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnTransitionEffectEvent, Window (%p)\n", mEcoreWindow);
1676
1677   if(Dali::Adaptor::IsAvailable())
1678   {
1679     mTransitionEffectEventSignal.Emit(state, type);
1680   }
1681 }
1682
1683 void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
1684 {
1685   if(Dali::Adaptor::IsAvailable())
1686   {
1687     mKeyboardRepeatSettingsChangedSignal.Emit();
1688   }
1689 }
1690
1691 void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
1692 {
1693   if(Dali::Adaptor::IsAvailable())
1694   {
1695     mWindowRedrawRequestSignal.Emit();
1696   }
1697 }
1698
1699 void WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage(void* event)
1700 {
1701   if(Dali::Adaptor::IsAvailable())
1702   {
1703     Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
1704     if(message)
1705     {
1706       DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, Window (%p), key:%s, value:%s \n", mEcoreWindow, message->key, message->val);
1707       std::string           key(message->key);
1708       std::string           value(message->val);
1709       Dali::Property::Array options;
1710
1711       if(message->options)
1712       {
1713         Eina_List* l;
1714         void*      data;
1715         EINA_LIST_FOREACH(message->options, l, data)
1716         {
1717           DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, Window (%p), option: %s\n", mEcoreWindow, (char*)data);
1718           std::string option(static_cast<char*>(data));
1719           options.Add(option);
1720         }
1721       }
1722
1723       mAuxiliaryMessageSignal.Emit(key, value, options);
1724     }
1725   }
1726 }
1727
1728 void WindowBaseEcoreWl2::OnEcoreEventConformantChange(void* event)
1729 {
1730   if(Dali::Adaptor::IsAvailable())
1731   {
1732     Ecore_Wl2_Event_Conformant_Change* ev = static_cast<Ecore_Wl2_Event_Conformant_Change*>(event);
1733     if(ev && ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1734     {
1735       WindowInsetsPartType partType = WindowInsetsPartType::STATUS_BAR;
1736
1737       int x = 0;
1738       int y = 0;
1739       int w = 0;
1740       int h = 0;
1741
1742       switch(ev->part_type)
1743       {
1744         case ECORE_WL2_INDICATOR_PART:
1745         {
1746           partType = WindowInsetsPartType::STATUS_BAR;
1747           ecore_wl2_window_indicator_geometry_get(mEcoreWindow, &x, &y, &w, &h);
1748           break;
1749         }
1750         case ECORE_WL2_KEYBOARD_PART:
1751         {
1752           partType = WindowInsetsPartType::KEYBOARD;
1753           ecore_wl2_window_keyboard_geometry_get(mEcoreWindow, &x, &y, &w, &h);
1754           break;
1755         }
1756         case ECORE_WL2_CLIPBOARD_PART:
1757         {
1758           partType = WindowInsetsPartType::CLIPBOARD;
1759           ecore_wl2_window_clipboard_geometry_get(mEcoreWindow, &x, &y, &w, &h);
1760           break;
1761         }
1762         default:
1763         {
1764           break;
1765         }
1766       }
1767
1768       WindowInsetsPartState partState = WindowInsetsPartState::INVISIBLE;
1769
1770       int left   = 0;
1771       int right  = 0;
1772       int top    = 0;
1773       int bottom = 0;
1774
1775       // Insets are applied only if system UI(e.g. virtual keyboard) satisfies the following 2 conditions.
1776       // 1. System UI fits to the window width or height.
1777       // 2. System UI begins or ends from the edge of window.
1778       // Otherwise, we should not resize window content because there would be empty space around system UI.
1779       bool applyInsets = false;
1780
1781       // Zero insets are applied if state is invisible
1782       if(!ev->state)
1783       {
1784         applyInsets = true;
1785       }
1786       else
1787       {
1788         partState = WindowInsetsPartState::VISIBLE;
1789
1790         int winX = mWindowPositionSize.x;
1791         int winY = mWindowPositionSize.y;
1792         int winW = mWindowPositionSize.width;
1793         int winH = mWindowPositionSize.height;
1794
1795         if((x <= winX) && (x + w >= winX + winW))
1796         {
1797           if((y <= winY) && (y + h >= winY) && (y + h <= winY + winH))
1798           {
1799             top         = y + h - winY;
1800             applyInsets = true;
1801           }
1802           else if((y + h >= winY + winH) && (y >= winY) && (y <= winY + winH))
1803           {
1804             bottom      = winY + winH - y;
1805             applyInsets = true;
1806           }
1807         }
1808         else if((y <= winY) && (y + h >= winY + winH))
1809         {
1810           if((x <= winX) && (x + w >= winX) && (x + w <= winX + winW))
1811           {
1812             left        = x + w - winX;
1813             applyInsets = true;
1814           }
1815           else if((x + w >= winX + winW) && (x >= winX) && (x <= winX + winW))
1816           {
1817             right       = winX + winW - x;
1818             applyInsets = true;
1819           }
1820         }
1821       }
1822
1823       if(applyInsets)
1824       {
1825         mInsetsChangedSignal.Emit(partType, partState, Extents(left, right, top, bottom));
1826       }
1827     }
1828   }
1829 }
1830
1831 void WindowBaseEcoreWl2::KeymapChanged(void* data, int type, void* event)
1832 {
1833   Ecore_Wl2_Event_Seat_Keymap_Changed* changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>(event);
1834   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id);
1835   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(changed->display);
1836   if(ecoreWlInput)
1837   {
1838     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
1839   }
1840 }
1841
1842 void WindowBaseEcoreWl2::OnMoveCompleted(void* event)
1843 {
1844   Ecore_Wl2_Event_Window_Interactive_Move_Done* movedDoneEvent = static_cast<Ecore_Wl2_Event_Window_Interactive_Move_Done*>(event);
1845   if(movedDoneEvent && movedDoneEvent->win == static_cast<uint32_t>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
1846   {
1847     Dali::PositionSize orgPositionSize(movedDoneEvent->x, movedDoneEvent->y, movedDoneEvent->w, movedDoneEvent->h);
1848     Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(orgPositionSize);
1849     Dali::Int32Pair    newPosition(newPositionSize.x, newPositionSize.y);
1850     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnMoveCompleted, window(%p) has been moved by server[%d, %d]\n", mEcoreWindow, newPositionSize.x, newPositionSize.y);
1851     mMoveCompletedSignal.Emit(newPosition);
1852   }
1853 }
1854
1855 void WindowBaseEcoreWl2::OnResizeCompleted(void* event)
1856 {
1857   Ecore_Wl2_Event_Window_Interactive_Resize_Done* resizedDoneEvent = static_cast<Ecore_Wl2_Event_Window_Interactive_Resize_Done*>(event);
1858   if(resizedDoneEvent && resizedDoneEvent->win == static_cast<uint32_t>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
1859   {
1860     Dali::PositionSize orgPositionSize(resizedDoneEvent->x, resizedDoneEvent->y, resizedDoneEvent->w, resizedDoneEvent->h);
1861     Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(orgPositionSize);
1862     Dali::Uint16Pair   newSize(newPositionSize.width, newPositionSize.height);
1863     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnResizeCompleted, window(%p) has been resized by server[%d, %d]\n", mEcoreWindow, newPositionSize.width, newPositionSize.height);
1864     mResizeCompletedSignal.Emit(newSize);
1865   }
1866 }
1867
1868 void WindowBaseEcoreWl2::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
1869 {
1870   if(strcmp(interface, tizen_policy_interface.name) == 0)
1871   {
1872     uint32_t clientVersion = std::min(version, MAX_TIZEN_CLIENT_VERSION);
1873
1874     mTizenPolicy = static_cast<tizen_policy*>(wl_registry_bind(registry, name, &tizen_policy_interface, clientVersion));
1875     if(!mTizenPolicy)
1876     {
1877       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n");
1878       return;
1879     }
1880
1881     tizen_policy_add_listener(mTizenPolicy, &tizenPolicyListener, data);
1882
1883     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n");
1884   }
1885   else if(strcmp(interface, tizen_display_policy_interface.name) == 0)
1886   {
1887     mTizenDisplayPolicy = static_cast<tizen_display_policy*>(wl_registry_bind(registry, name, &tizen_display_policy_interface, version));
1888     if(!mTizenDisplayPolicy)
1889     {
1890       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n");
1891       return;
1892     }
1893
1894     tizen_display_policy_add_listener(mTizenDisplayPolicy, &tizenDisplayPolicyListener, data);
1895
1896     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n");
1897   }
1898 }
1899
1900 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
1901 {
1902   mTizenPolicy        = NULL;
1903   mTizenDisplayPolicy = NULL;
1904 }
1905
1906 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)
1907 {
1908   int  originalX, originalY, originalWidth, originalHeight;
1909   bool changed = false;
1910
1911   if(!surface)
1912   {
1913     DALI_LOG_ERROR("Failed to get wayland surface in WindowBaseEcoreWl2::TizenPolicyConformantArea()\n");
1914     return;
1915   }
1916
1917   if(conformantPart == TIZEN_POLICY_CONFORMANT_PART_INDICATOR)
1918   {
1919     ecore_wl2_window_indicator_geometry_get(mEcoreWindow, &originalX, &originalY, &originalWidth, &originalHeight);
1920     if((originalX != x) || (originalY != y) || (originalWidth != w) || (originalHeight != h))
1921     {
1922       ecore_wl2_window_indicator_geometry_set(mEcoreWindow, x, y, w, h);
1923       changed = true;
1924     }
1925
1926     /**
1927      * The given state is based on the visibility value of indicator.
1928      * Thus we need to add 1 to it before comparing with indicator state.
1929      */
1930     Ecore_Wl2_Indicator_State indState = ecore_wl2_window_indicator_state_get(mEcoreWindow);
1931     if((state + 1) != indState)
1932     {
1933       ecore_wl2_window_indicator_state_set(mEcoreWindow, static_cast<Ecore_Wl2_Indicator_State>(state + 1));
1934       changed = true;
1935     }
1936   }
1937   else if(conformantPart == TIZEN_POLICY_CONFORMANT_PART_KEYBOARD)
1938   {
1939     ecore_wl2_window_keyboard_geometry_get(mEcoreWindow, &originalX, &originalY, &originalWidth, &originalHeight);
1940     if((originalX != x) || (originalY != y) || (originalWidth != w) || (originalHeight != h))
1941     {
1942       ecore_wl2_window_keyboard_geometry_set(mEcoreWindow, x, y, w, h);
1943       changed = true;
1944     }
1945
1946     /**
1947      * The given state is based on the visibility value of virtual keyboard window.
1948      * Thus we need to add 1 to it before comparing with keyboard state.
1949      */
1950     Ecore_Wl2_Virtual_Keyboard_State kbdState = ecore_wl2_window_keyboard_state_get(mEcoreWindow);
1951     if((state + 1) != (kbdState))
1952     {
1953       ecore_wl2_window_keyboard_state_set(mEcoreWindow, static_cast<Ecore_Wl2_Virtual_Keyboard_State>(state + 1));
1954       changed = true;
1955     }
1956   }
1957   else if(conformantPart == TIZEN_POLICY_CONFORMANT_PART_CLIPBOARD)
1958   {
1959     ecore_wl2_window_clipboard_geometry_get(mEcoreWindow, &originalX, &originalY, &originalWidth, &originalHeight);
1960     if((originalX != x) || (originalY != y) || (originalWidth != w) || (originalHeight != h))
1961     {
1962       ecore_wl2_window_clipboard_geometry_set(mEcoreWindow, x, y, w, h);
1963       changed = true;
1964     }
1965
1966     /**
1967      * The given state is based on the visibility value of clipboard window.
1968      * Thus we need to add 1 to it before comparing with clipboard state.
1969      */
1970     Ecore_Wl2_Clipboard_State clipState = ecore_wl2_window_clipboard_state_get(mEcoreWindow);
1971     if((state + 1) != clipState)
1972     {
1973       ecore_wl2_window_clipboard_state_set(mEcoreWindow, static_cast<Ecore_Wl2_Clipboard_State>(state + 1));
1974       changed = true;
1975     }
1976   }
1977
1978   if(changed)
1979   {
1980     Ecore_Wl2_Event_Conformant_Change* ev = static_cast<Ecore_Wl2_Event_Conformant_Change*>(calloc(1, sizeof(Ecore_Wl2_Event_Conformant_Change)));
1981
1982     if(DALI_UNLIKELY(!ev))
1983     {
1984       DALI_LOG_ERROR("Failed to allocate Ecore_Wl2_Event_Conformant_Change. calloc size : %zu\n", sizeof(Ecore_Wl2_Event_Conformant_Change));
1985       return;
1986     }
1987     ev->win       = GetNativeWindowId();
1988     ev->part_type = static_cast<Ecore_Wl2_Conformant_Part_Type>(conformantPart);
1989     ev->state     = state;
1990     ecore_event_add(ECORE_WL2_EVENT_CONFORMANT_CHANGE, ev, NULL, NULL);
1991   }
1992
1993   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);
1994 }
1995
1996 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
1997 {
1998   mNotificationLevel           = level;
1999   mNotificationChangeState     = state;
2000   mNotificationLevelChangeDone = true;
2001
2002   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state);
2003 }
2004
2005 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
2006 {
2007   mScreenOffMode            = mode;
2008   mScreenOffModeChangeState = state;
2009   mScreenOffModeChangeDone  = true;
2010
2011   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state);
2012 }
2013
2014 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
2015 {
2016   mBrightness            = brightness;
2017   mBrightnessChangeState = state;
2018   mBrightnessChangeDone  = true;
2019
2020   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state);
2021 }
2022
2023 void WindowBaseEcoreWl2::GetKeyCode(std::string keyName, int32_t& keyCode)
2024 {
2025   xkb_keysym_t sym = XKB_KEY_NoSymbol;
2026   KeyCodeMap   foundKeyCode;
2027
2028   sym = xkb_keysym_from_name(keyName.c_str(), XKB_KEYSYM_NO_FLAGS);
2029   if(sym == XKB_KEY_NoSymbol || !mKeyMap)
2030   {
2031     DALI_LOG_ERROR("Failed to get keysym or keymap in WindowBaseEcoreWl2\n");
2032     return;
2033   }
2034
2035   foundKeyCode.keySym    = sym;
2036   foundKeyCode.isKeyCode = false;
2037   xkb_keymap_key_for_each(mKeyMap, FindKeyCode, &foundKeyCode);
2038   keyCode = static_cast<int32_t>(foundKeyCode.keyCode);
2039 }
2040
2041 Any WindowBaseEcoreWl2::GetNativeWindow()
2042 {
2043   return mEcoreWindow;
2044 }
2045
2046 int WindowBaseEcoreWl2::GetNativeWindowId()
2047 {
2048   return ecore_wl2_window_id_get(mEcoreWindow);
2049 }
2050
2051 std::string WindowBaseEcoreWl2::GetNativeWindowResourceId()
2052 {
2053 #ifdef OVER_TIZEN_VERSION_7
2054   return std::to_string(ecore_wl2_window_resource_id_get(mEcoreWindow));
2055 #else
2056   return std::string();
2057 #endif
2058 }
2059
2060 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow(int width, int height)
2061 {
2062   int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
2063
2064   START_DURATION_CHECK();
2065   if(totalAngle == 90 || totalAngle == 270)
2066   {
2067     mEglWindow = wl_egl_window_create(mWlSurface, height, width);
2068   }
2069   else
2070   {
2071     mEglWindow = wl_egl_window_create(mWlSurface, width, height);
2072   }
2073   FINISH_DURATION_CHECK("wl_egl_window_create");
2074
2075   return static_cast<EGLNativeWindowType>(mEglWindow);
2076 }
2077
2078 void WindowBaseEcoreWl2::DestroyEglWindow()
2079 {
2080   if(mEglWindow != NULL)
2081   {
2082     START_DURATION_CHECK();
2083     wl_egl_window_destroy(mEglWindow);
2084     FINISH_DURATION_CHECK("wl_egl_window_destroy");
2085
2086     mEglWindow = NULL;
2087   }
2088 }
2089
2090 void WindowBaseEcoreWl2::SetEglWindowRotation(int angle)
2091 {
2092   wl_egl_window_tizen_rotation rotation;
2093
2094   switch(angle)
2095   {
2096     case 0:
2097     {
2098       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
2099       break;
2100     }
2101     case 90:
2102     {
2103       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
2104       break;
2105     }
2106     case 180:
2107     {
2108       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
2109       break;
2110     }
2111     case 270:
2112     {
2113       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
2114       break;
2115     }
2116     default:
2117     {
2118       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
2119       break;
2120     }
2121   }
2122
2123   START_DURATION_CHECK();
2124   wl_egl_window_tizen_set_rotation(mEglWindow, rotation);
2125   FINISH_DURATION_CHECK("wl_egl_window_tizen_set_rotation");
2126 }
2127
2128 void WindowBaseEcoreWl2::SetEglWindowBufferTransform(int angle)
2129 {
2130   wl_output_transform bufferTransform;
2131
2132   switch(angle)
2133   {
2134     case 0:
2135     {
2136       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
2137       break;
2138     }
2139     case 90:
2140     {
2141       bufferTransform = WL_OUTPUT_TRANSFORM_90;
2142       break;
2143     }
2144     case 180:
2145     {
2146       bufferTransform = WL_OUTPUT_TRANSFORM_180;
2147       break;
2148     }
2149     case 270:
2150     {
2151       bufferTransform = WL_OUTPUT_TRANSFORM_270;
2152       break;
2153     }
2154     default:
2155     {
2156       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
2157       break;
2158     }
2159   }
2160
2161   DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_buffer_transform() with buffer Transform [%d]\n", bufferTransform);
2162   START_DURATION_CHECK();
2163   wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
2164   FINISH_DURATION_CHECK("wl_egl_window_tizen_set_buffer_transform");
2165 }
2166
2167 void WindowBaseEcoreWl2::SetEglWindowTransform(int angle)
2168 {
2169   wl_output_transform windowTransform;
2170
2171   switch(angle)
2172   {
2173     case 0:
2174     {
2175       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
2176       break;
2177     }
2178     case 90:
2179     {
2180       windowTransform = WL_OUTPUT_TRANSFORM_90;
2181       break;
2182     }
2183     case 180:
2184     {
2185       windowTransform = WL_OUTPUT_TRANSFORM_180;
2186       break;
2187     }
2188     case 270:
2189     {
2190       windowTransform = WL_OUTPUT_TRANSFORM_270;
2191       break;
2192     }
2193     default:
2194     {
2195       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
2196       break;
2197     }
2198   }
2199
2200   DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_window_transform() with window Transform [%d]\n", windowTransform);
2201   START_DURATION_CHECK();
2202   wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
2203   FINISH_DURATION_CHECK("wl_egl_window_tizen_set_window_transform");
2204 }
2205
2206 void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
2207 {
2208   DALI_LOG_RELEASE_INFO("wl_egl_window_resize(), (%d, %d) [%d x %d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2209   START_DURATION_CHECK();
2210   wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
2211
2212   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
2213   if(mMoveResizeSerial != mLastSubmittedMoveResizeSerial)
2214   {
2215     wl_egl_window_tizen_set_window_serial(mEglWindow, mMoveResizeSerial);
2216     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
2217   }
2218   FINISH_DURATION_CHECK("wl_egl_window functions");
2219 }
2220
2221 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
2222 {
2223   START_DURATION_CHECK();
2224   // Check capability
2225   wl_egl_window_tizen_capability capability = static_cast<wl_egl_window_tizen_capability>(wl_egl_window_tizen_get_capabilities(mEglWindow));
2226   FINISH_DURATION_CHECK("wl_egl_window_tizen_get_capabilities");
2227
2228   if(capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED)
2229   {
2230     mSupportedPreProtation = true;
2231     return true;
2232   }
2233   mSupportedPreProtation = false;
2234   return false;
2235 }
2236
2237 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToSystem(PositionSize positionSize)
2238 {
2239   PositionSize newPositionSize;
2240   int32_t      screenWidth, screenHeight;
2241   WindowSystem::GetScreenSize(screenWidth, screenHeight);
2242
2243   if(mWindowRotationAngle == 90)
2244   {
2245     newPositionSize.x      = positionSize.y;
2246     newPositionSize.y      = screenHeight - (positionSize.x + positionSize.width);
2247     newPositionSize.width  = positionSize.height;
2248     newPositionSize.height = positionSize.width;
2249   }
2250   else if(mWindowRotationAngle == 180)
2251   {
2252     newPositionSize.x      = screenWidth - (positionSize.x + positionSize.width);
2253     newPositionSize.y      = screenHeight - (positionSize.y + positionSize.height);
2254     newPositionSize.width  = positionSize.width;
2255     newPositionSize.height = positionSize.height;
2256   }
2257   else if(mWindowRotationAngle == 270)
2258   {
2259     newPositionSize.x      = screenWidth - (positionSize.y + positionSize.height);
2260     newPositionSize.y      = positionSize.x;
2261     newPositionSize.width  = positionSize.height;
2262     newPositionSize.height = positionSize.width;
2263   }
2264   else
2265   {
2266     newPositionSize.x      = positionSize.x;
2267     newPositionSize.y      = positionSize.y;
2268     newPositionSize.width  = positionSize.width;
2269     newPositionSize.height = positionSize.height;
2270   }
2271
2272   return newPositionSize;
2273 }
2274
2275 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToCurrentOrientation(PositionSize positionSize)
2276 {
2277   PositionSize newPositionSize;
2278   int32_t      screenWidth, screenHeight;
2279   WindowSystem::GetScreenSize(screenWidth, screenHeight);
2280
2281   if(mWindowRotationAngle == 90)
2282   {
2283     newPositionSize.x      = screenHeight - (positionSize.y + positionSize.height);
2284     newPositionSize.y      = positionSize.x;
2285     newPositionSize.width  = positionSize.height;
2286     newPositionSize.height = positionSize.width;
2287   }
2288   else if(mWindowRotationAngle == 180)
2289   {
2290     newPositionSize.x      = screenWidth - (positionSize.x + positionSize.width);
2291     newPositionSize.y      = screenHeight - (positionSize.y + positionSize.height);
2292     newPositionSize.width  = positionSize.width;
2293     newPositionSize.height = positionSize.height;
2294   }
2295   else if(mWindowRotationAngle == 270)
2296   {
2297     newPositionSize.x      = positionSize.y;
2298     newPositionSize.y      = screenWidth - (positionSize.x + positionSize.width);
2299     newPositionSize.width  = positionSize.height;
2300     newPositionSize.height = positionSize.width;
2301   }
2302   else
2303   {
2304     newPositionSize.x      = positionSize.x;
2305     newPositionSize.y      = positionSize.y;
2306     newPositionSize.width  = positionSize.width;
2307     newPositionSize.height = positionSize.height;
2308   }
2309
2310   return newPositionSize;
2311 }
2312
2313 void WindowBaseEcoreWl2::Move(PositionSize positionSize)
2314 {
2315   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
2316
2317   mWindowPositionSize = newPositionSize;
2318   DALI_LOG_RELEASE_INFO("ecore_wl2_window_position_set x[%d], y[%d]\n", newPositionSize.x, newPositionSize.y);
2319   START_DURATION_CHECK();
2320   ecore_wl2_window_position_set(mEcoreWindow, newPositionSize.x, newPositionSize.y);
2321   FINISH_DURATION_CHECK("ecore_wl2_window_position_set");
2322 }
2323
2324 void WindowBaseEcoreWl2::Resize(PositionSize positionSize)
2325 {
2326   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
2327
2328   mWindowPositionSize = newPositionSize;
2329   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);
2330   START_DURATION_CHECK();
2331   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
2332   FINISH_DURATION_CHECK("ecore_wl2_window_sync_geometry_set");
2333 }
2334
2335 void WindowBaseEcoreWl2::MoveResize(PositionSize positionSize)
2336 {
2337   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
2338
2339   mWindowPositionSize = newPositionSize;
2340   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);
2341   START_DURATION_CHECK();
2342   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
2343   FINISH_DURATION_CHECK("ecore_wl2_window_sync_geometry_set");
2344 }
2345
2346 void WindowBaseEcoreWl2::SetLayout(unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan)
2347 {
2348 #ifdef OVER_TIZEN_VERSION_8
2349   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);
2350   START_DURATION_CHECK();
2351   ecore_wl2_window_layout_set(mEcoreWindow, numCols, numRows, column, row, colSpan, rowSpan);
2352   FINISH_DURATION_CHECK("ecore_wl2_window_layout_set");
2353 #endif
2354 }
2355
2356 void WindowBaseEcoreWl2::SetClass(const std::string& name, const std::string& className)
2357 {
2358   ecore_wl2_window_title_set(mEcoreWindow, name.c_str());
2359   ecore_wl2_window_class_set(mEcoreWindow, className.c_str());
2360 }
2361
2362 void WindowBaseEcoreWl2::Raise()
2363 {
2364   START_DURATION_CHECK();
2365   // Use ecore_wl2_window_activate to prevent the window shown without rendering
2366   ecore_wl2_window_activate(mEcoreWindow);
2367   FINISH_DURATION_CHECK("ecore_wl2_window_activate");
2368 }
2369
2370 void WindowBaseEcoreWl2::Lower()
2371 {
2372   START_DURATION_CHECK();
2373   ecore_wl2_window_lower(mEcoreWindow);
2374   FINISH_DURATION_CHECK("ecore_wl2_window_lower");
2375 }
2376
2377 void WindowBaseEcoreWl2::Activate()
2378 {
2379   START_DURATION_CHECK();
2380   ecore_wl2_window_activate(mEcoreWindow);
2381   FINISH_DURATION_CHECK("ecore_wl2_window_activate");
2382 }
2383
2384 void WindowBaseEcoreWl2::Maximize(bool maximize)
2385 {
2386   START_DURATION_CHECK();
2387   ecore_wl2_window_maximized_set(mEcoreWindow, maximize);
2388   FINISH_DURATION_CHECK("ecore_wl2_window_maximized_set");
2389 }
2390
2391 bool WindowBaseEcoreWl2::IsMaximized() const
2392 {
2393   return ecore_wl2_window_maximized_get(mEcoreWindow);
2394 }
2395
2396 void WindowBaseEcoreWl2::SetMaximumSize(Dali::Window::WindowSize size)
2397 {
2398   DALI_LOG_RELEASE_INFO("ecore_wl2_window_maximum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
2399   START_DURATION_CHECK();
2400   ecore_wl2_window_maximum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
2401   FINISH_DURATION_CHECK("ecore_wl2_window_maximum_size_set");
2402   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2403 }
2404
2405 void WindowBaseEcoreWl2::Minimize(bool minimize)
2406 {
2407   START_DURATION_CHECK();
2408   ecore_wl2_window_iconified_set(mEcoreWindow, minimize);
2409   FINISH_DURATION_CHECK("ecore_wl2_window_iconified_set");
2410 }
2411
2412 bool WindowBaseEcoreWl2::IsMinimized() const
2413 {
2414   return ecore_wl2_window_iconified_get(mEcoreWindow);
2415 }
2416
2417 void WindowBaseEcoreWl2::SetMimimumSize(Dali::Window::WindowSize size)
2418 {
2419   DALI_LOG_RELEASE_INFO("ecore_wl2_window_minimum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
2420   START_DURATION_CHECK();
2421   ecore_wl2_window_minimum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
2422   FINISH_DURATION_CHECK("ecore_wl2_window_minimum_size_set");
2423   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2424 }
2425
2426 void WindowBaseEcoreWl2::SetAvailableAnlges(const std::vector<int>& angles)
2427 {
2428   int rotations[4] = {0};
2429   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size());
2430   for(std::size_t i = 0; i < angles.size(); ++i)
2431   {
2432     rotations[i] = static_cast<int>(angles[i]);
2433     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "%d ", rotations[i]);
2434   }
2435
2436   START_DURATION_CHECK();
2437   ecore_wl2_window_available_rotations_set(mEcoreWindow, rotations, angles.size());
2438   FINISH_DURATION_CHECK("ecore_wl2_window_available_rotations_set");
2439 }
2440
2441 void WindowBaseEcoreWl2::SetPreferredAngle(int angle)
2442 {
2443   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetPreferredAngle, angle: %d\n", angle);
2444   START_DURATION_CHECK();
2445   ecore_wl2_window_preferred_rotation_set(mEcoreWindow, angle);
2446   FINISH_DURATION_CHECK("ecore_wl2_window_preferred_rotation_set");
2447 }
2448
2449 void WindowBaseEcoreWl2::SetAcceptFocus(bool accept)
2450 {
2451   START_DURATION_CHECK();
2452   ecore_wl2_window_focus_skip_set(mEcoreWindow, !accept);
2453   FINISH_DURATION_CHECK("ecore_wl2_window_focus_skip_set");
2454 }
2455
2456 void WindowBaseEcoreWl2::Show()
2457 {
2458   if(!mVisible)
2459   {
2460     START_DURATION_CHECK();
2461     ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
2462     FINISH_DURATION_CHECK("ecore_wl2_window_geometry_set");
2463   }
2464   mVisible = true;
2465
2466   ecore_wl2_window_show(mEcoreWindow);
2467 }
2468
2469 void WindowBaseEcoreWl2::Hide()
2470 {
2471   mVisible = false;
2472   ecore_wl2_window_hide(mEcoreWindow);
2473 }
2474
2475 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
2476 {
2477   return mSupportedAuxiliaryHints.size();
2478 }
2479
2480 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint(unsigned int index) const
2481 {
2482   if(index >= GetSupportedAuxiliaryHintCount())
2483   {
2484     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index);
2485   }
2486
2487   return mSupportedAuxiliaryHints[index];
2488 }
2489
2490 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint(const std::string& hint, const std::string& value)
2491 {
2492   bool supported = false;
2493
2494   // Check if the hint is suppported
2495   for(std::vector<std::string>::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter)
2496   {
2497     if(*iter == hint)
2498     {
2499       supported = true;
2500       break;
2501     }
2502   }
2503
2504   if(!supported)
2505   {
2506     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str());
2507     return 0;
2508   }
2509
2510   // Check if the hint is already added
2511   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
2512   {
2513     if(mAuxiliaryHints[i].first == hint)
2514     {
2515       // Just change the value
2516       mAuxiliaryHints[i].second = value;
2517
2518       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1);
2519
2520       return i + 1; // id is index + 1
2521     }
2522   }
2523
2524   // Add the hint
2525   mAuxiliaryHints.push_back(std::pair<std::string, std::string>(hint, value));
2526
2527   unsigned int id = mAuxiliaryHints.size();
2528
2529   START_DURATION_CHECK();
2530   ecore_wl2_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
2531   FINISH_DURATION_CHECK("ecore_wl2_window_aux_hint_add");
2532
2533   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
2534
2535   return id;
2536 }
2537
2538 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint(unsigned int id)
2539 {
2540   if(id == 0 || id > mAuxiliaryHints.size())
2541   {
2542     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id);
2543     return false;
2544   }
2545
2546   mAuxiliaryHints[id - 1].second = std::string();
2547
2548   START_DURATION_CHECK();
2549   ecore_wl2_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
2550   FINISH_DURATION_CHECK("ecore_wl2_window_aux_hint_del");
2551
2552   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
2553
2554   return true;
2555 }
2556
2557 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
2558 {
2559   if(id == 0 || id > mAuxiliaryHints.size())
2560   {
2561     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id);
2562     return false;
2563   }
2564
2565   mAuxiliaryHints[id - 1].second = value;
2566
2567   START_DURATION_CHECK();
2568   ecore_wl2_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
2569   FINISH_DURATION_CHECK("ecore_wl2_window_aux_hint_change");
2570
2571   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());
2572
2573   return true;
2574 }
2575
2576 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue(unsigned int id) const
2577 {
2578   if(id == 0 || id > mAuxiliaryHints.size())
2579   {
2580     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id);
2581     return std::string();
2582   }
2583
2584   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());
2585
2586   return mAuxiliaryHints[id - 1].second;
2587 }
2588
2589 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId(const std::string& hint) const
2590 {
2591   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
2592   {
2593     if(mAuxiliaryHints[i].first == hint)
2594     {
2595       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1);
2596       return i + 1;
2597     }
2598   }
2599
2600   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str());
2601
2602   return 0;
2603 }
2604
2605 void WindowBaseEcoreWl2::SetInputRegion(const Rect<int>& inputRegion)
2606 {
2607   Rect<int> convertRegion = RecalculatePositionSizeToSystem(inputRegion);
2608
2609   Eina_Rectangle rect;
2610   rect.x = convertRegion.x;
2611   rect.y = convertRegion.y;
2612   rect.w = convertRegion.width;
2613   rect.h = convertRegion.height;
2614
2615   DALI_LOG_RELEASE_INFO("%p, Set input rect (%d, %d, %d x %d)\n", mEcoreWindow, rect.x, rect.y, rect.w, rect.h);
2616   START_DURATION_CHECK();
2617   ecore_wl2_window_input_rect_set(mEcoreWindow, &rect);
2618   FINISH_DURATION_CHECK("ecore_wl2_window_input_rect_set");
2619   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2620 }
2621
2622 void WindowBaseEcoreWl2::SetType(Dali::WindowType type)
2623 {
2624   if(mType != type)
2625   {
2626     mType = type;
2627     Ecore_Wl2_Window_Type windowType;
2628
2629     switch(type)
2630     {
2631       case Dali::WindowType::NORMAL:
2632       {
2633         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::NORMAL\n");
2634         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2635         break;
2636       }
2637       case Dali::WindowType::NOTIFICATION:
2638       {
2639         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::NOTIFICATION\n");
2640         windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
2641         break;
2642       }
2643       case Dali::WindowType::UTILITY:
2644       {
2645         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::UTILITY\n");
2646         windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
2647         break;
2648       }
2649       case Dali::WindowType::DIALOG:
2650       {
2651         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::DIALOG\n");
2652         windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
2653         break;
2654       }
2655       case Dali::WindowType::IME:
2656       {
2657         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::IME\n");
2658         windowType = ECORE_WL2_WINDOW_TYPE_NONE;
2659         break;
2660       }
2661       case Dali::WindowType::DESKTOP:
2662       {
2663         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::DESKTOP\n");
2664         windowType = ECORE_WL2_WINDOW_TYPE_DESKTOP;
2665         break;
2666       }
2667       default:
2668       {
2669         DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, default window type\n");
2670         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2671         break;
2672       }
2673     }
2674
2675     START_DURATION_CHECK();
2676     ecore_wl2_window_type_set(mEcoreWindow, windowType);
2677     FINISH_DURATION_CHECK("ecore_wl2_window_type_set");
2678   }
2679 }
2680
2681 Dali::WindowType WindowBaseEcoreWl2::GetType() const
2682 {
2683   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::GetType(), Window (%p), DALI WindType: %d, mIsIMEWindowInitialized: %d\n", mEcoreWindow, mType, mIsIMEWindowInitialized);
2684   return mType;
2685 }
2686
2687 Dali::WindowOperationResult WindowBaseEcoreWl2::SetNotificationLevel(Dali::WindowNotificationLevel level)
2688 {
2689   START_DURATION_CHECK();
2690   while(!mTizenPolicy)
2691   {
2692     wl_display_dispatch_queue(mDisplay, mEventQueue);
2693   }
2694
2695   int notificationLevel;
2696
2697   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetNotificationLevel(), Window (%p), level [%d]\n", mEcoreWindow, level);
2698   switch(level)
2699   {
2700     case Dali::WindowNotificationLevel::NONE:
2701     {
2702       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
2703       break;
2704     }
2705     case Dali::WindowNotificationLevel::BASE:
2706     {
2707       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2708       break;
2709     }
2710     case Dali::WindowNotificationLevel::MEDIUM:
2711     {
2712       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
2713       break;
2714     }
2715     case Dali::WindowNotificationLevel::HIGH:
2716     {
2717       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
2718       break;
2719     }
2720     case Dali::WindowNotificationLevel::TOP:
2721     {
2722       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
2723       break;
2724     }
2725     default:
2726     {
2727       DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetNotificationLevel(), invalid level [%d]\n", level);
2728       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2729       break;
2730     }
2731   }
2732
2733   mNotificationLevelChangeDone = false;
2734   mNotificationChangeState     = TIZEN_POLICY_ERROR_STATE_NONE;
2735
2736   tizen_policy_set_notification_level(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), notificationLevel);
2737
2738   int count = 0;
2739
2740   while(!mNotificationLevelChangeDone && count < 3)
2741   {
2742     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2743     wl_display_dispatch_queue(mDisplay, mEventQueue);
2744     count++;
2745   }
2746   FINISH_DURATION_CHECK("ecore_wl2 & wl_display");
2747
2748   if(!mNotificationLevelChangeDone)
2749   {
2750     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState);
2751     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2752   }
2753   else if(mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2754   {
2755     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level);
2756     return Dali::WindowOperationResult::PERMISSION_DENIED;
2757   }
2758
2759   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel);
2760
2761   return Dali::WindowOperationResult::SUCCEED;
2762 }
2763
2764 Dali::WindowNotificationLevel WindowBaseEcoreWl2::GetNotificationLevel() const
2765 {
2766   while(!mTizenPolicy)
2767   {
2768     wl_display_dispatch_queue(mDisplay, mEventQueue);
2769   }
2770
2771   int count = 0;
2772
2773   while(!mNotificationLevelChangeDone && count < 3)
2774   {
2775     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2776     wl_display_dispatch_queue(mDisplay, mEventQueue);
2777     count++;
2778   }
2779
2780   if(!mNotificationLevelChangeDone)
2781   {
2782     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState);
2783     return Dali::WindowNotificationLevel::NONE;
2784   }
2785
2786   Dali::WindowNotificationLevel level;
2787
2788   switch(mNotificationLevel)
2789   {
2790     case TIZEN_POLICY_LEVEL_NONE:
2791     {
2792       level = Dali::WindowNotificationLevel::NONE;
2793       break;
2794     }
2795     case TIZEN_POLICY_LEVEL_DEFAULT:
2796     {
2797       level = Dali::WindowNotificationLevel::BASE;
2798       break;
2799     }
2800     case TIZEN_POLICY_LEVEL_MEDIUM:
2801     {
2802       level = Dali::WindowNotificationLevel::MEDIUM;
2803       break;
2804     }
2805     case TIZEN_POLICY_LEVEL_HIGH:
2806     {
2807       level = Dali::WindowNotificationLevel::HIGH;
2808       break;
2809     }
2810     case TIZEN_POLICY_LEVEL_TOP:
2811     {
2812       level = Dali::WindowNotificationLevel::TOP;
2813       break;
2814     }
2815     default:
2816     {
2817       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel);
2818       level = Dali::WindowNotificationLevel::NONE;
2819       break;
2820     }
2821   }
2822
2823   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel);
2824
2825   return level;
2826 }
2827
2828 void WindowBaseEcoreWl2::SetOpaqueState(bool opaque)
2829 {
2830   while(!mTizenPolicy)
2831   {
2832     wl_display_dispatch_queue(mDisplay, mEventQueue);
2833   }
2834
2835   tizen_policy_set_opaque_state(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), (opaque ? 1 : 0));
2836 }
2837
2838 Dali::WindowOperationResult WindowBaseEcoreWl2::SetScreenOffMode(WindowScreenOffMode screenOffMode)
2839 {
2840   while(!mTizenPolicy)
2841   {
2842     wl_display_dispatch_queue(mDisplay, mEventQueue);
2843   }
2844
2845   mScreenOffModeChangeDone  = false;
2846   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2847
2848   unsigned int mode = 0;
2849
2850   switch(screenOffMode)
2851   {
2852     case WindowScreenOffMode::TIMEOUT:
2853     {
2854       mode = 0;
2855       break;
2856     }
2857     case WindowScreenOffMode::NEVER:
2858     {
2859       mode = 1;
2860       break;
2861     }
2862   }
2863
2864   tizen_policy_set_window_screen_mode(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), mode);
2865
2866   int count = 0;
2867
2868   while(!mScreenOffModeChangeDone && count < 3)
2869   {
2870     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2871     wl_display_dispatch_queue(mDisplay, mEventQueue);
2872     count++;
2873   }
2874
2875   if(!mScreenOffModeChangeDone)
2876   {
2877     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState);
2878     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2879   }
2880   else if(mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2881   {
2882     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode);
2883     return Dali::WindowOperationResult::PERMISSION_DENIED;
2884   }
2885
2886   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode);
2887
2888   return Dali::WindowOperationResult::SUCCEED;
2889 }
2890
2891 WindowScreenOffMode WindowBaseEcoreWl2::GetScreenOffMode() const
2892 {
2893   while(!mTizenPolicy)
2894   {
2895     wl_display_dispatch_queue(mDisplay, mEventQueue);
2896   }
2897
2898   int count = 0;
2899
2900   while(!mScreenOffModeChangeDone && count < 3)
2901   {
2902     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2903     wl_display_dispatch_queue(mDisplay, mEventQueue);
2904     count++;
2905   }
2906
2907   if(!mScreenOffModeChangeDone)
2908   {
2909     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState);
2910     return WindowScreenOffMode::TIMEOUT;
2911   }
2912
2913   WindowScreenOffMode screenMode = WindowScreenOffMode::TIMEOUT;
2914
2915   switch(mScreenOffMode)
2916   {
2917     case 0:
2918     {
2919       screenMode = WindowScreenOffMode::TIMEOUT;
2920       break;
2921     }
2922     case 1:
2923     {
2924       screenMode = WindowScreenOffMode::NEVER;
2925       break;
2926     }
2927   }
2928
2929   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode);
2930
2931   return screenMode;
2932 }
2933
2934 Dali::WindowOperationResult WindowBaseEcoreWl2::SetBrightness(int brightness)
2935 {
2936   START_DURATION_CHECK();
2937   while(!mTizenDisplayPolicy)
2938   {
2939     wl_display_dispatch_queue(mDisplay, mEventQueue);
2940   }
2941
2942   mBrightnessChangeDone  = false;
2943   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2944
2945   tizen_display_policy_set_window_brightness(mTizenDisplayPolicy, ecore_wl2_window_surface_get(mEcoreWindow), brightness);
2946
2947   int count = 0;
2948
2949   while(!mBrightnessChangeDone && count < 3)
2950   {
2951     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2952     wl_display_dispatch_queue(mDisplay, mEventQueue);
2953     count++;
2954   }
2955   FINISH_DURATION_CHECK("ecore_wl2_display_flush");
2956
2957   if(!mBrightnessChangeDone)
2958   {
2959     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState);
2960     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2961   }
2962   else if(mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2963   {
2964     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness);
2965     return Dali::WindowOperationResult::PERMISSION_DENIED;
2966   }
2967
2968   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness);
2969
2970   return Dali::WindowOperationResult::SUCCEED;
2971 }
2972
2973 int WindowBaseEcoreWl2::GetBrightness() const
2974 {
2975   START_DURATION_CHECK();
2976   while(!mTizenDisplayPolicy)
2977   {
2978     wl_display_dispatch_queue(mDisplay, mEventQueue);
2979   }
2980
2981   int count = 0;
2982
2983   while(!mBrightnessChangeDone && count < 3)
2984   {
2985     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2986     wl_display_dispatch_queue(mDisplay, mEventQueue);
2987     count++;
2988   }
2989   FINISH_DURATION_CHECK("ecore_wl2_display_flush");
2990
2991   if(!mBrightnessChangeDone)
2992   {
2993     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState);
2994     return 0;
2995   }
2996
2997   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness);
2998
2999   return mBrightness;
3000 }
3001
3002 bool WindowBaseEcoreWl2::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
3003 {
3004   Ecore_Wl2_Window_Keygrab_Mode mode;
3005
3006   switch(grabMode)
3007   {
3008     case KeyGrab::TOPMOST:
3009     {
3010       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
3011       break;
3012     }
3013     case KeyGrab::SHARED:
3014     {
3015       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
3016       break;
3017     }
3018     case KeyGrab::OVERRIDE_EXCLUSIVE:
3019     {
3020       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
3021       break;
3022     }
3023     case KeyGrab::EXCLUSIVE:
3024     {
3025       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
3026       break;
3027     }
3028     default:
3029     {
3030       return false;
3031     }
3032   }
3033
3034   return ecore_wl2_window_keygrab_set(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0, 0, mode);
3035 }
3036
3037 bool WindowBaseEcoreWl2::UngrabKey(Dali::KEY key)
3038 {
3039   return ecore_wl2_window_keygrab_unset(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0);
3040 }
3041
3042 bool WindowBaseEcoreWl2::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
3043 {
3044   int keyCount         = key.Count();
3045   int keyGrabModeCount = grabMode.Count();
3046
3047   if(keyCount != keyGrabModeCount || keyCount == 0)
3048   {
3049     return false;
3050   }
3051
3052   eina_init();
3053
3054   Eina_List*                     keyList = NULL;
3055   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
3056
3057   for(int index = 0; index < keyCount; ++index)
3058   {
3059     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
3060
3061     switch(grabMode[index])
3062     {
3063       case KeyGrab::TOPMOST:
3064       {
3065         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
3066         break;
3067       }
3068       case KeyGrab::SHARED:
3069       {
3070         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
3071         break;
3072       }
3073       case KeyGrab::OVERRIDE_EXCLUSIVE:
3074       {
3075         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
3076         break;
3077       }
3078       case KeyGrab::EXCLUSIVE:
3079       {
3080         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
3081         break;
3082       }
3083       default:
3084       {
3085         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
3086         break;
3087       }
3088     }
3089
3090     keyList = eina_list_append(keyList, &info);
3091   }
3092
3093   START_DURATION_CHECK();
3094   Eina_List* grabList = ecore_wl2_window_keygrab_list_set(mEcoreWindow, keyList);
3095   FINISH_DURATION_CHECK("ecore_wl2_window_keygrab_list_set");
3096
3097   result.Resize(keyCount, true);
3098
3099   Eina_List* l        = NULL;
3100   Eina_List* m        = NULL;
3101   void*      listData = NULL;
3102   void*      data     = NULL;
3103   if(grabList != NULL)
3104   {
3105     EINA_LIST_FOREACH(grabList, m, data)
3106     {
3107       int index = 0;
3108       EINA_LIST_FOREACH(keyList, l, listData)
3109       {
3110         if(static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key == NULL)
3111         {
3112           DALI_LOG_ERROR("input key list has null data!");
3113           break;
3114         }
3115
3116         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
3117         {
3118           result[index] = false;
3119         }
3120         ++index;
3121       }
3122     }
3123   }
3124
3125   delete[] info;
3126
3127   eina_list_free(keyList);
3128   eina_list_free(grabList);
3129   eina_shutdown();
3130
3131   return true;
3132 }
3133
3134 bool WindowBaseEcoreWl2::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
3135 {
3136   int keyCount = key.Count();
3137   if(keyCount == 0)
3138   {
3139     return false;
3140   }
3141
3142   eina_init();
3143
3144   Eina_List*                     keyList = NULL;
3145   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
3146
3147   for(int index = 0; index < keyCount; ++index)
3148   {
3149     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
3150     keyList         = eina_list_append(keyList, &info);
3151   }
3152
3153   START_DURATION_CHECK();
3154   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset(mEcoreWindow, keyList);
3155   FINISH_DURATION_CHECK("ecore_wl2_window_keygrab_list_unset");
3156
3157   result.Resize(keyCount, true);
3158
3159   Eina_List* l        = NULL;
3160   Eina_List* m        = NULL;
3161   void*      listData = NULL;
3162   void*      data     = NULL;
3163
3164   if(ungrabList != NULL)
3165   {
3166     EINA_LIST_FOREACH(ungrabList, m, data)
3167     {
3168       int index = 0;
3169       EINA_LIST_FOREACH(keyList, l, listData)
3170       {
3171         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
3172         {
3173           result[index] = false;
3174         }
3175         ++index;
3176       }
3177     }
3178   }
3179
3180   delete[] info;
3181
3182   eina_list_free(keyList);
3183   eina_list_free(ungrabList);
3184   eina_shutdown();
3185
3186   return true;
3187 }
3188
3189 void WindowBaseEcoreWl2::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
3190 {
3191   // calculate DPI
3192   float xres, yres;
3193
3194   Ecore_Wl2_Output* output = ecore_wl2_window_output_find(mEcoreWindow);
3195
3196   // 1 inch = 25.4 millimeters
3197   xres = ecore_wl2_output_dpi_get(output);
3198   yres = ecore_wl2_output_dpi_get(output);
3199
3200   dpiHorizontal = int(xres + 0.5f); // rounding
3201   dpiVertical   = int(yres + 0.5f);
3202 }
3203
3204 int WindowBaseEcoreWl2::GetWindowRotationAngle() const
3205 {
3206   int orientation = mWindowRotationAngle;
3207   if(mSupportedPreProtation)
3208   {
3209     orientation = 0;
3210   }
3211   return orientation;
3212 }
3213
3214 int WindowBaseEcoreWl2::GetScreenRotationAngle()
3215 {
3216   if(mSupportedPreProtation)
3217   {
3218     DALI_LOG_RELEASE_INFO("Support PreRotation and return 0\n");
3219     return 0;
3220   }
3221   int transform;
3222   if(ecore_wl2_window_ignore_output_transform_get(mEcoreWindow))
3223   {
3224     transform = 0;
3225   }
3226   else
3227   {
3228     transform = ecore_wl2_output_transform_get(ecore_wl2_window_output_find(mEcoreWindow));
3229   }
3230   mScreenRotationAngle = transform * 90;
3231   return mScreenRotationAngle;
3232 }
3233
3234 void WindowBaseEcoreWl2::SetWindowRotationAngle(int degree)
3235 {
3236   mWindowRotationAngle = degree;
3237   ecore_wl2_window_rotation_set(mEcoreWindow, degree);
3238 }
3239
3240 void WindowBaseEcoreWl2::WindowRotationCompleted(int degree, int width, int height)
3241 {
3242   START_DURATION_CHECK();
3243   ecore_wl2_window_rotation_change_done_send(mEcoreWindow, degree, width, height);
3244   FINISH_DURATION_CHECK("ecore_wl2_window_rotation_change_done_send");
3245 }
3246
3247 void WindowBaseEcoreWl2::SetTransparency(bool transparent)
3248 {
3249   START_DURATION_CHECK();
3250   ecore_wl2_window_alpha_set(mEcoreWindow, transparent);
3251   FINISH_DURATION_CHECK("ecore_wl2_window_alpha_set");
3252 }
3253
3254 void WindowBaseEcoreWl2::CreateWindow(PositionSize positionSize)
3255 {
3256   Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
3257   if(!display)
3258   {
3259     DALI_ASSERT_ALWAYS(0 && "Failed to get display");
3260   }
3261
3262   START_DURATION_CHECK();
3263   ecore_wl2_display_sync(display);
3264
3265   mEcoreWindow = ecore_wl2_window_new(display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
3266
3267   if(mEcoreWindow == 0)
3268   {
3269     DALI_ASSERT_ALWAYS(0 && "Failed to create Wayland window");
3270   }
3271
3272   // Set default type
3273   ecore_wl2_window_type_set(mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
3274   FINISH_DURATION_CHECK("ecore_wl2 functions");
3275 }
3276
3277 void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase, bool belowParent)
3278 {
3279   Ecore_Wl2_Window* ecoreParent = NULL;
3280   if(parentWinBase)
3281   {
3282     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
3283     ecoreParent                       = winBaseEcore2->mEcoreWindow;
3284   }
3285
3286   START_DURATION_CHECK();
3287   ecore_wl2_window_transient_parent_set(mEcoreWindow, ecoreParent, belowParent);
3288   FINISH_DURATION_CHECK("ecore_wl2_window_transient_parent_set");
3289 }
3290
3291 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
3292 {
3293   return wl_egl_window_tizen_create_commit_sync_fd(mEglWindow);
3294 }
3295
3296 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
3297 {
3298   return wl_egl_window_tizen_create_presentation_sync_fd(mEglWindow);
3299 }
3300
3301 void WindowBaseEcoreWl2::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
3302 {
3303   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);
3304   START_DURATION_CHECK();
3305   ecore_wl2_window_rotation_geometry_set(mEcoreWindow, angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
3306   FINISH_DURATION_CHECK("ecore_wl2_window_rotation_geometry_set");
3307 }
3308
3309 void WindowBaseEcoreWl2::InitializeIme()
3310 {
3311   Eina_Iterator*      globals;
3312   struct wl_registry* registry;
3313   Ecore_Wl2_Global*   global;
3314   Ecore_Wl2_Display*  ecoreWl2Display;
3315
3316   if(mIsIMEWindowInitialized)
3317   {
3318     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::InitializeIme, IME Window is already initialized\n");
3319     return;
3320   }
3321
3322   if(!(ecoreWl2Display = ecore_wl2_connected_display_get(NULL)))
3323   {
3324     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 connected display\n");
3325     return;
3326   }
3327
3328   DALI_LOG_RELEASE_INFO("InitializeIme:  Ecore_Wl2_Display: %p, ecore wl window: %p, mIsIMEWindowInitialized: %d\n", ecoreWl2Display, mEcoreWindow, mIsIMEWindowInitialized);
3329
3330   if(!(registry = ecore_wl2_display_registry_get(ecoreWl2Display)))
3331   {
3332     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 display registry\n");
3333     return;
3334   }
3335
3336   if(!(globals = ecore_wl2_display_globals_get(ecoreWl2Display)))
3337   {
3338     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 globals\n");
3339     return;
3340   }
3341
3342   START_DURATION_CHECK();
3343   EINA_ITERATOR_FOREACH(globals, global)
3344   {
3345 #ifdef OVER_TIZEN_VERSION_7
3346     if(strcmp(global->interface, "zwp_input_panel_v1") == 0)
3347     {
3348       mWlInputPanel = (zwp_input_panel_v1*)wl_registry_bind(registry, global->id, &zwp_input_panel_v1_interface, 1);
3349     }
3350 #else
3351     if(strcmp(global->interface, "wl_input_panel") == 0)
3352     {
3353       mWlInputPanel = (wl_input_panel*)wl_registry_bind(registry, global->id, &wl_input_panel_interface, 1);
3354     }
3355 #endif
3356     else if(strcmp(global->interface, "wl_output") == 0)
3357     {
3358       mWlOutput = (wl_output*)wl_registry_bind(registry, global->id, &wl_output_interface, 1);
3359     }
3360   }
3361
3362   if(!mWlInputPanel)
3363   {
3364     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel interface\n");
3365     return;
3366   }
3367
3368   if(!mWlOutput)
3369   {
3370     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland output panel interface\n");
3371     return;
3372   }
3373 #ifdef OVER_TIZEN_VERSION_7
3374   mWlInputPanelSurface = zwp_input_panel_v1_get_input_panel_surface(mWlInputPanel, mWlSurface);
3375 #else
3376   mWlInputPanelSurface = wl_input_panel_get_input_panel_surface(mWlInputPanel, mWlSurface);
3377 #endif
3378   if(!mWlInputPanelSurface)
3379   {
3380     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel surface\n");
3381     return;
3382   }
3383 #ifdef OVER_TIZEN_VERSION_7
3384   zwp_input_panel_surface_v1_set_toplevel(mWlInputPanelSurface, mWlOutput, ZWP_INPUT_PANEL_SURFACE_V1_POSITION_CENTER_BOTTOM);
3385 #else
3386   wl_input_panel_surface_set_toplevel(mWlInputPanelSurface, mWlOutput, WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
3387 #endif
3388   FINISH_DURATION_CHECK("zwp_input_panel_surface_v1_set_toplevel");
3389   mIsIMEWindowInitialized = true;
3390 }
3391
3392 void WindowBaseEcoreWl2::ImeWindowReadyToRender()
3393 {
3394   if(!mWlInputPanelSurface)
3395   {
3396     DALI_LOG_ERROR("WindowBaseEcoreWl2::ImeWindowReadyToRender(), wayland input panel surface is null\n");
3397     return;
3398   }
3399
3400   START_DURATION_CHECK();
3401 #ifdef OVER_TIZEN_VERSION_7
3402   zwp_input_panel_surface_v1_set_ready(mWlInputPanelSurface, 1);
3403 #else
3404   wl_input_panel_surface_set_ready(mWlInputPanelSurface, 1);
3405 #endif
3406   FINISH_DURATION_CHECK("zwp_input_panel_surface_v1_set_ready");
3407 }
3408
3409 void WindowBaseEcoreWl2::RequestMoveToServer()
3410 {
3411   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
3412   if(!display)
3413   {
3414     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get ecore_wl2_display\n");
3415     return;
3416   }
3417
3418   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
3419   if(!input)
3420   {
3421     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get default Ecore_Wl2_Input\n");
3422     return;
3423   }
3424
3425   START_DURATION_CHECK();
3426   ecore_wl2_window_move(mEcoreWindow, input);
3427   FINISH_DURATION_CHECK("ecore_wl2_window_move");
3428   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestMoveToServer, starts the window[%p] is moved by server\n", mEcoreWindow);
3429 }
3430
3431 void WindowBaseEcoreWl2::RequestResizeToServer(WindowResizeDirection direction)
3432 {
3433   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
3434   if(!display)
3435   {
3436     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get ecore_wl2_display\n");
3437     return;
3438   }
3439
3440   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
3441   if(!input)
3442   {
3443     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get default Ecore_Wl2_Input\n");
3444     return;
3445   }
3446
3447   ResizeLocation location = RecalculateLocationToCurrentOrientation(direction, mWindowRotationAngle);
3448
3449   START_DURATION_CHECK();
3450   ecore_wl2_window_resize(mEcoreWindow, input, static_cast<int>(location));
3451   FINISH_DURATION_CHECK("ecore_wl2_window_resize");
3452   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);
3453 }
3454
3455 void WindowBaseEcoreWl2::EnableFloatingMode(bool enable)
3456 {
3457   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EnableFloatingMode, floating mode flag: [%p], enable [%d]\n", mEcoreWindow, enable);
3458   START_DURATION_CHECK();
3459   if(enable == true)
3460   {
3461     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_TRUE);
3462   }
3463   else
3464   {
3465     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_FALSE);
3466   }
3467   FINISH_DURATION_CHECK("ecore_wl2_window_floating_mode_set");
3468 }
3469
3470 bool WindowBaseEcoreWl2::IsFloatingModeEnabled() const
3471 {
3472   return ecore_wl2_window_floating_mode_get(mEcoreWindow);
3473 }
3474
3475 void WindowBaseEcoreWl2::IncludeInputRegion(const Rect<int>& inputRegion)
3476 {
3477   Rect<int>      convertRegion = RecalculatePositionSizeToSystem(inputRegion);
3478   Eina_Rectangle rect;
3479
3480   rect.x = convertRegion.x;
3481   rect.y = convertRegion.y;
3482   rect.w = convertRegion.width;
3483   rect.h = convertRegion.height;
3484
3485   DALI_LOG_RELEASE_INFO("%p, Add input_rect(%d, %d, %d x %d)\n", mEcoreWindow, rect.x, rect.y, rect.w, rect.h);
3486   START_DURATION_CHECK();
3487   ecore_wl2_window_input_rect_add(mEcoreWindow, &rect);
3488   FINISH_DURATION_CHECK("ecore_wl2_window_input_rect_add");
3489   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
3490 }
3491
3492 void WindowBaseEcoreWl2::ExcludeInputRegion(const Rect<int>& inputRegion)
3493 {
3494   Rect<int>      convertRegion = RecalculatePositionSizeToSystem(inputRegion);
3495   Eina_Rectangle rect;
3496
3497   rect.x = convertRegion.x;
3498   rect.y = convertRegion.y;
3499   rect.w = convertRegion.width;
3500   rect.h = convertRegion.height;
3501
3502   DALI_LOG_RELEASE_INFO("%p, Subtract input_rect(%d, %d, %d x %d)\n", mEcoreWindow, rect.x, rect.y, rect.w, rect.h);
3503   START_DURATION_CHECK();
3504   ecore_wl2_window_input_rect_subtract(mEcoreWindow, &rect);
3505   FINISH_DURATION_CHECK("ecore_wl2_window_input_rect_subtract");
3506   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
3507 }
3508
3509 bool WindowBaseEcoreWl2::PointerConstraintsLock()
3510 {
3511 #ifdef OVER_TIZEN_VERSION_8
3512   return ecore_wl2_window_pointer_constraints_lock_pointer(mEcoreWindow);
3513 #else
3514   return false;
3515 #endif
3516 }
3517
3518 bool WindowBaseEcoreWl2::PointerConstraintsUnlock()
3519 {
3520 #ifdef OVER_TIZEN_VERSION_8
3521   return ecore_wl2_window_pointer_constraints_unlock_pointer(mEcoreWindow);
3522 #else
3523   return false;
3524 #endif
3525 }
3526
3527 void WindowBaseEcoreWl2::LockedPointerRegionSet(int32_t x, int32_t y, int32_t width, int32_t height)
3528 {
3529 #ifdef OVER_TIZEN_VERSION_8
3530   ecore_wl2_window_locked_pointer_region_set(mEcoreWindow, x, y, width, height);
3531   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
3532 #endif
3533 }
3534
3535 void WindowBaseEcoreWl2::LockedPointerCursorPositionHintSet(int32_t x, int32_t y)
3536 {
3537 #ifdef OVER_TIZEN_VERSION_8
3538   ecore_wl2_window_locked_pointer_cursor_position_hint_set(mEcoreWindow, x, y);
3539   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
3540 #endif
3541 }
3542
3543 bool WindowBaseEcoreWl2::PointerWarp(int32_t x, int32_t y)
3544 {
3545   return ecore_wl2_window_pointer_warp(mEcoreWindow, x, y);
3546 }
3547
3548 void WindowBaseEcoreWl2::CursorVisibleSet(bool visible)
3549 {
3550 #ifdef OVER_TIZEN_VERSION_8
3551   ecore_wl2_window_cursor_visible_set(mEcoreWindow, visible);
3552 #endif
3553 }
3554
3555 // Request grab key events according to the requested device subtype
3556 //(For now, subtype could be '0'/'11'/'12' which equals to ECORE_DEVICE_SUBCLASS_NONE/REMOCON/VIRTUAL_KEYBOARD)
3557 bool WindowBaseEcoreWl2::KeyboardGrab(Device::Subclass::Type deviceSubclass)
3558 {
3559 #ifdef OVER_TIZEN_VERSION_8
3560   Ecore_Device_Subclass ecoreDeviceSubclass;
3561   switch(deviceSubclass)
3562   {
3563     case Device::Subclass::NONE:
3564     {
3565       ecoreDeviceSubclass = ECORE_DEVICE_SUBCLASS_NONE;
3566       break;
3567     }
3568     case Device::Subclass::REMOCON:
3569     {
3570       ecoreDeviceSubclass = ECORE_DEVICE_SUBCLASS_REMOCON;
3571       break;
3572     }
3573     case Device::Subclass::VIRTUAL_KEYBOARD:
3574     {
3575       ecoreDeviceSubclass = ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD;
3576       break;
3577     }
3578     default:
3579     {
3580       DALI_LOG_ERROR("deviceSubclass : %d type is not support, subtype could be 'NONE', 'REMOCON', 'VIRTUAL_KEYBOARD'\n");
3581       return false;
3582     }
3583   }
3584   return ecore_wl2_window_keyboard_grab(mEcoreWindow, ecoreDeviceSubclass);
3585 #else
3586   return false;
3587 #endif
3588 }
3589
3590 // Request ungrab key events
3591 bool WindowBaseEcoreWl2::KeyboardUnGrab()
3592 {
3593 #ifdef OVER_TIZEN_VERSION_8
3594   return ecore_wl2_window_keyboard_ungrab(mEcoreWindow);
3595 #else
3596   return false;
3597 #endif
3598 }
3599
3600 void WindowBaseEcoreWl2::SetFullScreen(bool fullscreen)
3601 {
3602   DALI_LOG_RELEASE_INFO("ecore_wl2_window_fullscreen_set, window: [%p], fullscreen [%d]\n", mEcoreWindow, fullscreen);
3603   START_DURATION_CHECK();
3604   ecore_wl2_window_fullscreen_set(mEcoreWindow, fullscreen);
3605   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
3606   FINISH_DURATION_CHECK("ecore_wl2_window_fullscreen_set");
3607 }
3608
3609 bool WindowBaseEcoreWl2::GetFullScreen()
3610 {
3611   return ecore_wl2_window_fullscreen_get(mEcoreWindow);
3612 }
3613
3614 void WindowBaseEcoreWl2::SetFrontBufferRendering(bool enable)
3615 {
3616   mIsFrontBufferRendering = enable;
3617 }
3618
3619 bool WindowBaseEcoreWl2::GetFrontBufferRendering()
3620 {
3621   return mIsFrontBufferRendering;
3622 }
3623
3624 void WindowBaseEcoreWl2::SetEglWindowFrontBufferMode(bool enable)
3625 {
3626   wl_egl_window_tizen_set_frontbuffer_mode(mEglWindow, enable);
3627 }
3628
3629 } // namespace Adaptor
3630
3631 } // namespace Internal
3632
3633 } // namespace Dali
3634
3635 #pragma GCC diagnostic pop