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

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