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

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