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