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