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