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

   1 /*
   2  * Copyright (c) 2024 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-wl/window-base-ecore-wl.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
  30 // EXTERNAL_HEADERS
  31 #include <Ecore_Input.h>
  32 #include <dali/integration-api/debug.h>
  33 #include <dali/public-api/object/any.h>
  34
  35 #if defined(VCONF_ENABLED)
  36 #include <vconf-keys.h>
  37 #include <vconf.h>
  38 #endif
  39
  40 namespace Dali
  41 {
  42 namespace Internal
  43 {
  44 namespace Adaptor
  45 {
  46 namespace
  47 {
  48 #if defined(DEBUG_ENABLED)
  49 Debug::Filter* gWindowBaseLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW_BASE");
  50 #endif
  51
  52 const uint32_t     MAX_TIZEN_CLIENT_VERSION = 7;
  53 const unsigned int PRIMARY_TOUCH_BUTTON_ID  = 1;
  54
  55 #if defined(VCONF_ENABLED)
  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 #endif
  58
  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
  64 /**
  65  * Get the device name from the provided ecore key event
  66  */
  67 void GetDeviceName(Ecore_Event_Key* keyEvent, std::string& result)
  68 {
  69   const char* ecoreDeviceName = ecore_device_name_get(keyEvent->dev);
  70
  71   if(ecoreDeviceName)
  72   {
  73     result = ecoreDeviceName;
  74   }
  75 }
  76
  77 /**
  78  * Get the device class from the provided ecore event
  79  */
  80 void GetDeviceClass(Ecore_Device_Class ecoreDeviceClass, Device::Class::Type& deviceClass)
  81 {
  82   switch(ecoreDeviceClass)
  83   {
  84     case ECORE_DEVICE_CLASS_SEAT:
  85     {
  86       deviceClass = Device::Class::USER;
  87       break;
  88     }
  89     case ECORE_DEVICE_CLASS_KEYBOARD:
  90     {
  91       deviceClass = Device::Class::KEYBOARD;
  92       break;
  93     }
  94     case ECORE_DEVICE_CLASS_MOUSE:
  95     {
  96       deviceClass = Device::Class::MOUSE;
  97       break;
  98     }
  99     case ECORE_DEVICE_CLASS_TOUCH:
 100     {
 101       deviceClass = Device::Class::TOUCH;
 102       break;
 103     }
 104     case ECORE_DEVICE_CLASS_PEN:
 105     {
 106       deviceClass = Device::Class::PEN;
 107       break;
 108     }
 109     case ECORE_DEVICE_CLASS_POINTER:
 110     {
 111       deviceClass = Device::Class::POINTER;
 112       break;
 113     }
 114     case ECORE_DEVICE_CLASS_GAMEPAD:
 115     {
 116       deviceClass = Device::Class::GAMEPAD;
 117       break;
 118     }
 119     default:
 120     {
 121       deviceClass = Device::Class::NONE;
 122       break;
 123     }
 124   }
 125 }
 126
 127 void GetDeviceSubclass(Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subclass::Type& deviceSubclass)
 128 {
 129   switch(ecoreDeviceSubclass)
 130   {
 131     case ECORE_DEVICE_SUBCLASS_FINGER:
 132     {
 133       deviceSubclass = Device::Subclass::FINGER;
 134       break;
 135     }
 136     case ECORE_DEVICE_SUBCLASS_FINGERNAIL:
 137     {
 138       deviceSubclass = Device::Subclass::FINGERNAIL;
 139       break;
 140     }
 141     case ECORE_DEVICE_SUBCLASS_KNUCKLE:
 142     {
 143       deviceSubclass = Device::Subclass::KNUCKLE;
 144       break;
 145     }
 146     case ECORE_DEVICE_SUBCLASS_PALM:
 147     {
 148       deviceSubclass = Device::Subclass::PALM;
 149       break;
 150     }
 151     case ECORE_DEVICE_SUBCLASS_HAND_SIZE:
 152     {
 153       deviceSubclass = Device::Subclass::HAND_SIDE;
 154       break;
 155     }
 156     case ECORE_DEVICE_SUBCLASS_HAND_FLAT:
 157     {
 158       deviceSubclass = Device::Subclass::HAND_FLAT;
 159       break;
 160     }
 161     case ECORE_DEVICE_SUBCLASS_PEN_TIP:
 162     {
 163       deviceSubclass = Device::Subclass::PEN_TIP;
 164       break;
 165     }
 166     case ECORE_DEVICE_SUBCLASS_TRACKPAD:
 167     {
 168       deviceSubclass = Device::Subclass::TRACKPAD;
 169       break;
 170     }
 171     case ECORE_DEVICE_SUBCLASS_TRACKPOINT:
 172     {
 173       deviceSubclass = Device::Subclass::TRACKPOINT;
 174       break;
 175     }
 176     case ECORE_DEVICE_SUBCLASS_TRACKBALL:
 177     {
 178       deviceSubclass = Device::Subclass::TRACKBALL;
 179       break;
 180     }
 181     case ECORE_DEVICE_SUBCLASS_REMOCON:
 182     {
 183       deviceSubclass = Device::Subclass::REMOCON;
 184       break;
 185     }
 186     case ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD:
 187     {
 188       deviceSubclass = Device::Subclass::VIRTUAL_KEYBOARD;
 189       break;
 190     }
 191     default:
 192     {
 193       deviceSubclass = Device::Subclass::NONE;
 194       break;
 195     }
 196   }
 197 }
 198
 199 /////////////////////////////////////////////////////////////////////////////////////////////////
 200 // Window Callbacks
 201 /////////////////////////////////////////////////////////////////////////////////////////////////
 202
 203 /// Called when the window iconify state is changed.
 204 static Eina_Bool EcoreEventWindowIconifyStateChanged(void* data, int type, void* event)
 205 {
 206   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 207   if(windowBase)
 208   {
 209     return windowBase->OnIconifyStateChanged(data, type, event);
 210   }
 211
 212   return ECORE_CALLBACK_PASS_ON;
 213 }
 214
 215 /// Called when the window gains focus
 216 static Eina_Bool EcoreEventWindowFocusIn(void* data, int type, void* event)
 217 {
 218   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 219   if(windowBase)
 220   {
 221     return windowBase->OnFocusIn(data, type, event);
 222   }
 223
 224   return ECORE_CALLBACK_PASS_ON;
 225 }
 226
 227 /// Called when the window loses focus
 228 static Eina_Bool EcoreEventWindowFocusOut(void* data, int type, void* event)
 229 {
 230   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 231   if(windowBase)
 232   {
 233     return windowBase->OnFocusOut(data, type, event);
 234   }
 235
 236   return ECORE_CALLBACK_PASS_ON;
 237 }
 238
 239 /// Called when the output is transformed
 240 static Eina_Bool EcoreEventOutputTransform(void* data, int type, void* event)
 241 {
 242   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 243   if(windowBase)
 244   {
 245     return windowBase->OnOutputTransform(data, type, event);
 246   }
 247
 248   return ECORE_CALLBACK_PASS_ON;
 249 }
 250
 251 /// Called when the output transform should be ignored
 252 static Eina_Bool EcoreEventIgnoreOutputTransform(void* data, int type, void* event)
 253 {
 254   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 255   if(windowBase)
 256   {
 257     return windowBase->OnIgnoreOutputTransform(data, type, event);
 258   }
 259
 260   return ECORE_CALLBACK_PASS_ON;
 261 }
 262
 263 /**
 264  * Called when rotate event is recevied.
 265  */
 266 static Eina_Bool EcoreEventRotate(void* data, int type, void* event)
 267 {
 268   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 269   if(windowBase)
 270   {
 271     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl::EcoreEventRotate\n");
 272     windowBase->OnRotation(data, type, event);
 273   }
 274   return ECORE_CALLBACK_PASS_ON;
 275 }
 276
 277 /////////////////////////////////////////////////////////////////////////////////////////////////
 278 // Touch Callbacks
 279 /////////////////////////////////////////////////////////////////////////////////////////////////
 280
 281 /**
 282  * Called when a touch down is received.
 283  */
 284 static Eina_Bool EcoreEventMouseButtonDown(void* data, int type, void* event)
 285 {
 286   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 287   if(windowBase)
 288   {
 289     windowBase->OnMouseButtonDown(data, type, event);
 290   }
 291   return ECORE_CALLBACK_PASS_ON;
 292 }
 293
 294 /**
 295  * Called when a touch up is received.
 296  */
 297 static Eina_Bool EcoreEventMouseButtonUp(void* data, int type, void* event)
 298 {
 299   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 300   if(windowBase)
 301   {
 302     windowBase->OnMouseButtonUp(data, type, event);
 303   }
 304   return ECORE_CALLBACK_PASS_ON;
 305 }
 306
 307 /**
 308  * Called when a touch motion is received.
 309  */
 310 static Eina_Bool EcoreEventMouseButtonMove(void* data, int type, void* event)
 311 {
 312   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 313   if(windowBase)
 314   {
 315     windowBase->OnMouseButtonMove(data, type, event);
 316   }
 317   return ECORE_CALLBACK_PASS_ON;
 318 }
 319
 320 /**
 321  * Called when a touch is canceled.
 322  */
 323 static Eina_Bool EcoreEventMouseButtonCancel(void* data, int type, void* event)
 324 {
 325   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 326   if(windowBase)
 327   {
 328     windowBase->OnMouseButtonCancel(data, type, event);
 329   }
 330   return ECORE_CALLBACK_PASS_ON;
 331 }
 332
 333 /**
 334  * Called when a mouse wheel is received.
 335  */
 336 static Eina_Bool EcoreEventMouseWheel(void* data, int type, void* event)
 337 {
 338   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 339   if(windowBase)
 340   {
 341     windowBase->OnMouseWheel(data, type, event);
 342   }
 343   return ECORE_CALLBACK_PASS_ON;
 344 }
 345
 346 /**
 347  * Called when a detent rotation event is recevied.
 348  */
 349 static Eina_Bool EcoreEventDetentRotation(void* data, int type, void* event)
 350 {
 351   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 352   if(windowBase)
 353   {
 354     windowBase->OnDetentRotation(data, type, event);
 355   }
 356   return ECORE_CALLBACK_PASS_ON;
 357 }
 358
 359 /////////////////////////////////////////////////////////////////////////////////////////////////
 360 // Key Callbacks
 361 /////////////////////////////////////////////////////////////////////////////////////////////////
 362
 363 /**
 364  * Called when a key down is received.
 365  */
 366 static Eina_Bool EcoreEventKeyDown(void* data, int type, void* event)
 367 {
 368   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 369   if(windowBase)
 370   {
 371     windowBase->OnKeyDown(data, type, event);
 372   }
 373   return ECORE_CALLBACK_PASS_ON;
 374 }
 375
 376 /**
 377  * Called when a key up is received.
 378  */
 379 static Eina_Bool EcoreEventKeyUp(void* data, int type, void* event)
 380 {
 381   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 382   if(windowBase)
 383   {
 384     windowBase->OnKeyUp(data, type, event);
 385   }
 386   return ECORE_CALLBACK_PASS_ON;
 387 }
 388
 389 /////////////////////////////////////////////////////////////////////////////////////////////////
 390 // Selection Callbacks
 391 /////////////////////////////////////////////////////////////////////////////////////////////////
 392
 393 /**
 394  * Called when the source window notifies us the content in clipboard is selected.
 395  */
 396 static Eina_Bool EcoreEventDataSend(void* data, int type, void* event)
 397 {
 398   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 399   if(windowBase)
 400   {
 401     windowBase->OnDataSend(data, type, event);
 402   }
 403   return ECORE_CALLBACK_PASS_ON;
 404 }
 405
 406 /**
 407 * Called when the source window sends us about the selected content.
 408 * For example, when item is selected in the clipboard.
 409 */
 410 static Eina_Bool EcoreEventDataReceive(void* data, int type, void* event)
 411 {
 412   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 413   if(windowBase)
 414   {
 415     windowBase->OnDataReceive(data, type, event);
 416   }
 417   return ECORE_CALLBACK_PASS_ON;
 418 }
 419
 420 /////////////////////////////////////////////////////////////////////////////////////////////////
 421 // Font Callbacks
 422 /////////////////////////////////////////////////////////////////////////////////////////////////
 423
 424 #if defined(VCONF_ENABLED)
 425 /**
 426  * Called when a font name is changed.
 427  */
 428 static void VconfNotifyFontNameChanged(keynode_t* node, void* data)
 429 {
 430   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 431   if(windowBase)
 432   {
 433     windowBase->OnFontNameChanged();
 434   }
 435 }
 436
 437 /**
 438  * Called when a font size is changed.
 439  */
 440 static void VconfNotifyFontSizeChanged(keynode_t* node, void* data)
 441 {
 442   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 443   if(windowBase)
 444   {
 445     windowBase->OnFontSizeChanged();
 446   }
 447 }
 448 #endif
 449
 450 static void RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
 451 {
 452   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 453   if(windowBase)
 454   {
 455     windowBase->RegistryGlobalCallback(data, registry, name, interface, version);
 456   }
 457 }
 458
 459 static void RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
 460 {
 461   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 462   if(windowBase)
 463   {
 464     windowBase->RegistryGlobalCallbackRemove(data, registry, id);
 465   }
 466 }
 467
 468 static void TizenPolicyConformant(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t isConformant)
 469 {
 470 }
 471
 472 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)
 473 {
 474 }
 475
 476 static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
 477 {
 478   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 479   if(windowBase)
 480   {
 481     windowBase->TizenPolicyNotificationChangeDone(data, tizenPolicy, surface, level, state);
 482   }
 483 }
 484
 485 static void TizenPolicyTransientForDone(void* data, struct tizen_policy* tizenPolicy, uint32_t childId)
 486 {
 487 }
 488
 489 static void TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
 490 {
 491   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 492   if(windowBase)
 493   {
 494     windowBase->TizenPolicyScreenModeChangeDone(data, tizenPolicy, surface, mode, state);
 495   }
 496 }
 497
 498 static void TizenPolicyIconifyStateChanged(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t iconified, uint32_t force)
 499 {
 500 }
 501
 502 static void TizenPolicySupportedAuxiliaryHints(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, struct wl_array* hints, uint32_t numNints)
 503 {
 504 }
 505
 506 static void TizenPolicyAllowedAuxiliaryHint(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int id)
 507 {
 508 }
 509
 510 static void TizenPolicyAuxiliaryMessage(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, const char* key, const char* val, struct wl_array* options)
 511 {
 512 }
 513
 514 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)
 515 {
 516 }
 517
 518 static void DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
 519 {
 520   WindowBaseEcoreWl* windowBase = static_cast<WindowBaseEcoreWl*>(data);
 521   if(windowBase)
 522   {
 523     windowBase->DisplayPolicyBrightnessChangeDone(data, displayPolicy, surface, brightness, state);
 524   }
 525 }
 526
 527 const struct wl_registry_listener registryListener =
 528   {
 529     RegistryGlobalCallback,
 530     RegistryGlobalCallbackRemove};
 531
 532 const struct tizen_policy_listener tizenPolicyListener =
 533   {
 534     TizenPolicyConformant,
 535     TizenPolicyConformantArea,
 536     TizenPolicyNotificationChangeDone,
 537     TizenPolicyTransientForDone,
 538     TizenPolicyScreenModeChangeDone,
 539     TizenPolicyIconifyStateChanged,
 540     TizenPolicySupportedAuxiliaryHints,
 541     TizenPolicyAllowedAuxiliaryHint,
 542     TizenPolicyAuxiliaryMessage,
 543     TizenPolicyConformantRegion};
 544
 545 const struct tizen_display_policy_listener tizenDisplayPolicyListener =
 546   {
 547     DisplayPolicyBrightnessChangeDone};
 548
 549 } // unnamed namespace
 550
 551 WindowBaseEcoreWl::WindowBaseEcoreWl(Dali::PositionSize positionSize, Any surface, bool isTransparent)
 552 : mEcoreEventHandler(),
 553   mEcoreWindow(nullptr),
 554   mWlSurface(nullptr),
 555   mEglWindow(nullptr),
 556   mDisplay(nullptr),
 557   mEventQueue(nullptr),
 558   mTizenPolicy(nullptr),
 559   mTizenDisplayPolicy(nullptr),
 560   mSupportedAuxiliaryHints(),
 561   mAuxiliaryHints(),
 562   mNotificationLevel(-1),
 563   mNotificationChangeState(0),
 564   mNotificationLevelChangeDone(true),
 565   mScreenOffMode(0),
 566   mScreenOffModeChangeState(0),
 567   mScreenOffModeChangeDone(true),
 568   mBrightness(0),
 569   mBrightnessChangeState(0),
 570   mBrightnessChangeDone(true),
 571   mOwnSurface(false),
 572   mWindowRotationAngle(0),
 573   mScreenRotationAngle(0),
 574   mSupportedPreProtation(0)
 575 {
 576   Initialize(positionSize, surface, isTransparent);
 577 }
 578
 579 WindowBaseEcoreWl::~WindowBaseEcoreWl()
 580 {
 581 #if defined(VCONF_ENABLED)
 582   vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged);
 583   vconf_ignore_key_changed(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged);
 584 #endif
 585
 586   for(Dali::Vector<Ecore_Event_Handler*>::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter)
 587   {
 588     ecore_event_handler_del(*iter);
 589   }
 590   mEcoreEventHandler.Clear();
 591
 592   if(mEventQueue)
 593   {
 594     wl_event_queue_destroy(mEventQueue);
 595   }
 596
 597   mSupportedAuxiliaryHints.clear();
 598   mAuxiliaryHints.clear();
 599
 600   if(mEglWindow != NULL)
 601   {
 602     wl_egl_window_destroy(mEglWindow);
 603     mEglWindow = NULL;
 604   }
 605
 606   if(mOwnSurface)
 607   {
 608     try
 609     {
 610       ecore_wl_window_free(mEcoreWindow);
 611     }
 612     catch(std::bad_weak_ptr const& ex)
 613     {
 614       DALI_LOG_ERROR("WindowBaseEcoreWl::~WindowBaseEcoreWl() - window (%p) std::bad_weak_ptr caught: %s\n", mEcoreWindow, ex.what());
 615     }
 616   }
 617 }
 618
 619 void WindowBaseEcoreWl::Initialize(PositionSize positionSize, Any surface, bool isTransparent)
 620 {
 621   if(surface.Empty() == false)
 622   {
 623     // check we have a valid type
 624     DALI_ASSERT_ALWAYS((surface.GetType() == typeid(Ecore_Wl_Window*)) && "Surface type is invalid");
 625
 626     mEcoreWindow = AnyCast<Ecore_Wl_Window*>(surface);
 627   }
 628   else
 629   {
 630     // we own the surface about to created
 631     mOwnSurface = true;
 632     CreateWindow(positionSize);
 633   }
 634
 635   mWlSurface = ecore_wl_window_surface_create(mEcoreWindow);
 636
 637   SetTransparency(isTransparent);
 638
 639   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this));
 640   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this));
 641   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this));
 642   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this));
 643   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM, EcoreEventIgnoreOutputTransform, this));
 644
 645   // Register Rotate event
 646   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_ROTATE, EcoreEventRotate, this));
 647
 648   // Register Touch events
 649   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, EcoreEventMouseButtonDown, this));
 650   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, EcoreEventMouseButtonUp, this));
 651   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, EcoreEventMouseButtonMove, this));
 652   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, EcoreEventMouseButtonCancel, this));
 653
 654   // Register Mouse wheel events
 655   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL, EcoreEventMouseWheel, this));
 656
 657   // Register Detent event
 658   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_DETENT_ROTATE, EcoreEventDetentRotation, this));
 659
 660   // Register Key events
 661   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, EcoreEventKeyDown, this));
 662   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_KEY_UP, EcoreEventKeyUp, this));
 663
 664   // Register Selection event - clipboard selection
 665   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_DATA_SOURCE_SEND, EcoreEventDataSend, this));
 666   mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL_EVENT_SELECTION_DATA_READY, EcoreEventDataReceive, this));
 667
 668 #if defined(VCONF_ENABLED)
 669   // Register Vconf notify - font name and size
 670   vconf_notify_key_changed_for_ui_thread(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this);
 671   vconf_notify_key_changed_for_ui_thread(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this);
 672 #endif
 673
 674   mDisplay = ecore_wl_display_get();
 675
 676   if(mDisplay)
 677   {
 678     wl_display* displayWrapper = static_cast<wl_display*>(wl_proxy_create_wrapper(mDisplay));
 679     if(displayWrapper)
 680     {
 681       mEventQueue = wl_display_create_queue(mDisplay);
 682       if(mEventQueue)
 683       {
 684         wl_proxy_set_queue(reinterpret_cast<wl_proxy*>(displayWrapper), mEventQueue);
 685
 686         wl_registry* registry = wl_display_get_registry(displayWrapper);
 687         wl_registry_add_listener(registry, &registryListener, this);
 688       }
 689
 690       wl_proxy_wrapper_destroy(displayWrapper);
 691     }
 692   }
 693
 694   // get auxiliary hint
 695   Eina_List* hints = ecore_wl_window_aux_hints_supported_get(mEcoreWindow);
 696   if(hints)
 697   {
 698     Eina_List* l    = NULL;
 699     char*      hint = NULL;
 700
 701     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))))
 702     {
 703       mSupportedAuxiliaryHints.push_back(hint);
 704
 705       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::Initialize: %s\n", hint);
 706     }
 707   }
 708 }
 709
 710 Eina_Bool WindowBaseEcoreWl::OnIconifyStateChanged(void* data, int type, void* event)
 711 {
 712   Ecore_Wl_Event_Window_Iconify_State_Change* iconifyChangedEvent(static_cast<Ecore_Wl_Event_Window_Iconify_State_Change*>(event));
 713   Eina_Bool                                   handled(ECORE_CALLBACK_PASS_ON);
 714
 715   if(iconifyChangedEvent->win == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 716   {
 717     if(iconifyChangedEvent->iconified == EINA_TRUE)
 718     {
 719       mIconifyChangedSignal.Emit(true);
 720     }
 721     else
 722     {
 723       mIconifyChangedSignal.Emit(false);
 724     }
 725     handled = ECORE_CALLBACK_DONE;
 726   }
 727
 728   return handled;
 729 }
 730
 731 Eina_Bool WindowBaseEcoreWl::OnFocusIn(void* data, int type, void* event)
 732 {
 733   Ecore_Wl_Event_Focus_In* focusInEvent(static_cast<Ecore_Wl_Event_Focus_In*>(event));
 734
 735   if(focusInEvent->win == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 736   {
 737     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n");
 738
 739     mFocusChangedSignal.Emit(true);
 740   }
 741
 742   return ECORE_CALLBACK_PASS_ON;
 743 }
 744
 745 Eina_Bool WindowBaseEcoreWl::OnFocusOut(void* data, int type, void* event)
 746 {
 747   Ecore_Wl_Event_Focus_Out* focusOutEvent(static_cast<Ecore_Wl_Event_Focus_Out*>(event));
 748
 749   if(focusOutEvent->win == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 750   {
 751     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n");
 752
 753     mFocusChangedSignal.Emit(false);
 754   }
 755
 756   return ECORE_CALLBACK_PASS_ON;
 757 }
 758
 759 Eina_Bool WindowBaseEcoreWl::OnOutputTransform(void* data, int type, void* event)
 760 {
 761   Ecore_Wl_Event_Output_Transform* transformEvent(static_cast<Ecore_Wl_Event_Output_Transform*>(event));
 762
 763   if(transformEvent->output == ecore_wl_window_output_find(mEcoreWindow) && Dali::Adaptor::IsAvailable())
 764   {
 765     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
 766
 767     mOutputTransformedSignal.Emit();
 768   }
 769
 770   return ECORE_CALLBACK_PASS_ON;
 771 }
 772
 773 Eina_Bool WindowBaseEcoreWl::OnIgnoreOutputTransform(void* data, int type, void* event)
 774 {
 775   Ecore_Wl_Event_Ignore_Output_Transform* ignoreTransformEvent(static_cast<Ecore_Wl_Event_Ignore_Output_Transform*>(event));
 776
 777   if(ignoreTransformEvent->win == mEcoreWindow && Dali::Adaptor::IsAvailable())
 778   {
 779     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
 780
 781     mOutputTransformedSignal.Emit();
 782   }
 783
 784   return ECORE_CALLBACK_PASS_ON;
 785 }
 786
 787 void WindowBaseEcoreWl::OnRotation(void* data, int type, void* event)
 788 {
 789   Ecore_Wl_Event_Window_Rotate* ev(static_cast<Ecore_Wl_Event_Window_Rotate*>(event));
 790
 791   if(ev->win == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 792   {
 793     DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h);
 794
 795     RotationEvent rotationEvent;
 796     rotationEvent.angle     = ev->angle;
 797     rotationEvent.winResize = 0;
 798
 799     if(ev->angle == 0 || ev->angle == 180)
 800     {
 801       rotationEvent.width  = ev->w;
 802       rotationEvent.height = ev->h;
 803     }
 804     else
 805     {
 806       rotationEvent.width  = ev->h;
 807       rotationEvent.height = ev->w;
 808     }
 809
 810     mRotationSignal.Emit(rotationEvent);
 811   }
 812 }
 813
 814 void WindowBaseEcoreWl::OnMouseButtonDown(void* data, int type, void* event)
 815 {
 816   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
 817
 818   if(touchEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 819   {
 820     PointState::Type state(PointState::DOWN);
 821
 822     // Check if the buttons field is set and ensure it's the primary touch button.
 823     // If this event was triggered by buttons other than the primary button (used for touch), then
 824     // just send an interrupted event to Core.
 825     if(touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID))
 826     {
 827       state = PointState::INTERRUPTED;
 828     }
 829
 830     Device::Class::Type    deviceClass;
 831     Device::Subclass::Type deviceSubclass;
 832
 833     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
 834     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
 835
 836     Integration::Point point;
 837     point.SetDeviceId(touchEvent->multi.device);
 838     point.SetState(state);
 839     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
 840     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
 841     point.SetPressure(touchEvent->multi.pressure);
 842     point.SetAngle(Degree(touchEvent->multi.angle));
 843     point.SetDeviceClass(deviceClass);
 844     point.SetDeviceSubclass(deviceSubclass);
 845
 846     mTouchEventSignal.Emit(point, touchEvent->timestamp);
 847   }
 848 }
 849
 850 void WindowBaseEcoreWl::OnMouseButtonUp(void* data, int type, void* event)
 851 {
 852   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
 853
 854   if(touchEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 855   {
 856     Device::Class::Type    deviceClass;
 857     Device::Subclass::Type deviceSubclass;
 858
 859     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
 860     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
 861
 862     Integration::Point point;
 863     point.SetDeviceId(touchEvent->multi.device);
 864     point.SetState(PointState::UP);
 865     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
 866     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
 867     point.SetPressure(touchEvent->multi.pressure);
 868     point.SetAngle(Degree(touchEvent->multi.angle));
 869     point.SetDeviceClass(deviceClass);
 870     point.SetDeviceSubclass(deviceSubclass);
 871
 872     mTouchEventSignal.Emit(point, touchEvent->timestamp);
 873   }
 874 }
 875
 876 void WindowBaseEcoreWl::OnMouseButtonMove(void* data, int type, void* event)
 877 {
 878   Ecore_Event_Mouse_Move* touchEvent = static_cast<Ecore_Event_Mouse_Move*>(event);
 879
 880   if(touchEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 881   {
 882     Device::Class::Type    deviceClass;
 883     Device::Subclass::Type deviceSubclass;
 884
 885     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
 886     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
 887
 888     Integration::Point point;
 889     point.SetDeviceId(touchEvent->multi.device);
 890     point.SetState(PointState::MOTION);
 891     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
 892     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
 893     point.SetPressure(touchEvent->multi.pressure);
 894     point.SetAngle(Degree(touchEvent->multi.angle));
 895     point.SetDeviceClass(deviceClass);
 896     point.SetDeviceSubclass(deviceSubclass);
 897
 898     mTouchEventSignal.Emit(point, touchEvent->timestamp);
 899   }
 900 }
 901
 902 void WindowBaseEcoreWl::OnMouseButtonCancel(void* data, int type, void* event)
 903 {
 904   Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
 905
 906   if(touchEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 907   {
 908     Device::Class::Type    deviceClass;
 909     Device::Subclass::Type deviceSubclass;
 910
 911     GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
 912     GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
 913
 914     Integration::Point point;
 915     point.SetDeviceId(touchEvent->multi.device);
 916     point.SetState(PointState::INTERRUPTED);
 917     point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
 918     point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
 919     point.SetPressure(touchEvent->multi.pressure);
 920     point.SetAngle(Degree(touchEvent->multi.angle));
 921     point.SetDeviceClass(deviceClass);
 922     point.SetDeviceSubclass(deviceSubclass);
 923
 924     mTouchEventSignal.Emit(point, touchEvent->timestamp);
 925
 926     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnMouseButtonCancel\n");
 927   }
 928 }
 929
 930 void WindowBaseEcoreWl::OnMouseWheel(void* data, int type, void* event)
 931 {
 932   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast<Ecore_Event_Mouse_Wheel*>(event);
 933
 934   if(mouseWheelEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 935   {
 936     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnMouseWheel: direction: %d, modifiers: %d, x: %d, y: %d, z: %d\n", mouseWheelEvent->direction, mouseWheelEvent->modifiers, mouseWheelEvent->x, mouseWheelEvent->y, mouseWheelEvent->z);
 937
 938     Integration::WheelEvent wheelEvent(Integration::WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp);
 939
 940     mWheelEventSignal.Emit(wheelEvent);
 941   }
 942 }
 943
 944 void WindowBaseEcoreWl::OnDetentRotation(void* data, int type, void* event)
 945 {
 946   if(Dali::Adaptor::IsAvailable())
 947   {
 948     Ecore_Event_Detent_Rotate* detentEvent = static_cast<Ecore_Event_Detent_Rotate*>(event);
 949
 950     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::OnDetentRotation\n");
 951
 952     int direction = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
 953     int timeStamp = detentEvent->timestamp;
 954
 955     Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0, Vector2(0.0f, 0.0f), direction, timeStamp);
 956
 957     mWheelEventSignal.Emit(wheelEvent);
 958   }
 959 }
 960
 961 void WindowBaseEcoreWl::OnKeyDown(void* data, int type, void* event)
 962 {
 963   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
 964
 965   if(keyEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
 966   {
 967     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyDown\n");
 968
 969     std::string keyName(keyEvent->keyname);
 970     std::string logicalKey("");
 971     std::string keyString("");
 972     std::string compose("");
 973
 974     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
 975     if(keyEvent->compose)
 976     {
 977       compose = keyEvent->compose;
 978     }
 979
 980     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
 981     if(keyEvent->key)
 982     {
 983       logicalKey = keyEvent->key;
 984     }
 985
 986     int keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
 987     keyCode     = (keyCode == -1) ? 0 : keyCode;
 988     int           modifier(keyEvent->modifiers);
 989     unsigned long time = keyEvent->timestamp;
 990     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
 991     {
 992       keyCode = atoi(keyEvent->keyname + 8);
 993     }
 994
 995     // Ensure key event string is not NULL as keys like SHIFT have a null string.
 996     if(keyEvent->string)
 997     {
 998       keyString = keyEvent->string;
 999     }
1000
1001     std::string            deviceName;
1002     Device::Class::Type    deviceClass;
1003     Device::Subclass::Type deviceSubclass;
1004
1005     GetDeviceName(keyEvent, deviceName);
1006     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1007     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1008
1009     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass);
1010     keyEvent.windowId = GetNativeWindowId();
1011
1012     mKeyEventSignal.Emit(keyEvent);
1013   }
1014 }
1015
1016 void WindowBaseEcoreWl::OnKeyUp(void* data, int type, void* event)
1017 {
1018   Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
1019
1020   if(keyEvent->window == static_cast<unsigned int>(ecore_wl_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
1021   {
1022     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyUp\n");
1023
1024 #if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
1025     // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
1026     if(keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL)
1027     {
1028       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyUp: This event flag indicates the event is canceled. \n");
1029       return;
1030     }
1031 #endif // Since ecore 1.23 version
1032
1033     std::string keyName(keyEvent->keyname);
1034     std::string logicalKey("");
1035     std::string keyString("");
1036     std::string compose("");
1037
1038     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1039     if(keyEvent->compose)
1040     {
1041       compose = keyEvent->compose;
1042     }
1043
1044     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1045     if(keyEvent->key)
1046     {
1047       logicalKey = keyEvent->key;
1048     }
1049
1050     int keyCode = KeyLookup::GetDaliKeyCode(keyEvent->keyname);
1051     keyCode     = (keyCode == -1) ? 0 : keyCode;
1052     int           modifier(keyEvent->modifiers);
1053     unsigned long time = keyEvent->timestamp;
1054     if(!strncmp(keyEvent->keyname, "Keycode-", 8))
1055     {
1056       keyCode = atoi(keyEvent->keyname + 8);
1057     }
1058
1059     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1060     if(keyEvent->string)
1061     {
1062       keyString = keyEvent->string;
1063     }
1064
1065     std::string            deviceName;
1066     Device::Class::Type    deviceClass;
1067     Device::Subclass::Type deviceSubclass;
1068
1069     GetDeviceName(keyEvent, deviceName);
1070     GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
1071     GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
1072
1073     Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
1074     keyEvent.windowId = GetNativeWindowId();
1075
1076     mKeyEventSignal.Emit(keyEvent);
1077   }
1078 }
1079
1080 void WindowBaseEcoreWl::OnDataSend(void* data, int type, void* event)
1081 {
1082   if(Dali::Adaptor::IsAvailable())
1083   {
1084     mSelectionDataSendSignal.Emit(event);
1085   }
1086 }
1087
1088 void WindowBaseEcoreWl::OnDataReceive(void* data, int type, void* event)
1089 {
1090   if(Dali::Adaptor::IsAvailable())
1091   {
1092     mSelectionDataReceivedSignal.Emit(event);
1093   }
1094 }
1095
1096 void WindowBaseEcoreWl::OnFontNameChanged()
1097 {
1098   if(Dali::Adaptor::IsAvailable())
1099   {
1100     mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
1101   }
1102 }
1103
1104 void WindowBaseEcoreWl::OnFontSizeChanged()
1105 {
1106   if(Dali::Adaptor::IsAvailable())
1107   {
1108     mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
1109   }
1110 }
1111
1112 void WindowBaseEcoreWl::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
1113 {
1114   if(strcmp(interface, tizen_policy_interface.name) == 0)
1115   {
1116     uint32_t clientVersion = std::min(version, MAX_TIZEN_CLIENT_VERSION);
1117
1118     mTizenPolicy = static_cast<tizen_policy*>(wl_registry_bind(registry, name, &tizen_policy_interface, clientVersion));
1119     if(!mTizenPolicy)
1120     {
1121       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n");
1122       return;
1123     }
1124
1125     tizen_policy_add_listener(mTizenPolicy, &tizenPolicyListener, data);
1126
1127     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: tizen_policy_add_listener is called.\n");
1128   }
1129   else if(strcmp(interface, tizen_display_policy_interface.name) == 0)
1130   {
1131     mTizenDisplayPolicy = static_cast<tizen_display_policy*>(wl_registry_bind(registry, name, &tizen_display_policy_interface, version));
1132     if(!mTizenDisplayPolicy)
1133     {
1134       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n");
1135       return;
1136     }
1137
1138     tizen_display_policy_add_listener(mTizenDisplayPolicy, &tizenDisplayPolicyListener, data);
1139
1140     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n");
1141   }
1142 }
1143
1144 void WindowBaseEcoreWl::RegistryGlobalCallbackRemove(void* data, struct wl_registry* registry, uint32_t id)
1145 {
1146   mTizenPolicy        = NULL;
1147   mTizenDisplayPolicy = NULL;
1148 }
1149
1150 void WindowBaseEcoreWl::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
1151 {
1152   mNotificationLevel           = level;
1153   mNotificationChangeState     = state;
1154   mNotificationLevelChangeDone = true;
1155
1156   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state);
1157 }
1158
1159 void WindowBaseEcoreWl::TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state)
1160 {
1161   mScreenOffMode            = mode;
1162   mScreenOffModeChangeState = state;
1163   mScreenOffModeChangeDone  = true;
1164
1165   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state);
1166 }
1167
1168 void WindowBaseEcoreWl::DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy* displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state)
1169 {
1170   mBrightness            = brightness;
1171   mBrightnessChangeState = state;
1172   mBrightnessChangeDone  = true;
1173
1174   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state);
1175 }
1176
1177 Any WindowBaseEcoreWl::GetNativeWindow()
1178 {
1179   return mEcoreWindow;
1180 }
1181
1182 int WindowBaseEcoreWl::GetNativeWindowId()
1183 {
1184   return ecore_wl_window_id_get(mEcoreWindow);
1185 }
1186
1187 std::string WindowBaseEcoreWl::GetNativeWindowResourceId()
1188 {
1189   return std::string();
1190 }
1191
1192 EGLNativeWindowType WindowBaseEcoreWl::CreateEglWindow(int width, int height)
1193 {
1194   mEglWindow = wl_egl_window_create(mWlSurface, width, height);
1195
1196   return static_cast<EGLNativeWindowType>(mEglWindow);
1197 }
1198
1199 void WindowBaseEcoreWl::DestroyEglWindow()
1200 {
1201   if(mEglWindow != NULL)
1202   {
1203     wl_egl_window_destroy(mEglWindow);
1204     mEglWindow = NULL;
1205   }
1206 }
1207
1208 void WindowBaseEcoreWl::SetEglWindowRotation(int angle)
1209 {
1210   wl_egl_window_rotation rotation;
1211
1212   switch(angle)
1213   {
1214     case 0:
1215     {
1216       rotation = ROTATION_0;
1217       break;
1218     }
1219     case 90:
1220     {
1221       rotation = ROTATION_270;
1222       break;
1223     }
1224     case 180:
1225     {
1226       rotation = ROTATION_180;
1227       break;
1228     }
1229     case 270:
1230     {
1231       rotation = ROTATION_90;
1232       break;
1233     }
1234     default:
1235     {
1236       rotation = ROTATION_0;
1237       break;
1238     }
1239   }
1240
1241   wl_egl_window_set_rotation(mEglWindow, rotation);
1242 }
1243
1244 void WindowBaseEcoreWl::SetEglWindowBufferTransform(int angle)
1245 {
1246   wl_output_transform bufferTransform;
1247
1248   switch(angle)
1249   {
1250     case 0:
1251     {
1252       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1253       break;
1254     }
1255     case 90:
1256     {
1257       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1258       break;
1259     }
1260     case 180:
1261     {
1262       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1263       break;
1264     }
1265     case 270:
1266     {
1267       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1268       break;
1269     }
1270     default:
1271     {
1272       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1273       break;
1274     }
1275   }
1276
1277   wl_egl_window_set_buffer_transform(mEglWindow, bufferTransform);
1278 }
1279
1280 void WindowBaseEcoreWl::SetEglWindowTransform(int angle)
1281 {
1282   wl_output_transform windowTransform;
1283
1284   switch(angle)
1285   {
1286     case 0:
1287     {
1288       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1289       break;
1290     }
1291     case 90:
1292     {
1293       windowTransform = WL_OUTPUT_TRANSFORM_90;
1294       break;
1295     }
1296     case 180:
1297     {
1298       windowTransform = WL_OUTPUT_TRANSFORM_180;
1299       break;
1300     }
1301     case 270:
1302     {
1303       windowTransform = WL_OUTPUT_TRANSFORM_270;
1304       break;
1305     }
1306     default:
1307     {
1308       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1309       break;
1310     }
1311   }
1312
1313   wl_egl_window_set_window_transform(mEglWindow, windowTransform);
1314 }
1315
1316 void WindowBaseEcoreWl::ResizeEglWindow(PositionSize positionSize)
1317 {
1318   wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
1319 }
1320
1321 bool WindowBaseEcoreWl::IsEglWindowRotationSupported()
1322 {
1323   // Check capability
1324   wl_egl_window_capability capability = static_cast<wl_egl_window_capability>(wl_egl_window_get_capabilities(mEglWindow));
1325   if(capability == WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED)
1326   {
1327     mSupportedPreProtation = true;
1328     return true;
1329   }
1330   mSupportedPreProtation = false;
1331   return false;
1332 }
1333
1334 void WindowBaseEcoreWl::Move(PositionSize positionSize)
1335 {
1336   ecore_wl_window_position_set(mEcoreWindow, positionSize.x, positionSize.y);
1337 }
1338
1339 void WindowBaseEcoreWl::Resize(PositionSize positionSize)
1340 {
1341   ecore_wl_window_update_size(mEcoreWindow, positionSize.width, positionSize.height);
1342 }
1343
1344 void WindowBaseEcoreWl::MoveResize(PositionSize positionSize)
1345 {
1346   ecore_wl_window_position_set(mEcoreWindow, positionSize.x, positionSize.y);
1347   ecore_wl_window_update_size(mEcoreWindow, positionSize.width, positionSize.height);
1348 }
1349
1350 void WindowBaseEcoreWl::SetLayout(unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan)
1351 {
1352 }
1353
1354 void WindowBaseEcoreWl::SetClass(const std::string& name, const std::string& className)
1355 {
1356   ecore_wl_window_title_set(mEcoreWindow, name.c_str());
1357   ecore_wl_window_class_name_set(mEcoreWindow, className.c_str());
1358 }
1359
1360 void WindowBaseEcoreWl::Raise()
1361 {
1362   // Use ecore_wl_window_activate to prevent the window shown without rendering
1363   ecore_wl_window_activate(mEcoreWindow);
1364 }
1365
1366 void WindowBaseEcoreWl::Lower()
1367 {
1368   ecore_wl_window_lower(mEcoreWindow);
1369 }
1370
1371 void WindowBaseEcoreWl::Activate()
1372 {
1373   ecore_wl_window_activate(mEcoreWindow);
1374 }
1375
1376 void WindowBaseEcoreWl::Maximize(bool maximize)
1377 {
1378 }
1379
1380 bool WindowBaseEcoreWl::IsMaximized() const
1381 {
1382   return false;
1383 }
1384
1385 void WindowBaseEcoreWl::SetMaximumSize(Dali::Window::WindowSize size)
1386 {
1387 }
1388
1389 void WindowBaseEcoreWl::Minimize(bool minimize)
1390 {
1391 }
1392
1393 bool WindowBaseEcoreWl::IsMinimized() const
1394 {
1395   return false;
1396 }
1397
1398 void WindowBaseEcoreWl::SetMimimumSize(Dali::Window::WindowSize size)
1399 {
1400 }
1401
1402 void WindowBaseEcoreWl::SetAvailableAnlges(const std::vector<int>& angles)
1403 {
1404   int rotations[4] = {0};
1405   DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl::SetAvailableAnlges, angle's count: %d\n", angles.size());
1406   for(std::size_t i = 0; i < angles.size(); ++i)
1407   {
1408     rotations[i] = static_cast<int>(angles[i]);
1409     DALI_LOG_RELEASE_INFO("%d ", rotations[i]);
1410   }
1411   ecore_wl_window_rotation_available_rotations_set(mEcoreWindow, rotations, angles.size());
1412 }
1413
1414 void WindowBaseEcoreWl::SetPreferredAngle(int angle)
1415 {
1416   ecore_wl_window_rotation_preferred_rotation_set(mEcoreWindow, angle);
1417 }
1418
1419 void WindowBaseEcoreWl::SetAcceptFocus(bool accept)
1420 {
1421   ecore_wl_window_focus_skip_set(mEcoreWindow, !accept);
1422 }
1423
1424 void WindowBaseEcoreWl::Show()
1425 {
1426   ecore_wl_window_show(mEcoreWindow);
1427 }
1428
1429 void WindowBaseEcoreWl::Hide()
1430 {
1431   ecore_wl_window_hide(mEcoreWindow);
1432 }
1433
1434 unsigned int WindowBaseEcoreWl::GetSupportedAuxiliaryHintCount() const
1435 {
1436   return mSupportedAuxiliaryHints.size();
1437 }
1438
1439 std::string WindowBaseEcoreWl::GetSupportedAuxiliaryHint(unsigned int index) const
1440 {
1441   if(index >= GetSupportedAuxiliaryHintCount())
1442   {
1443     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index);
1444   }
1445
1446   return mSupportedAuxiliaryHints[index];
1447 }
1448
1449 unsigned int WindowBaseEcoreWl::AddAuxiliaryHint(const std::string& hint, const std::string& value)
1450 {
1451   bool supported = false;
1452
1453   // Check if the hint is suppported
1454   for(std::vector<std::string>::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter)
1455   {
1456     if(*iter == hint)
1457     {
1458       supported = true;
1459       break;
1460     }
1461   }
1462
1463   if(!supported)
1464   {
1465     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str());
1466     return 0;
1467   }
1468
1469   // Check if the hint is already added
1470   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1471   {
1472     if(mAuxiliaryHints[i].first == hint)
1473     {
1474       // Just change the value
1475       mAuxiliaryHints[i].second = value;
1476
1477       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1);
1478
1479       return i + 1; // id is index + 1
1480     }
1481   }
1482
1483   // Add the hint
1484   mAuxiliaryHints.push_back(std::pair<std::string, std::string>(hint, value));
1485
1486   unsigned int id = mAuxiliaryHints.size();
1487
1488   ecore_wl_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
1489
1490   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
1491
1492   return id;
1493 }
1494
1495 bool WindowBaseEcoreWl::RemoveAuxiliaryHint(unsigned int id)
1496 {
1497   if(id == 0 || id > mAuxiliaryHints.size())
1498   {
1499     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::RemoveAuxiliaryHint: Invalid id [%d]\n", id);
1500     return false;
1501   }
1502
1503   mAuxiliaryHints[id - 1].second = std::string();
1504
1505   ecore_wl_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
1506
1507   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
1508
1509   return true;
1510 }
1511
1512 bool WindowBaseEcoreWl::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
1513 {
1514   if(id == 0 || id > mAuxiliaryHints.size())
1515   {
1516     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::SetAuxiliaryHintValue: Invalid id [%d]\n", id);
1517     return false;
1518   }
1519
1520   mAuxiliaryHints[id - 1].second = value;
1521
1522   ecore_wl_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
1523
1524   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str());
1525
1526   return true;
1527 }
1528
1529 std::string WindowBaseEcoreWl::GetAuxiliaryHintValue(unsigned int id) const
1530 {
1531   if(id == 0 || id > mAuxiliaryHints.size())
1532   {
1533     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::GetAuxiliaryHintValue: Invalid id [%d]\n", id);
1534     return std::string();
1535   }
1536
1537   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str());
1538
1539   return mAuxiliaryHints[id - 1].second;
1540 }
1541
1542 unsigned int WindowBaseEcoreWl::GetAuxiliaryHintId(const std::string& hint) const
1543 {
1544   for(unsigned int i = 0; i < mAuxiliaryHints.size(); i++)
1545   {
1546     if(mAuxiliaryHints[i].first == hint)
1547     {
1548       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1);
1549       return i + 1;
1550     }
1551   }
1552
1553   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str());
1554
1555   return 0;
1556 }
1557
1558 void WindowBaseEcoreWl::SetInputRegion(const Rect<int>& inputRegion)
1559 {
1560   ecore_wl_window_input_region_set(mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height);
1561 }
1562
1563 void WindowBaseEcoreWl::SetType(Dali::WindowType type)
1564 {
1565   Ecore_Wl_Window_Type windowType;
1566
1567   switch(type)
1568   {
1569     case Dali::WindowType::NORMAL:
1570     {
1571       windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1572       break;
1573     }
1574     case Dali::WindowType::NOTIFICATION:
1575     {
1576       windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1577       break;
1578     }
1579     case Dali::WindowType::UTILITY:
1580     {
1581       windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1582       break;
1583     }
1584     case Dali::WindowType::DIALOG:
1585     {
1586       windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1587       break;
1588     }
1589     default:
1590     {
1591       windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1592       break;
1593     }
1594   }
1595
1596   ecore_wl_window_type_set(mEcoreWindow, windowType);
1597 }
1598
1599 Dali::WindowType WindowBaseEcoreWl::GetType() const
1600 {
1601   return Dali::WindowType::NORMAL;
1602 }
1603
1604 Dali::WindowOperationResult WindowBaseEcoreWl::SetNotificationLevel(Dali::WindowNotificationLevel level)
1605 {
1606   while(!mTizenPolicy)
1607   {
1608     wl_display_dispatch_queue(mDisplay, mEventQueue);
1609   }
1610
1611   int notificationLevel;
1612
1613   switch(level)
1614   {
1615     case Dali::WindowNotificationLevel::NONE:
1616     {
1617       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1618       break;
1619     }
1620     case Dali::WindowNotificationLevel::BASE:
1621     {
1622       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1623       break;
1624     }
1625     case Dali::WindowNotificationLevel::MEDIUM:
1626     {
1627       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1628       break;
1629     }
1630     case Dali::WindowNotificationLevel::HIGH:
1631     {
1632       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1633       break;
1634     }
1635     case Dali::WindowNotificationLevel::TOP:
1636     {
1637       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1638       break;
1639     }
1640     default:
1641     {
1642       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: invalid level [%d]\n", level);
1643       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1644       break;
1645     }
1646   }
1647
1648   mNotificationLevelChangeDone = false;
1649   mNotificationChangeState     = TIZEN_POLICY_ERROR_STATE_NONE;
1650
1651   tizen_policy_set_notification_level(mTizenPolicy, ecore_wl_window_surface_get(mEcoreWindow), notificationLevel);
1652
1653   int count = 0;
1654
1655   while(!mNotificationLevelChangeDone && count < 3)
1656   {
1657     ecore_wl_flush();
1658     wl_display_dispatch_queue(mDisplay, mEventQueue);
1659     count++;
1660   }
1661
1662   if(!mNotificationLevelChangeDone)
1663   {
1664     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState);
1665     return Dali::WindowOperationResult::UNKNOWN_ERROR;
1666   }
1667   else if(mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
1668   {
1669     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Permission denied! [%d]\n", level);
1670     return Dali::WindowOperationResult::PERMISSION_DENIED;
1671   }
1672
1673   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel);
1674
1675   return Dali::WindowOperationResult::SUCCEED;
1676 }
1677
1678 Dali::WindowNotificationLevel WindowBaseEcoreWl::GetNotificationLevel() const
1679 {
1680   while(!mTizenPolicy)
1681   {
1682     wl_display_dispatch_queue(mDisplay, mEventQueue);
1683   }
1684
1685   int count = 0;
1686
1687   while(!mNotificationLevelChangeDone && count < 3)
1688   {
1689     ecore_wl_flush();
1690     wl_display_dispatch_queue(mDisplay, mEventQueue);
1691     count++;
1692   }
1693
1694   if(!mNotificationLevelChangeDone)
1695   {
1696     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState);
1697     return Dali::Window::NotificationLevel::NONE;
1698   }
1699
1700   Dali::WindowNotificationLevel level;
1701
1702   switch(mNotificationLevel)
1703   {
1704     case TIZEN_POLICY_LEVEL_NONE:
1705     {
1706       level = Dali::WindowNotificationLevel::NONE;
1707       break;
1708     }
1709     case TIZEN_POLICY_LEVEL_DEFAULT:
1710     {
1711       level = Dali::WindowNotificationLevel::BASE;
1712       break;
1713     }
1714     case TIZEN_POLICY_LEVEL_MEDIUM:
1715     {
1716       level = Dali::WindowNotificationLevel::MEDIUM;
1717       break;
1718     }
1719     case TIZEN_POLICY_LEVEL_HIGH:
1720     {
1721       level = Dali::WindowNotificationLevel::HIGH;
1722       break;
1723     }
1724     case TIZEN_POLICY_LEVEL_TOP:
1725     {
1726       level = Dali::WindowNotificationLevel::TOP;
1727       break;
1728     }
1729     default:
1730     {
1731       DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel);
1732       level = Dali::WindowNotificationLevel::NONE;
1733       break;
1734     }
1735   }
1736
1737   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: level [%d]\n", mNotificationLevel);
1738
1739   return level;
1740 }
1741
1742 void WindowBaseEcoreWl::SetOpaqueState(bool opaque)
1743 {
1744   while(!mTizenPolicy)
1745   {
1746     wl_display_dispatch_queue(mDisplay, mEventQueue);
1747   }
1748
1749   tizen_policy_set_opaque_state(mTizenPolicy, ecore_wl_window_surface_get(mEcoreWindow), (opaque ? 1 : 0));
1750 }
1751
1752 Dali::WindowOperationResult WindowBaseEcoreWl::SetScreenOffMode(WindowScreenOffMode screenOffMode)
1753 {
1754   while(!mTizenPolicy)
1755   {
1756     wl_display_dispatch_queue(mDisplay, mEventQueue);
1757   }
1758
1759   mScreenOffModeChangeDone  = false;
1760   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1761
1762   unsigned int mode = 0;
1763
1764   switch(screenOffMode)
1765   {
1766     case WindowScreenOffMode::TIMEOUT:
1767     {
1768       mode = 0;
1769       break;
1770     }
1771     case WindowScreenOffMode::NEVER:
1772     {
1773       mode = 1;
1774       break;
1775     }
1776   }
1777
1778   tizen_policy_set_window_screen_mode(mTizenPolicy, ecore_wl_window_surface_get(mEcoreWindow), mode);
1779
1780   int count = 0;
1781
1782   while(!mScreenOffModeChangeDone && count < 3)
1783   {
1784     ecore_wl_flush();
1785     wl_display_dispatch_queue(mDisplay, mEventQueue);
1786     count++;
1787   }
1788
1789   if(!mScreenOffModeChangeDone)
1790   {
1791     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState);
1792     return Dali::WindowOperationResult::UNKNOWN_ERROR;
1793   }
1794   else if(mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
1795   {
1796     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode);
1797     return Dali::WindowOperationResult::PERMISSION_DENIED;
1798   }
1799
1800   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode);
1801
1802   return Dali::WindowOperationResult::SUCCEED;
1803 }
1804
1805 WindowScreenOffMode WindowBaseEcoreWl::GetScreenOffMode() const
1806 {
1807   while(!mTizenPolicy)
1808   {
1809     wl_display_dispatch_queue(mDisplay, mEventQueue);
1810   }
1811
1812   int count = 0;
1813
1814   while(!mScreenOffModeChangeDone && count < 3)
1815   {
1816     ecore_wl_flush();
1817     wl_display_dispatch_queue(mDisplay, mEventQueue);
1818     count++;
1819   }
1820
1821   if(!mScreenOffModeChangeDone)
1822   {
1823     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState);
1824     return WindowScreenOffMode::TIMEOUT;
1825   }
1826
1827   WindowScreenOffMode screenMode = WindowScreenOffMode::TIMEOUT;
1828
1829   switch(mScreenOffMode)
1830   {
1831     case 0:
1832     {
1833       screenMode = WindowScreenOffMode::TIMEOUT;
1834       break;
1835     }
1836     case 1:
1837     {
1838       screenMode = WindowScreenOffMode::NEVER;
1839       break;
1840     }
1841   }
1842
1843   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode);
1844
1845   return screenMode;
1846 }
1847
1848 Dali::WindowOperationResult WindowBaseEcoreWl::SetBrightness(int brightness)
1849 {
1850   while(!mTizenDisplayPolicy)
1851   {
1852     wl_display_dispatch_queue(mDisplay, mEventQueue);
1853   }
1854
1855   mBrightnessChangeDone  = false;
1856   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1857
1858   tizen_display_policy_set_window_brightness(mTizenDisplayPolicy, ecore_wl_window_surface_get(mEcoreWindow), brightness);
1859
1860   int count = 0;
1861
1862   while(!mBrightnessChangeDone && count < 3)
1863   {
1864     ecore_wl_flush();
1865     wl_display_dispatch_queue(mDisplay, mEventQueue);
1866     count++;
1867   }
1868
1869   if(!mBrightnessChangeDone)
1870   {
1871     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState);
1872     return Dali::WindowOperationResult::UNKNOWN_ERROR;
1873   }
1874   else if(mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
1875   {
1876     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Permission denied! [%d]\n", brightness);
1877     return Dali::WindowOperationResult::PERMISSION_DENIED;
1878   }
1879
1880   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Brightness is changed [%d]\n", mBrightness);
1881
1882   return Dali::WindowOperationResult::SUCCEED;
1883 }
1884
1885 int WindowBaseEcoreWl::GetBrightness() const
1886 {
1887   while(!mTizenDisplayPolicy)
1888   {
1889     wl_display_dispatch_queue(mDisplay, mEventQueue);
1890   }
1891
1892   int count = 0;
1893
1894   while(!mBrightnessChangeDone && count < 3)
1895   {
1896     ecore_wl_flush();
1897     wl_display_dispatch_queue(mDisplay, mEventQueue);
1898     count++;
1899   }
1900
1901   if(!mBrightnessChangeDone)
1902   {
1903     DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetBrightness: Error! [%d]\n", mBrightnessChangeState);
1904     return 0;
1905   }
1906
1907   DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetBrightness: Brightness [%d]\n", mBrightness);
1908
1909   return mBrightness;
1910 }
1911
1912 bool WindowBaseEcoreWl::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
1913 {
1914   Ecore_Wl_Window_Keygrab_Mode mode;
1915
1916   switch(grabMode)
1917   {
1918     case KeyGrab::TOPMOST:
1919     {
1920       mode = ECORE_WL_WINDOW_KEYGRAB_TOPMOST;
1921       break;
1922     }
1923     case KeyGrab::SHARED:
1924     {
1925       mode = ECORE_WL_WINDOW_KEYGRAB_SHARED;
1926       break;
1927     }
1928     case KeyGrab::OVERRIDE_EXCLUSIVE:
1929     {
1930       mode = ECORE_WL_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
1931       break;
1932     }
1933     case KeyGrab::EXCLUSIVE:
1934     {
1935       mode = ECORE_WL_WINDOW_KEYGRAB_EXCLUSIVE;
1936       break;
1937     }
1938     default:
1939     {
1940       return false;
1941     }
1942   }
1943
1944   return ecore_wl_window_keygrab_set(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0, 0, mode);
1945 }
1946
1947 bool WindowBaseEcoreWl::UngrabKey(Dali::KEY key)
1948 {
1949   return ecore_wl_window_keygrab_unset(mEcoreWindow, KeyLookup::GetKeyName(key), 0, 0);
1950 }
1951
1952 bool WindowBaseEcoreWl::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
1953 {
1954   int keyCount         = key.Count();
1955   int keyGrabModeCount = grabMode.Count();
1956
1957   if(keyCount != keyGrabModeCount || keyCount == 0)
1958   {
1959     return false;
1960   }
1961
1962   eina_init();
1963
1964   Eina_List*                    keyList = NULL;
1965   Ecore_Wl_Window_Keygrab_Info* info    = new Ecore_Wl_Window_Keygrab_Info[keyCount];
1966
1967   for(int index = 0; index < keyCount; ++index)
1968   {
1969     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
1970
1971     switch(grabMode[index])
1972     {
1973       case KeyGrab::TOPMOST:
1974       {
1975         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_TOPMOST;
1976         break;
1977       }
1978       case KeyGrab::SHARED:
1979       {
1980         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_SHARED;
1981         break;
1982       }
1983       case KeyGrab::OVERRIDE_EXCLUSIVE:
1984       {
1985         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
1986         break;
1987       }
1988       case KeyGrab::EXCLUSIVE:
1989       {
1990         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_EXCLUSIVE;
1991         break;
1992       }
1993       default:
1994       {
1995         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_UNKNOWN;
1996         break;
1997       }
1998     }
1999
2000     keyList = eina_list_append(keyList, &info);
2001   }
2002
2003   Eina_List* grabList = ecore_wl_window_keygrab_list_set(mEcoreWindow, keyList);
2004
2005   result.Resize(keyCount, true);
2006
2007   Eina_List* l        = NULL;
2008   Eina_List* m        = NULL;
2009   void*      listData = NULL;
2010   void*      data     = NULL;
2011   if(grabList != NULL)
2012   {
2013     EINA_LIST_FOREACH(grabList, m, data)
2014     {
2015       int index = 0;
2016       EINA_LIST_FOREACH(keyList, l, listData)
2017       {
2018         if(static_cast<Ecore_Wl_Window_Keygrab_Info*>(listData)->key == NULL)
2019         {
2020           DALI_LOG_ERROR("input key list has null data!");
2021           break;
2022         }
2023
2024         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl_Window_Keygrab_Info*>(listData)->key) == 0)
2025         {
2026           result[index] = false;
2027         }
2028         ++index;
2029       }
2030     }
2031   }
2032
2033   delete[] info;
2034
2035   eina_list_free(keyList);
2036   eina_list_free(grabList);
2037   eina_shutdown();
2038
2039   return true;
2040 }
2041
2042 bool WindowBaseEcoreWl::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
2043 {
2044   int keyCount = key.Count();
2045   if(keyCount == 0)
2046   {
2047     return false;
2048   }
2049
2050   eina_init();
2051
2052   Eina_List*                    keyList = NULL;
2053   Ecore_Wl_Window_Keygrab_Info* info    = new Ecore_Wl_Window_Keygrab_Info[keyCount];
2054
2055   for(int index = 0; index < keyCount; ++index)
2056   {
2057     info[index].key = const_cast<char*>(KeyLookup::GetKeyName(key[index]));
2058     keyList         = eina_list_append(keyList, &info);
2059   }
2060
2061   Eina_List* ungrabList = ecore_wl_window_keygrab_list_unset(mEcoreWindow, keyList);
2062
2063   result.Resize(keyCount, true);
2064
2065   Eina_List* l        = NULL;
2066   Eina_List* m        = NULL;
2067   void*      listData = NULL;
2068   void*      data     = NULL;
2069
2070   if(ungrabList != NULL)
2071   {
2072     EINA_LIST_FOREACH(ungrabList, m, data)
2073     {
2074       int index = 0;
2075       EINA_LIST_FOREACH(keyList, l, listData)
2076       {
2077         if(strcmp(static_cast<char*>(data), static_cast<Ecore_Wl_Window_Keygrab_Info*>(listData)->key) == 0)
2078         {
2079           result[index] = false;
2080         }
2081         ++index;
2082       }
2083     }
2084   }
2085
2086   delete[] info;
2087
2088   eina_list_free(keyList);
2089   eina_list_free(ungrabList);
2090   eina_shutdown();
2091
2092   return true;
2093 }
2094
2095 void WindowBaseEcoreWl::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
2096 {
2097   // calculate DPI
2098   float xres, yres;
2099
2100   // 1 inch = 25.4 millimeters
2101   xres = ecore_wl_dpi_get();
2102   yres = ecore_wl_dpi_get();
2103
2104   dpiHorizontal = int(xres + 0.5f); // rounding
2105   dpiVertical   = int(yres + 0.5f);
2106 }
2107
2108 int WindowBaseEcoreWl::GetWindowRotationAngle() const
2109 {
2110   int orientation = mWindowRotationAngle;
2111   if(mSupportedPreProtation)
2112   {
2113     orientation = 0;
2114   }
2115   return orientation;
2116 }
2117
2118 int WindowBaseEcoreWl::GetScreenRotationAngle()
2119 {
2120   int transform = 0;
2121
2122   if(ecore_wl_window_ignore_output_transform_get(mEcoreWindow))
2123   {
2124     transform = 0;
2125   }
2126   else
2127   {
2128     transform = ecore_wl_output_transform_get(ecore_wl_window_output_find(mEcoreWindow));
2129   }
2130
2131   mScreenRotationAngle = transform * 90;
2132   return mScreenRotationAngle;
2133 }
2134
2135 void WindowBaseEcoreWl::SetWindowRotationAngle(int degree)
2136 {
2137   mWindowRotationAngle = degree;
2138   ecore_wl_window_rotation_set(mEcoreWindow, degree);
2139 }
2140
2141 void WindowBaseEcoreWl::WindowRotationCompleted(int degree, int width, int height)
2142 {
2143   ecore_wl_window_rotation_change_done_send(mEcoreWindow);
2144 }
2145
2146 void WindowBaseEcoreWl::SetTransparency(bool transparent)
2147 {
2148   ecore_wl_window_alpha_set(mEcoreWindow, transparent);
2149 }
2150
2151 void WindowBaseEcoreWl::CreateWindow(PositionSize positionSize)
2152 {
2153   mEcoreWindow = ecore_wl_window_new(0, positionSize.x, positionSize.y, positionSize.width, positionSize.height, ECORE_WL_WINDOW_BUFFER_TYPE_EGL_WINDOW);
2154
2155   if(mEcoreWindow == 0)
2156   {
2157     DALI_ASSERT_ALWAYS(0 && "Failed to create Wayland window");
2158   }
2159 }
2160
2161 void WindowBaseEcoreWl::SetParent(WindowBase* parentWinBase, bool belowParent)
2162 {
2163   Ecore_Wl_Window* ecoreParent = NULL;
2164   if(parentWinBase)
2165   {
2166     WindowBaseEcoreWl* winBaseEcore = static_cast<WindowBaseEcoreWl*>(parentWinBase);
2167     ecoreParent                     = winBaseEcore->mEcoreWindow;
2168   }
2169   ecore_wl_window_parent_set(mEcoreWindow, ecoreParent);
2170 }
2171
2172 int WindowBaseEcoreWl::CreateFrameRenderedSyncFence()
2173 {
2174   return -1;
2175 }
2176
2177 int WindowBaseEcoreWl::CreateFramePresentedSyncFence()
2178 {
2179   return -1;
2180 }
2181
2182 void WindowBaseEcoreWl::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
2183 {
2184 }
2185
2186 void WindowBaseEcoreWl::InitializeIme()
2187 {
2188 }
2189
2190 void WindowBaseEcoreWl::ImeWindowReadyToRender()
2191 {
2192 }
2193
2194 void WindowBaseEcoreWl::RequestMoveToServer()
2195 {
2196 }
2197
2198 void WindowBaseEcoreWl::RequestResizeToServer(WindowResizeDirection direction)
2199 {
2200 }
2201
2202 void WindowBaseEcoreWl::EnableFloatingMode(bool enable)
2203 {
2204 }
2205
2206 bool WindowBaseEcoreWl::IsFloatingModeEnabled() const
2207 {
2208   return false;
2209 }
2210
2211 void WindowBaseEcoreWl::IncludeInputRegion(const Rect<int>& inputRegion)
2212 {
2213 }
2214
2215 void WindowBaseEcoreWl::ExcludeInputRegion(const Rect<int>& inputRegion)
2216 {
2217 }
2218
2219 void WindowBaseEcoreWl::SetFrontBufferRendering(bool enable)
2220 {
2221 }
2222
2223 bool WindowBaseEcoreWl::GetFrontBufferRendering()
2224 {
2225   return false;
2226 }
2227
2228 void WindowBaseEcoreWl::SetEglWindowFrontBufferMode(bool enable)
2229 {
2230 }
2231
2232 } // namespace Adaptor
2233
2234 } // namespace Internal
2235
2236 } // namespace Dali
2237
2238 #pragma GCC diagnostic pop