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