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

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