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