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

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