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

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