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  = ev->w;
1096     int tempHeight = 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     mMaximizeChangedSignal.Emit(static_cast<bool>(ev->states & ECORE_WL2_WINDOW_STATE_MAXIMIZED));
1133
1134     ecore_wl2_window_commit(mEcoreWindow, EINA_FALSE);
1135   }
1136 }
1137
1138 void WindowBaseEcoreWl2::OnMouseButtonDown(void* data, int type, void* event)
1139 {
1140   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1141
1142   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
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     Device::Class::Type    deviceClass;
1185     Device::Subclass::Type deviceSubclass;
1186
1187     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1188     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1189
1190     Integration::Point point;
1191     point.SetDeviceId(touchEvent->multi.device);
1192     point.SetState(PointState::UP);
1193     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1194     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1195     point.SetPressure(touchEvent->multi.pressure);
1196     point.SetAngle(Degree(touchEvent->multi.angle));
1197     point.SetDeviceClass(deviceClass);
1198     point.SetDeviceSubclass(deviceSubclass);
1199     point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
1200
1201     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1202   }
1203 }
1204
1205 void WindowBaseEcoreWl2::OnMouseButtonMove(void* data, int type, void* event)
1206 {
1207   Ecore_Event_Mouse_Move* touchEvent = static_cast<Ecore_Event_Mouse_Move*>(event);
1208
1209   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1210   {
1211     Device::Class::Type    deviceClass;
1212     Device::Subclass::Type deviceSubclass;
1213
1214     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
1215     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
1216
1217     Integration::Point point;
1218     point.SetDeviceId(touchEvent->multi.device);
1219     point.SetState(PointState::MOTION);
1220     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
1221     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
1222     point.SetPressure(touchEvent->multi.pressure);
1223     point.SetAngle(Degree(touchEvent->multi.angle));
1224     point.SetDeviceClass(deviceClass);
1225     point.SetDeviceSubclass(deviceSubclass);
1226
1227     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1228   }
1229 }
1230
1231 void WindowBaseEcoreWl2::OnMouseButtonCancel(void* data, int type, void* event)
1232 {
1233   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
1234
1235   if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1236   {
1237     Integration::Point point;
1238     point.SetDeviceId(touchEvent->multi.device);
1239     point.SetState(PointState::INTERRUPTED);
1240     point.SetScreenPosition(Vector2(0.0f, 0.0f));
1241
1242     mTouchEventSignal.Emit(point, touchEvent->timestamp);
1243
1244     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseButtonCancel\n");
1245   }
1246 }
1247
1248 void WindowBaseEcoreWl2::OnMouseWheel(void* data, int type, void* event)
1249 {
1250   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast<Ecore_Event_Mouse_Wheel*>(event);
1251
1252   if(mouseWheelEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1253   {
1254     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);
1255
1256     Integration::WheelEvent wheelEvent(Integration::WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp);
1257
1258     mWheelEventSignal.Emit(wheelEvent);
1259   }
1260 }
1261
1262 void WindowBaseEcoreWl2::OnDetentRotation(void* data, int type, void* event)
1263 {
1264   Ecore_Event_Detent_Rotate* detentEvent = static_cast<Ecore_Event_Detent_Rotate*>(event);
1265
1266   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n");
1267
1268   int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
1269
1270   Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, detentEvent->direction, 0, Vector2(0.0f, 0.0f), clockwise, detentEvent->timestamp);
1271
1272   mWheelEventSignal.Emit(wheelEvent);
1273 }
1274
1275 void WindowBaseEcoreWl2::OnKeyDown(void* data, int type, void* event)
1276 {
1277   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1278
1279   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1280   {
1281     std::string keyName(keyEvent->keyname);
1282     std::string logicalKey("");
1283     std::string keyString("");
1284     std::string compose("");
1285
1286     DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_KEY_DOWN");
1287
1288     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1289     if(keyEvent->compose)
1290     {
1291       compose = keyEvent->compose;
1292     }
1293
1294     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1295     if(keyEvent->key)
1296     {
1297       logicalKey = keyEvent->key;
1298     }
1299
1300     int keyCode = 0;
1301     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1302
1303     if(keyCode == 0)
1304     {
1305       // Get a specific key code from dali key look up table.
1306       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1307     }
1308
1309     keyCode = (keyCode == -1) ? 0 : keyCode;
1310     int           modifier(keyEvent->modifiers);
1311     unsigned long time = keyEvent->timestamp;
1312     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1313     {
1314       keyCode = atoi(keyEvent->keyname + 8);
1315     }
1316
1317     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1318     if(keyEvent->string)
1319     {
1320       keyString = keyEvent->string;
1321     }
1322
1323     std::string            deviceName;
1324     Device::Class::Type    deviceClass;
1325     Device::Subclass::Type deviceSubclass;
1326
1327     GetDeviceName(keyEvent, deviceName);
1328     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1329     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1330
1331     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass);
1332
1333     mKeyEventSignal.Emit(keyEvent);
1334   }
1335 }
1336
1337 void WindowBaseEcoreWl2::OnKeyUp(void* data, int type, void* event)
1338 {
1339   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1340
1341   if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
1342   {
1343 #if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
1344     // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
1345     if(keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL)
1346     {
1347       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp: This event flag indicates the event is canceled. \n");
1348       return;
1349     }
1350 #endif // Since ecore 1.23 version
1351
1352     std::string keyName(keyEvent->keyname);
1353     std::string logicalKey("");
1354     std::string keyString("");
1355     std::string compose("");
1356
1357     DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_KEY_UP");
1358
1359     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1360     if(keyEvent->compose)
1361     {
1362       compose = keyEvent->compose;
1363     }
1364
1365     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1366     if(keyEvent->key)
1367     {
1368       logicalKey = keyEvent->key;
1369     }
1370
1371     int keyCode = 0;
1372     GetKeyCode(keyName, keyCode); // Get key code dynamically.
1373
1374     if(keyCode == 0)
1375     {
1376       // Get a specific key code from dali key look up table.
1377       keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1378     }
1379
1380     keyCode = (keyCode == -1) ? 0 : keyCode;
1381     int           modifier(keyEvent->modifiers);
1382     unsigned long time = keyEvent->timestamp;
1383     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1384     {
1385       keyCode = atoi(keyEvent->keyname + 8);
1386     }
1387
1388     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1389     if(keyEvent->string)
1390     {
1391       keyString = keyEvent->string;
1392     }
1393
1394     std::string            deviceName;
1395     Device::Class::Type    deviceClass;
1396     Device::Subclass::Type deviceSubclass;
1397
1398     GetDeviceName(keyEvent, deviceName);
1399     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1400     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1401
1402     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
1403
1404     mKeyEventSignal.Emit(keyEvent);
1405   }
1406 }
1407
1408 void WindowBaseEcoreWl2::OnDataSend(void* data, int type, void* event)
1409 {
1410   mSelectionDataSendSignal.Emit(event);
1411 }
1412
1413 void WindowBaseEcoreWl2::OnDataReceive(void* data, int type, void* event)
1414 {
1415   mSelectionDataReceivedSignal.Emit(event);
1416 }
1417
1418 void WindowBaseEcoreWl2::OnFontNameChanged()
1419 {
1420   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
1421 }
1422
1423 void WindowBaseEcoreWl2::OnFontSizeChanged()
1424 {
1425   mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
1426 }
1427
1428 void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
1429 {
1430   mTransitionEffectEventSignal.Emit(state, type);
1431 }
1432
1433 void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
1434 {
1435   mKeyboardRepeatSettingsChangedSignal.Emit();
1436 }
1437
1438 void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
1439 {
1440   mWindowRedrawRequestSignal.Emit();
1441 }
1442
1443 void WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage(void* event)
1444 {
1445   Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
1446   if(message)
1447   {
1448     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, key:%s, value:%s \n", message->key, message->val);
1449     std::string           key(message->key);
1450     std::string           value(message->val);
1451     Dali::Property::Array options;
1452
1453     if(message->options)
1454     {
1455       Eina_List* l;
1456       void*      data;
1457       EINA_LIST_FOREACH(message->options, l, data)
1458       {
1459         DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, option: %s\n", (char*)data);
1460         std::string option(static_cast<char*>(data));
1461         options.Add(option);
1462       }
1463     }
1464
1465     mAuxiliaryMessageSignal.Emit(key, value, options);
1466   }
1467 }
1468
1469 void WindowBaseEcoreWl2::KeymapChanged(void* data, int type, void* event)
1470 {
1471   Ecore_Wl2_Event_Seat_Keymap_Changed* changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>(event);
1472   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id);
1473   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(changed->display);
1474   if(ecoreWlInput)
1475   {
1476     mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
1477   }
1478 }
1479
1480 void WindowBaseEcoreWl2::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
1481 {
1482   if(strcmp(interface, tizen_policy_interface.name) == 0)
1483   {
1484     uint32_t clientVersion = std::min(version, MAX_TIZEN_CLIENT_VERSION);
1485
1486     mTizenPolicy = static_cast<tizen_policy*>(wl_registry_bind(registry, name, &tizen_policy_interface, clientVersion));
1487     if(!mTizenPolicy)
1488     {
1489       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n");
1490       return;
1491     }
1492
1493     tizen_policy_add_listener(mTizenPolicy, &tizenPolicyListener, data);
1494
1495     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n");
1496   }
1497   else if(strcmp(interface, tizen_display_policy_interface.name) == 0)
1498   {
1499     mTizenDisplayPolicy = static_cast<tizen_display_policy*>(wl_registry_bind(registry, name, &tizen_display_policy_interface, version));
1500     if(!mTizenDisplayPolicy)
1501     {
1502       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n");
1503       return;
1504     }
1505
1506     tizen_display_policy_add_listener(mTizenDisplayPolicy, &tizenDisplayPolicyListener, data);
1507
1508     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n");
1509   }
1510 }
1511
1512 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
1513 {
1514   mTizenPolicy        = NULL;
1515   mTizenDisplayPolicy = NULL;
1516 }
1517
1518 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
1519 {
1520   mNotificationLevel           = level;
1521   mNotificationChangeState     = state;
1522   mNotificationLevelChangeDone = true;
1523
1524   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state);
1525 }
1526
1527 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
1528 {
1529   mScreenOffMode            = mode;
1530   mScreenOffModeChangeState = state;
1531   mScreenOffModeChangeDone  = true;
1532
1533   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state);
1534 }
1535
1536 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
1537 {
1538   mBrightness            = brightness;
1539   mBrightnessChangeState = state;
1540   mBrightnessChangeDone  = true;
1541
1542   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state);
1543 }
1544
1545 void WindowBaseEcoreWl2::GetKeyCode(std::string keyName, int32_t& keyCode)
1546 {
1547   xkb_keysym_t sym = XKB_KEY_NoSymbol;
1548   KeyCodeMap   foundKeyCode;
1549
1550   sym = xkb_keysym_from_name(keyName.c_str(), XKB_KEYSYM_NO_FLAGS);
1551   if(sym == XKB_KEY_NoSymbol)
1552   {
1553     DALI_LOG_ERROR("Failed to get keysym in WindowBaseEcoreWl2\n");
1554     return;
1555   }
1556
1557   foundKeyCode.keySym    = sym;
1558   foundKeyCode.isKeyCode = false;
1559   xkb_keymap_key_for_each(mKeyMap, FindKeyCode, &foundKeyCode);
1560   keyCode = static_cast<int32_t>(foundKeyCode.keyCode);
1561 }
1562
1563 Any WindowBaseEcoreWl2::GetNativeWindow()
1564 {
1565   return mEcoreWindow;
1566 }
1567
1568 int WindowBaseEcoreWl2::GetNativeWindowId()
1569 {
1570   return ecore_wl2_window_id_get(mEcoreWindow);
1571 }
1572
1573 std::string WindowBaseEcoreWl2::GetNativeWindowResourceId()
1574 {
1575 #ifdef OVER_TIZEN_VERSION_7
1576   return std::to_string(ecore_wl2_window_resource_id_get(mEcoreWindow));
1577 #else
1578   return std::string();
1579 #endif
1580 }
1581
1582 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow(int width, int height)
1583 {
1584   int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
1585   if(totalAngle == 90 || totalAngle == 270)
1586   {
1587     mEglWindow = wl_egl_window_create(mWlSurface, height, width);
1588   }
1589   else
1590   {
1591     mEglWindow = wl_egl_window_create(mWlSurface, width, height);
1592   }
1593
1594   return static_cast<EGLNativeWindowType>(mEglWindow);
1595 }
1596
1597 void WindowBaseEcoreWl2::DestroyEglWindow()
1598 {
1599   if(mEglWindow != NULL)
1600   {
1601     wl_egl_window_destroy(mEglWindow);
1602     mEglWindow = NULL;
1603   }
1604 }
1605
1606 void WindowBaseEcoreWl2::SetEglWindowRotation(int angle)
1607 {
1608   wl_egl_window_tizen_rotation rotation;
1609
1610   switch(angle)
1611   {
1612     case 0:
1613     {
1614       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1615       break;
1616     }
1617     case 90:
1618     {
1619       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
1620       break;
1621     }
1622     case 180:
1623     {
1624       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
1625       break;
1626     }
1627     case 270:
1628     {
1629       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
1630       break;
1631     }
1632     default:
1633     {
1634       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0;
1635       break;
1636     }
1637   }
1638
1639   wl_egl_window_tizen_set_rotation(mEglWindow, rotation);
1640 }
1641
1642 void WindowBaseEcoreWl2::SetEglWindowBufferTransform(int angle)
1643 {
1644   wl_output_transform bufferTransform;
1645
1646   switch(angle)
1647   {
1648     case 0:
1649     {
1650       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1651       break;
1652     }
1653     case 90:
1654     {
1655       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1656       break;
1657     }
1658     case 180:
1659     {
1660       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1661       break;
1662     }
1663     case 270:
1664     {
1665       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1666       break;
1667     }
1668     default:
1669     {
1670       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1671       break;
1672     }
1673   }
1674
1675   DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_buffer_transform() with buffer Transform [%d]\n", bufferTransform);
1676   wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
1677 }
1678
1679 void WindowBaseEcoreWl2::SetEglWindowTransform(int angle)
1680 {
1681   wl_output_transform windowTransform;
1682
1683   switch(angle)
1684   {
1685     case 0:
1686     {
1687       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1688       break;
1689     }
1690     case 90:
1691     {
1692       windowTransform = WL_OUTPUT_TRANSFORM_90;
1693       break;
1694     }
1695     case 180:
1696     {
1697       windowTransform = WL_OUTPUT_TRANSFORM_180;
1698       break;
1699     }
1700     case 270:
1701     {
1702       windowTransform = WL_OUTPUT_TRANSFORM_270;
1703       break;
1704     }
1705     default:
1706     {
1707       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1708       break;
1709     }
1710   }
1711
1712   DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_window_transform() with window Transform [%d]\n", windowTransform);
1713   wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
1714 }
1715
1716 void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
1717 {
1718   DALI_LOG_RELEASE_INFO("wl_egl_window_resize(), (%d, %d) [%d x %d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height);
1719   wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
1720
1721   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
1722   if(mMoveResizeSerial != mLastSubmittedMoveResizeSerial)
1723   {
1724     wl_egl_window_tizen_set_window_serial(mEglWindow, mMoveResizeSerial);
1725     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
1726   }
1727 }
1728
1729 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
1730 {
1731   // Check capability
1732   wl_egl_window_tizen_capability capability = static_cast<wl_egl_window_tizen_capability>(wl_egl_window_tizen_get_capabilities(mEglWindow));
1733   if(capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED)
1734   {
1735     mSupportedPreProtation = true;
1736     return true;
1737   }
1738   mSupportedPreProtation = false;
1739   return false;
1740 }
1741
1742 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToSystem(PositionSize positionSize)
1743 {
1744   PositionSize newPositionSize;
1745   int32_t      screenWidth, screenHeight;
1746   WindowSystem::GetScreenSize(screenWidth, screenHeight);
1747
1748   if(mWindowRotationAngle == 90)
1749   {
1750     newPositionSize.x      = positionSize.y;
1751     newPositionSize.y      = screenHeight - (positionSize.x + positionSize.width);
1752     newPositionSize.width  = positionSize.height;
1753     newPositionSize.height = positionSize.width;
1754   }
1755   else if(mWindowRotationAngle == 180)
1756   {
1757     newPositionSize.x      = screenWidth - (positionSize.x + positionSize.width);
1758     newPositionSize.y      = screenHeight - (positionSize.y + positionSize.height);
1759     newPositionSize.width  = positionSize.width;
1760     newPositionSize.height = positionSize.height;
1761   }
1762   else if(mWindowRotationAngle == 270)
1763   {
1764     newPositionSize.x      = screenWidth - (positionSize.y + positionSize.height);
1765     newPositionSize.y      = positionSize.x;
1766     newPositionSize.width  = positionSize.height;
1767     newPositionSize.height = positionSize.width;
1768   }
1769   else
1770   {
1771     newPositionSize.x      = positionSize.x;
1772     newPositionSize.y      = positionSize.y;
1773     newPositionSize.width  = positionSize.width;
1774     newPositionSize.height = positionSize.height;
1775   }
1776
1777   return newPositionSize;
1778 }
1779
1780 PositionSize WindowBaseEcoreWl2::RecalculatePositionSizeToCurrentOrientation(PositionSize positionSize)
1781 {
1782   PositionSize newPositionSize;
1783   int32_t      screenWidth, screenHeight;
1784   WindowSystem::GetScreenSize(screenWidth, screenHeight);
1785
1786   if(mWindowRotationAngle == 90)
1787   {
1788     newPositionSize.x      = screenHeight - (positionSize.y + positionSize.height);
1789     newPositionSize.y      = positionSize.x;
1790     newPositionSize.width  = positionSize.height;
1791     newPositionSize.height = positionSize.width;
1792   }
1793   else if(mWindowRotationAngle == 180)
1794   {
1795     newPositionSize.x      = screenWidth - (positionSize.x + positionSize.width);
1796     newPositionSize.y      = screenHeight - (positionSize.y + positionSize.height);
1797     newPositionSize.width  = positionSize.width;
1798     newPositionSize.height = positionSize.height;
1799   }
1800   else if(mWindowRotationAngle == 270)
1801   {
1802     newPositionSize.x      = positionSize.y;
1803     newPositionSize.y      = screenWidth - (positionSize.x + positionSize.width);
1804     newPositionSize.width  = positionSize.height;
1805     newPositionSize.height = positionSize.width;
1806   }
1807   else
1808   {
1809     newPositionSize.x      = positionSize.x;
1810     newPositionSize.y      = positionSize.y;
1811     newPositionSize.width  = positionSize.width;
1812     newPositionSize.height = positionSize.height;
1813   }
1814
1815   return newPositionSize;
1816 }
1817
1818 void WindowBaseEcoreWl2::Move(PositionSize positionSize)
1819 {
1820   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1821
1822   mWindowPositionSize = newPositionSize;
1823   DALI_LOG_RELEASE_INFO("ecore_wl2_window_position_set x[%d], y[%d]\n", newPositionSize.x, newPositionSize.y);
1824   ecore_wl2_window_position_set(mEcoreWindow, newPositionSize.x, newPositionSize.y);
1825 }
1826
1827 void WindowBaseEcoreWl2::Resize(PositionSize positionSize)
1828 {
1829   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1830
1831   mWindowPositionSize = newPositionSize;
1832   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);
1833   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1834 }
1835
1836 void WindowBaseEcoreWl2::MoveResize(PositionSize positionSize)
1837 {
1838   PositionSize newPositionSize = RecalculatePositionSizeToSystem(positionSize);
1839
1840   mWindowPositionSize = newPositionSize;
1841   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);
1842   ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
1843 }
1844
1845 void WindowBaseEcoreWl2::SetClass(const std::string& name, const std::string& className)
1846 {
1847   ecore_wl2_window_title_set(mEcoreWindow, name.c_str());
1848   ecore_wl2_window_class_set(mEcoreWindow, className.c_str());
1849 }
1850
1851 void WindowBaseEcoreWl2::Raise()
1852 {
1853   // Use ecore_wl2_window_activate to prevent the window shown without rendering
1854   ecore_wl2_window_activate(mEcoreWindow);
1855 }
1856
1857 void WindowBaseEcoreWl2::Lower()
1858 {
1859   ecore_wl2_window_lower(mEcoreWindow);
1860 }
1861
1862 void WindowBaseEcoreWl2::Activate()
1863 {
1864   ecore_wl2_window_activate(mEcoreWindow);
1865 }
1866
1867 void WindowBaseEcoreWl2::Maximize(bool maximize)
1868 {
1869   ecore_wl2_window_maximized_set(mEcoreWindow, maximize);
1870 }
1871
1872 bool WindowBaseEcoreWl2::IsMaximized() const
1873 {
1874   return ecore_wl2_window_maximized_get(mEcoreWindow);
1875 }
1876
1877 void WindowBaseEcoreWl2::SetMaximumSize(Dali::Window::WindowSize size)
1878 {
1879   DALI_LOG_RELEASE_INFO("ecore_wl2_window_maximum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
1880   ecore_wl2_window_maximum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
1881 }
1882
1883 void WindowBaseEcoreWl2::Minimize(bool minimize)
1884 {
1885   ecore_wl2_window_iconified_set(mEcoreWindow, minimize);
1886 }
1887
1888 bool WindowBaseEcoreWl2::IsMinimized() const
1889 {
1890   return ecore_wl2_window_iconified_get(mEcoreWindow);
1891 }
1892
1893 void WindowBaseEcoreWl2::SetMimimumSize(Dali::Window::WindowSize size)
1894 {
1895   DALI_LOG_RELEASE_INFO("ecore_wl2_window_minimum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
1896   ecore_wl2_window_minimum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
1897 }
1898
1899 void WindowBaseEcoreWl2::SetAvailableAnlges(const std::vector<int>& angles)
1900 {
1901   int rotations[4] = {0};
1902   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size());
1903   for(std::size_t i = 0; i < angles.size(); ++i)
1904   {
1905     rotations[i] = static_cast<int>(angles[i]);
1906     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "%d ", rotations[i]);
1907   }
1908   ecore_wl2_window_available_rotations_set(mEcoreWindow, rotations, angles.size());
1909 }
1910
1911 void WindowBaseEcoreWl2::SetPreferredAngle(int angle)
1912 {
1913   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetPreferredAngle, angle: %d\n", angle);
1914   ecore_wl2_window_preferred_rotation_set(mEcoreWindow, angle);
1915 }
1916
1917 void WindowBaseEcoreWl2::SetAcceptFocus(bool accept)
1918 {
1919   ecore_wl2_window_focus_skip_set(mEcoreWindow, !accept);
1920 }
1921
1922 void WindowBaseEcoreWl2::Show()
1923 {
1924   if(!mVisible)
1925   {
1926     ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1927   }
1928   mVisible = true;
1929
1930   ecore_wl2_window_show(mEcoreWindow);
1931 }
1932
1933 void WindowBaseEcoreWl2::Hide()
1934 {
1935   mVisible = false;
1936   ecore_wl2_window_hide(mEcoreWindow);
1937 }
1938
1939 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1940 {
1941   return mSupportedAuxiliaryHints.size();
1942 }
1943
1944 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint(unsigned int index) const
1945 {
1946   if(index >= GetSupportedAuxiliaryHintCount())
1947   {
1948     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index);
1949   }
1950
1951   return mSupportedAuxiliaryHints[index];
1952 }
1953
1954 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint(const std::string& hint, const std::string& value)
1955 {
1956   bool supported = false;
1957
1958   // Check if the hint is suppported
1959   for(std::vector<std::string>::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter)
1960   {
1961     if(*iter == hint)
1962     {
1963       supported = true;
1964       break;
1965     }
1966   }
1967
1968   if(!supported)
1969   {
1970     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str());
1971     return 0;
1972   }
1973
1974   // Check if the hint is already added
1975   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1976   {
1977     if(mAuxiliaryHints[i].first == hint)
1978     {
1979       // Just change the value
1980       mAuxiliaryHints[i].second = value;
1981
1982       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1);
1983
1984       return i + 1; // id is index + 1
1985     }
1986   }
1987
1988   // Add the hint
1989   mAuxiliaryHints.push_back(std::pair<std::string, std::string>(hint, value));
1990
1991   unsigned int id = mAuxiliaryHints.size();
1992
1993   ecore_wl2_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
1994
1995   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
1996
1997   return id;
1998 }
1999
2000 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint(unsigned int id)
2001 {
2002   if(id == 0 || id > mAuxiliaryHints.size())
2003   {
2004     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id);
2005     return false;
2006   }
2007
2008   mAuxiliaryHints[id - 1].second = std::string();
2009
2010   ecore_wl2_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
2011
2012   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
2013
2014   return true;
2015 }
2016
2017 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
2018 {
2019   if(id == 0 || id > mAuxiliaryHints.size())
2020   {
2021     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id);
2022     return false;
2023   }
2024
2025   mAuxiliaryHints[id - 1].second = value;
2026
2027   ecore_wl2_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
2028
2029   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());
2030
2031   return true;
2032 }
2033
2034 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue(unsigned int id) const
2035 {
2036   if(id == 0 || id > mAuxiliaryHints.size())
2037   {
2038     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id);
2039     return std::string();
2040   }
2041
2042   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());
2043
2044   return mAuxiliaryHints[id - 1].second;
2045 }
2046
2047 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId(const std::string& hint) const
2048 {
2049   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
2050   {
2051     if(mAuxiliaryHints[i].first == hint)
2052     {
2053       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1);
2054       return i + 1;
2055     }
2056   }
2057
2058   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str());
2059
2060   return 0;
2061 }
2062
2063 void WindowBaseEcoreWl2::SetInputRegion(const Rect<int>& inputRegion)
2064 {
2065   ecore_wl2_window_input_region_set(mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height);
2066 }
2067
2068 void WindowBaseEcoreWl2::SetType(Dali::WindowType type)
2069 {
2070   if(mType != type)
2071   {
2072     mType = type;
2073     Ecore_Wl2_Window_Type windowType;
2074
2075     switch(type)
2076     {
2077       case Dali::WindowType::NORMAL:
2078       {
2079         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2080         break;
2081       }
2082       case Dali::WindowType::NOTIFICATION:
2083       {
2084         windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
2085         break;
2086       }
2087       case Dali::WindowType::UTILITY:
2088       {
2089         windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
2090         break;
2091       }
2092       case Dali::WindowType::DIALOG:
2093       {
2094         windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
2095         break;
2096       }
2097       case Dali::WindowType::IME:
2098       {
2099         windowType = ECORE_WL2_WINDOW_TYPE_NONE;
2100         break;
2101       }
2102       case Dali::WindowType::DESKTOP:
2103       {
2104         windowType = ECORE_WL2_WINDOW_TYPE_DESKTOP;
2105         break;
2106       }
2107       default:
2108       {
2109         windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
2110         break;
2111       }
2112     }
2113     ecore_wl2_window_type_set(mEcoreWindow, windowType);
2114   }
2115 }
2116
2117 Dali::WindowType WindowBaseEcoreWl2::GetType() const
2118 {
2119   return mType;
2120 }
2121
2122 Dali::WindowOperationResult WindowBaseEcoreWl2::SetNotificationLevel(Dali::WindowNotificationLevel level)
2123 {
2124   while(!mTizenPolicy)
2125   {
2126     wl_display_dispatch_queue(mDisplay, mEventQueue);
2127   }
2128
2129   int notificationLevel;
2130
2131   switch(level)
2132   {
2133     case Dali::WindowNotificationLevel::NONE:
2134     {
2135       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
2136       break;
2137     }
2138     case Dali::WindowNotificationLevel::BASE:
2139     {
2140       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2141       break;
2142     }
2143     case Dali::WindowNotificationLevel::MEDIUM:
2144     {
2145       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
2146       break;
2147     }
2148     case Dali::WindowNotificationLevel::HIGH:
2149     {
2150       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
2151       break;
2152     }
2153     case Dali::WindowNotificationLevel::TOP:
2154     {
2155       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
2156       break;
2157     }
2158     default:
2159     {
2160       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level);
2161       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
2162       break;
2163     }
2164   }
2165
2166   mNotificationLevelChangeDone = false;
2167   mNotificationChangeState     = TIZEN_POLICY_ERROR_STATE_NONE;
2168
2169   tizen_policy_set_notification_level(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), notificationLevel);
2170
2171   int count = 0;
2172
2173   while(!mNotificationLevelChangeDone && count < 3)
2174   {
2175     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2176     wl_display_dispatch_queue(mDisplay, mEventQueue);
2177     count++;
2178   }
2179
2180   if(!mNotificationLevelChangeDone)
2181   {
2182     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState);
2183     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2184   }
2185   else if(mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2186   {
2187     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level);
2188     return Dali::WindowOperationResult::PERMISSION_DENIED;
2189   }
2190
2191   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel);
2192
2193   return Dali::WindowOperationResult::SUCCEED;
2194 }
2195
2196 Dali::WindowNotificationLevel WindowBaseEcoreWl2::GetNotificationLevel() const
2197 {
2198   while(!mTizenPolicy)
2199   {
2200     wl_display_dispatch_queue(mDisplay, mEventQueue);
2201   }
2202
2203   int count = 0;
2204
2205   while(!mNotificationLevelChangeDone && count < 3)
2206   {
2207     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2208     wl_display_dispatch_queue(mDisplay, mEventQueue);
2209     count++;
2210   }
2211
2212   if(!mNotificationLevelChangeDone)
2213   {
2214     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState);
2215     return Dali::WindowNotificationLevel::NONE;
2216   }
2217
2218   Dali::WindowNotificationLevel level;
2219
2220   switch(mNotificationLevel)
2221   {
2222     case TIZEN_POLICY_LEVEL_NONE:
2223     {
2224       level = Dali::WindowNotificationLevel::NONE;
2225       break;
2226     }
2227     case TIZEN_POLICY_LEVEL_DEFAULT:
2228     {
2229       level = Dali::WindowNotificationLevel::BASE;
2230       break;
2231     }
2232     case TIZEN_POLICY_LEVEL_MEDIUM:
2233     {
2234       level = Dali::WindowNotificationLevel::MEDIUM;
2235       break;
2236     }
2237     case TIZEN_POLICY_LEVEL_HIGH:
2238     {
2239       level = Dali::WindowNotificationLevel::HIGH;
2240       break;
2241     }
2242     case TIZEN_POLICY_LEVEL_TOP:
2243     {
2244       level = Dali::WindowNotificationLevel::TOP;
2245       break;
2246     }
2247     default:
2248     {
2249       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel);
2250       level = Dali::WindowNotificationLevel::NONE;
2251       break;
2252     }
2253   }
2254
2255   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel);
2256
2257   return level;
2258 }
2259
2260 void WindowBaseEcoreWl2::SetOpaqueState(bool opaque)
2261 {
2262   while(!mTizenPolicy)
2263   {
2264     wl_display_dispatch_queue(mDisplay, mEventQueue);
2265   }
2266
2267   tizen_policy_set_opaque_state(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), (opaque ? 1 : 0));
2268 }
2269
2270 Dali::WindowOperationResult WindowBaseEcoreWl2::SetScreenOffMode(WindowScreenOffMode screenOffMode)
2271 {
2272   while(!mTizenPolicy)
2273   {
2274     wl_display_dispatch_queue(mDisplay, mEventQueue);
2275   }
2276
2277   mScreenOffModeChangeDone  = false;
2278   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2279
2280   unsigned int mode = 0;
2281
2282   switch(screenOffMode)
2283   {
2284     case WindowScreenOffMode::TIMEOUT:
2285     {
2286       mode = 0;
2287       break;
2288     }
2289     case WindowScreenOffMode::NEVER:
2290     {
2291       mode = 1;
2292       break;
2293     }
2294   }
2295
2296   tizen_policy_set_window_screen_mode(mTizenPolicy, ecore_wl2_window_surface_get(mEcoreWindow), mode);
2297
2298   int count = 0;
2299
2300   while(!mScreenOffModeChangeDone && count < 3)
2301   {
2302     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2303     wl_display_dispatch_queue(mDisplay, mEventQueue);
2304     count++;
2305   }
2306
2307   if(!mScreenOffModeChangeDone)
2308   {
2309     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState);
2310     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2311   }
2312   else if(mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2313   {
2314     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode);
2315     return Dali::WindowOperationResult::PERMISSION_DENIED;
2316   }
2317
2318   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode);
2319
2320   return Dali::WindowOperationResult::SUCCEED;
2321 }
2322
2323 WindowScreenOffMode WindowBaseEcoreWl2::GetScreenOffMode() const
2324 {
2325   while(!mTizenPolicy)
2326   {
2327     wl_display_dispatch_queue(mDisplay, mEventQueue);
2328   }
2329
2330   int count = 0;
2331
2332   while(!mScreenOffModeChangeDone && count < 3)
2333   {
2334     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2335     wl_display_dispatch_queue(mDisplay, mEventQueue);
2336     count++;
2337   }
2338
2339   if(!mScreenOffModeChangeDone)
2340   {
2341     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState);
2342     return WindowScreenOffMode::TIMEOUT;
2343   }
2344
2345   WindowScreenOffMode screenMode = WindowScreenOffMode::TIMEOUT;
2346
2347   switch(mScreenOffMode)
2348   {
2349     case 0:
2350     {
2351       screenMode = WindowScreenOffMode::TIMEOUT;
2352       break;
2353     }
2354     case 1:
2355     {
2356       screenMode = WindowScreenOffMode::NEVER;
2357       break;
2358     }
2359   }
2360
2361   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode);
2362
2363   return screenMode;
2364 }
2365
2366 Dali::WindowOperationResult WindowBaseEcoreWl2::SetBrightness(int brightness)
2367 {
2368   while(!mTizenDisplayPolicy)
2369   {
2370     wl_display_dispatch_queue(mDisplay, mEventQueue);
2371   }
2372
2373   mBrightnessChangeDone  = false;
2374   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2375
2376   tizen_display_policy_set_window_brightness(mTizenDisplayPolicy, ecore_wl2_window_surface_get(mEcoreWindow), brightness);
2377
2378   int count = 0;
2379
2380   while(!mBrightnessChangeDone && count < 3)
2381   {
2382     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2383     wl_display_dispatch_queue(mDisplay, mEventQueue);
2384     count++;
2385   }
2386
2387   if(!mBrightnessChangeDone)
2388   {
2389     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState);
2390     return Dali::WindowOperationResult::UNKNOWN_ERROR;
2391   }
2392   else if(mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
2393   {
2394     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness);
2395     return Dali::WindowOperationResult::PERMISSION_DENIED;
2396   }
2397
2398   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness);
2399
2400   return Dali::WindowOperationResult::SUCCEED;
2401 }
2402
2403 int WindowBaseEcoreWl2::GetBrightness() const
2404 {
2405   while(!mTizenDisplayPolicy)
2406   {
2407     wl_display_dispatch_queue(mDisplay, mEventQueue);
2408   }
2409
2410   int count = 0;
2411
2412   while(!mBrightnessChangeDone && count < 3)
2413   {
2414     ecore_wl2_display_flush(ecore_wl2_connected_display_get(NULL));
2415     wl_display_dispatch_queue(mDisplay, mEventQueue);
2416     count++;
2417   }
2418
2419   if(!mBrightnessChangeDone)
2420   {
2421     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState);
2422     return 0;
2423   }
2424
2425   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness);
2426
2427   return mBrightness;
2428 }
2429
2430 bool WindowBaseEcoreWl2::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
2431 {
2432   Ecore_Wl2_Window_Keygrab_Mode mode;
2433
2434   switch(grabMode)
2435   {
2436     case KeyGrab::TOPMOST:
2437     {
2438       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2439       break;
2440     }
2441     case KeyGrab::SHARED:
2442     {
2443       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2444       break;
2445     }
2446     case KeyGrab::OVERRIDE_EXCLUSIVE:
2447     {
2448       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2449       break;
2450     }
2451     case KeyGrab::EXCLUSIVE:
2452     {
2453       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2454       break;
2455     }
2456     default:
2457     {
2458       return false;
2459     }
2460   }
2461
2462   return ecore_wl2_window_keygrab_set(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0, 0, mode);
2463 }
2464
2465 bool WindowBaseEcoreWl2::UngrabKey(Dali::KEY key)
2466 {
2467   return ecore_wl2_window_keygrab_unset(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0);
2468 }
2469
2470 bool WindowBaseEcoreWl2::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
2471 {
2472   int keyCount         = key.Count();
2473   int keyGrabModeCount = grabMode.Count();
2474
2475   if(keyCount != keyGrabModeCount || keyCount == 0)
2476   {
2477     return false;
2478   }
2479
2480   eina_init();
2481
2482   Eina_List*                     keyList = NULL;
2483   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2484
2485   for(int index = 0; index < keyCount; ++index)
2486   {
2487     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2488
2489     switch(grabMode[index])
2490     {
2491       case KeyGrab::TOPMOST:
2492       {
2493         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2494         break;
2495       }
2496       case KeyGrab::SHARED:
2497       {
2498         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2499         break;
2500       }
2501       case KeyGrab::OVERRIDE_EXCLUSIVE:
2502       {
2503         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2504         break;
2505       }
2506       case KeyGrab::EXCLUSIVE:
2507       {
2508         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2509         break;
2510       }
2511       default:
2512       {
2513         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2514         break;
2515       }
2516     }
2517
2518     keyList = eina_list_append(keyList, &info);
2519   }
2520
2521   Eina_List* grabList = ecore_wl2_window_keygrab_list_set(mEcoreWindow, keyList);
2522
2523   result.Resize(keyCount, true);
2524
2525   Eina_List* l        = NULL;
2526   Eina_List* m        = NULL;
2527   void*      listData = NULL;
2528   void*      data     = NULL;
2529   if(grabList != NULL)
2530   {
2531     EINA_LIST_FOREACH(grabList, m, data)
2532     {
2533       int index = 0;
2534       EINA_LIST_FOREACH(keyList, l, listData)
2535       {
2536         if(static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key == NULL)
2537         {
2538           DALI_LOG_ERROR("input key list has null data!");
2539           break;
2540         }
2541
2542         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2543         {
2544           result[index] = false;
2545         }
2546         ++index;
2547       }
2548     }
2549   }
2550
2551   delete[] info;
2552
2553   eina_list_free(keyList);
2554   eina_list_free(grabList);
2555   eina_shutdown();
2556
2557   return true;
2558 }
2559
2560 bool WindowBaseEcoreWl2::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
2561 {
2562   int keyCount = key.Count();
2563   if(keyCount == 0)
2564   {
2565     return false;
2566   }
2567
2568   eina_init();
2569
2570   Eina_List*                     keyList = NULL;
2571   Ecore_Wl2_Window_Keygrab_Info* info    = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2572
2573   for(int index = 0; index < keyCount; ++index)
2574   {
2575     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2576     keyList         = eina_list_append(keyList, &info);
2577   }
2578
2579   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset(mEcoreWindow, keyList);
2580
2581   result.Resize(keyCount, true);
2582
2583   Eina_List* l        = NULL;
2584   Eina_List* m        = NULL;
2585   void*      listData = NULL;
2586   void*      data     = NULL;
2587
2588   if(ungrabList != NULL)
2589   {
2590     EINA_LIST_FOREACH(ungrabList, m, data)
2591     {
2592       int index = 0;
2593       EINA_LIST_FOREACH(keyList, l, listData)
2594       {
2595         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl2_Window_Keygrab_Info*>(listData)->key) == 0)
2596         {
2597           result[index] = false;
2598         }
2599         ++index;
2600       }
2601     }
2602   }
2603
2604   delete[] info;
2605
2606   eina_list_free(keyList);
2607   eina_list_free(ungrabList);
2608   eina_shutdown();
2609
2610   return true;
2611 }
2612
2613 void WindowBaseEcoreWl2::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
2614 {
2615   // calculate DPI
2616   float xres, yres;
2617
2618   Ecore_Wl2_Output* output = ecore_wl2_window_output_find(mEcoreWindow);
2619
2620   // 1 inch = 25.4 millimeters
2621   xres = ecore_wl2_output_dpi_get(output);
2622   yres = ecore_wl2_output_dpi_get(output);
2623
2624   dpiHorizontal = int(xres + 0.5f); // rounding
2625   dpiVertical   = int(yres + 0.5f);
2626 }
2627
2628 int WindowBaseEcoreWl2::GetWindowRotationAngle() const
2629 {
2630   int orientation = mWindowRotationAngle;
2631   if(mSupportedPreProtation)
2632   {
2633     orientation = 0;
2634   }
2635   return orientation;
2636 }
2637
2638 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2639 {
2640   if(mSupportedPreProtation)
2641   {
2642     DALI_LOG_RELEASE_INFO("Support PreRotation and return 0\n");
2643     return 0;
2644   }
2645   int transform;
2646   if(ecore_wl2_window_ignore_output_transform_get(mEcoreWindow))
2647   {
2648     transform = 0;
2649   }
2650   else
2651   {
2652     transform = ecore_wl2_output_transform_get(ecore_wl2_window_output_find(mEcoreWindow));
2653   }
2654   mScreenRotationAngle = transform * 90;
2655   return mScreenRotationAngle;
2656 }
2657
2658 void WindowBaseEcoreWl2::SetWindowRotationAngle(int degree)
2659 {
2660   mWindowRotationAngle = degree;
2661   ecore_wl2_window_rotation_set(mEcoreWindow, degree);
2662 }
2663
2664 void WindowBaseEcoreWl2::WindowRotationCompleted(int degree, int width, int height)
2665 {
2666   ecore_wl2_window_rotation_change_done_send(mEcoreWindow, degree, width, height);
2667 }
2668
2669 void WindowBaseEcoreWl2::SetTransparency(bool transparent)
2670 {
2671   ecore_wl2_window_alpha_set(mEcoreWindow, transparent);
2672 }
2673
2674 void WindowBaseEcoreWl2::CreateWindow(PositionSize positionSize)
2675 {
2676   Ecore_Wl2_Display* display = ecore_wl2_display_connect(NULL);
2677   if(!display)
2678   {
2679     DALI_ASSERT_ALWAYS(0 && "Failed to get display");
2680   }
2681
2682   ecore_wl2_display_sync(display);
2683
2684   mEcoreWindow = ecore_wl2_window_new(display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2685
2686   if(mEcoreWindow == 0)
2687   {
2688     DALI_ASSERT_ALWAYS(0 && "Failed to create Wayland window");
2689   }
2690
2691   // Set default type
2692   ecore_wl2_window_type_set(mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
2693 }
2694
2695 void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase, bool belowParent)
2696 {
2697   Ecore_Wl2_Window* ecoreParent = NULL;
2698   if(parentWinBase)
2699   {
2700     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
2701     ecoreParent                       = winBaseEcore2->mEcoreWindow;
2702   }
2703   ecore_wl2_window_transient_parent_set(mEcoreWindow, ecoreParent, belowParent);
2704 }
2705
2706 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2707 {
2708   return wl_egl_window_tizen_create_commit_sync_fd(mEglWindow);
2709 }
2710
2711 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2712 {
2713   return wl_egl_window_tizen_create_presentation_sync_fd(mEglWindow);
2714 }
2715
2716 void WindowBaseEcoreWl2::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
2717 {
2718   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);
2719   ecore_wl2_window_rotation_geometry_set(mEcoreWindow, angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
2720 }
2721
2722 void WindowBaseEcoreWl2::InitializeIme()
2723 {
2724   Eina_Iterator*      globals;
2725   struct wl_registry* registry;
2726   Ecore_Wl2_Global*   global;
2727   Ecore_Wl2_Display*  ecoreWl2Display;
2728
2729   if(!(ecoreWl2Display = ecore_wl2_connected_display_get(NULL)))
2730   {
2731     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 connected display\n");
2732     return;
2733   }
2734
2735   DALI_LOG_RELEASE_INFO("InitializeIme:  Ecore_Wl2_Display: %p, ecore wl window: %p\n", ecoreWl2Display, mEcoreWindow);
2736
2737   if(!(registry = ecore_wl2_display_registry_get(ecoreWl2Display)))
2738   {
2739     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 display registry\n");
2740     return;
2741   }
2742
2743   if(!(globals = ecore_wl2_display_globals_get(ecoreWl2Display)))
2744   {
2745     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 globals\n");
2746     return;
2747   }
2748
2749   EINA_ITERATOR_FOREACH(globals, global)
2750   {
2751 #ifdef OVER_TIZEN_VERSION_7
2752     if(strcmp(global->interface, "zwp_input_panel_v1") == 0)
2753     {
2754       mWlInputPanel = (zwp_input_panel_v1*)wl_registry_bind(registry, global->id, &zwp_input_panel_v1_interface, 1);
2755     }
2756 #else
2757     if(strcmp(global->interface, "wl_input_panel") == 0)
2758     {
2759       mWlInputPanel = (wl_input_panel*)wl_registry_bind(registry, global->id, &wl_input_panel_interface, 1);
2760     }
2761 #endif
2762     else if(strcmp(global->interface, "wl_output") == 0)
2763     {
2764       mWlOutput = (wl_output*)wl_registry_bind(registry, global->id, &wl_output_interface, 1);
2765     }
2766   }
2767
2768   if(!mWlInputPanel)
2769   {
2770     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel interface\n");
2771     return;
2772   }
2773
2774   if(!mWlOutput)
2775   {
2776     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland output panel interface\n");
2777     return;
2778   }
2779 #ifdef OVER_TIZEN_VERSION_7
2780   mWlInputPanelSurface = zwp_input_panel_v1_get_input_panel_surface(mWlInputPanel, mWlSurface);
2781 #else
2782   mWlInputPanelSurface = wl_input_panel_get_input_panel_surface(mWlInputPanel, mWlSurface);
2783 #endif
2784   if(!mWlInputPanelSurface)
2785   {
2786     DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get wayland input panel surface\n");
2787     return;
2788   }
2789 #ifdef OVER_TIZEN_VERSION_7
2790   zwp_input_panel_surface_v1_set_toplevel(mWlInputPanelSurface, mWlOutput, ZWP_INPUT_PANEL_SURFACE_V1_POSITION_CENTER_BOTTOM);
2791 #else
2792   wl_input_panel_surface_set_toplevel(mWlInputPanelSurface, mWlOutput, WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
2793 #endif
2794 }
2795
2796 void WindowBaseEcoreWl2::ImeWindowReadyToRender()
2797 {
2798   if(!mWlInputPanelSurface)
2799   {
2800     DALI_LOG_ERROR("WindowBaseEcoreWl2::ImeWindowReadyToRender(), wayland input panel surface is null\n");
2801     return;
2802   }
2803 #ifdef OVER_TIZEN_VERSION_7
2804   zwp_input_panel_surface_v1_set_ready(mWlInputPanelSurface, 1);
2805 #else
2806   wl_input_panel_surface_set_ready(mWlInputPanelSurface, 1);
2807 #endif
2808 }
2809
2810 void WindowBaseEcoreWl2::RequestMoveToServer()
2811 {
2812   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2813   if(!display)
2814   {
2815     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get ecore_wl2_display\n");
2816     return;
2817   }
2818
2819   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2820   if(!input)
2821   {
2822     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestMoveToServer, Fail to get default Ecore_Wl2_Input\n");
2823     return;
2824   }
2825
2826   ecore_wl2_window_move(mEcoreWindow, input);
2827   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestMoveToServer, starts the window[%p] is moved by server\n", mEcoreWindow);
2828 }
2829
2830 void WindowBaseEcoreWl2::RequestResizeToServer(WindowResizeDirection direction)
2831 {
2832   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
2833   if(!display)
2834   {
2835     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get ecore_wl2_display\n");
2836     return;
2837   }
2838
2839   Ecore_Wl2_Input* input = ecore_wl2_input_default_input_get(display);
2840   if(!input)
2841   {
2842     DALI_LOG_ERROR("WindowBaseEcoreWl2::RequestResizeToServer, Fail to get default Ecore_Wl2_Input\n");
2843     return;
2844   }
2845
2846   ResizeLocation location = RecalculateLocationToCurrentOrientation(direction, mWindowRotationAngle);
2847
2848   ecore_wl2_window_resize(mEcoreWindow, input, static_cast<int>(location));
2849   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);
2850 }
2851
2852 void WindowBaseEcoreWl2::EnableFloatingMode(bool enable)
2853 {
2854   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EnableFloatingMode, floating mode flag: [%p], enable [%d]\n", mEcoreWindow, enable);
2855   if(enable == true)
2856   {
2857     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_TRUE);
2858   }
2859   else
2860   {
2861     ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_FALSE);
2862   }
2863 }
2864
2865 bool WindowBaseEcoreWl2::IsFloatingModeEnabled() const
2866 {
2867   return ecore_wl2_window_floating_mode_get(mEcoreWindow);
2868 }
2869
2870 void WindowBaseEcoreWl2::IncludeInputRegion(const Rect<int>& inputRegion)
2871 {
2872   Eina_Rectangle rect;
2873   rect.x = inputRegion.x;
2874   rect.y = inputRegion.y;
2875   rect.w = inputRegion.width;
2876   rect.h = inputRegion.height;
2877
2878   ecore_wl2_window_input_rect_add(mEcoreWindow, &rect);
2879   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2880 }
2881
2882 void WindowBaseEcoreWl2::ExcludeInputRegion(const Rect<int>& inputRegion)
2883 {
2884   Eina_Rectangle rect;
2885   rect.x = inputRegion.x;
2886   rect.y = inputRegion.y;
2887   rect.w = inputRegion.width;
2888   rect.h = inputRegion.height;
2889
2890   ecore_wl2_window_input_rect_subtract(mEcoreWindow, &rect);
2891   ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
2892 }
2893
2894 } // namespace Adaptor
2895
2896 } // namespace Internal
2897
2898 } // namespace Dali
2899
2900 #pragma GCC diagnostic pop