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