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   mWindowRotationAngle( 0 ),
 714   mScreenRotationAngle( 0 ),
 715   mSupportedPreProtation( 0 )
 716 #ifdef DALI_ELDBUS_AVAILABLE
 717   , mSystemConnection( NULL )
 718 #endif
 719 {
 720   Initialize( positionSize, surface, isTransparent );
 721 }
 722
 723 WindowBaseEcoreWl2::~WindowBaseEcoreWl2()
 724 {
 725 #ifdef DALI_ELDBUS_AVAILABLE
 726     // Close down ElDBus connections.
 727     if( mSystemConnection )
 728     {
 729       eldbus_connection_unref( mSystemConnection );
 730     }
 731 #endif // DALI_ELDBUS_AVAILABLE
 732
 733   vconf_ignore_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged );
 734   vconf_ignore_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged );
 735
 736   for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter )
 737   {
 738     ecore_event_handler_del( *iter );
 739   }
 740   mEcoreEventHandler.Clear();
 741
 742   if( mEventQueue )
 743   {
 744     wl_event_queue_destroy( mEventQueue );
 745   }
 746
 747   mSupportedAuxiliaryHints.clear();
 748   mAuxiliaryHints.clear();
 749
 750   if( mEglWindow != NULL )
 751   {
 752     wl_egl_window_destroy( mEglWindow );
 753     mEglWindow = NULL;
 754   }
 755
 756   if( mOwnSurface )
 757   {
 758     ecore_wl2_window_free( mEcoreWindow );
 759
 760     WindowSystem::Shutdown();
 761   }
 762 }
 763
 764 void WindowBaseEcoreWl2::Initialize( PositionSize positionSize, Any surface, bool isTransparent )
 765 {
 766   if( surface.Empty() == false )
 767   {
 768     // check we have a valid type
 769     DALI_ASSERT_ALWAYS( ( surface.GetType() == typeid (Ecore_Wl2_Window *) ) && "Surface type is invalid" );
 770
 771     mEcoreWindow = AnyCast< Ecore_Wl2_Window* >( surface );
 772   }
 773   else
 774   {
 775     // we own the surface about to created
 776     WindowSystem::Initialize();
 777
 778     mOwnSurface = true;
 779     CreateWindow( positionSize );
 780   }
 781
 782   mWlSurface = ecore_wl2_window_surface_get( mEcoreWindow );
 783
 784   SetTransparency( isTransparent );
 785
 786   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_ICONIFY_STATE_CHANGE,  EcoreEventWindowIconifyStateChanged, this ) );
 787   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_FOCUS_IN,                     EcoreEventWindowFocusIn,             this ) );
 788   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_FOCUS_OUT,                    EcoreEventWindowFocusOut,            this ) );
 789   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_OUTPUT_TRANSFORM,             EcoreEventOutputTransform,           this ) );
 790   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_IGNORE_OUTPUT_TRANSFORM,      EcoreEventIgnoreOutputTransform,     this ) );
 791
 792   // Register Rotate event
 793   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_ROTATE,                EcoreEventRotate,                    this ) );
 794
 795   // Register Configure event
 796   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_CONFIGURE,             EcoreEventConfigure,                 this ) );
 797
 798   // Register Touch events
 799   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,                EcoreEventMouseButtonDown,           this ) );
 800   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,                  EcoreEventMouseButtonUp,             this ) );
 801   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE,                       EcoreEventMouseButtonMove,           this ) );
 802   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_CANCEL,              EcoreEventMouseButtonCancel,         this ) );
 803
 804   // Register Mouse wheel events
 805   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL,                      EcoreEventMouseWheel,                this ) );
 806
 807   // Register Detent event
 808   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_DETENT_ROTATE,                    EcoreEventDetentRotation,            this ) );
 809
 810   // Register Key events
 811   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN,                         EcoreEventKeyDown,                   this ) );
 812   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_UP,                           EcoreEventKeyUp,                     this ) );
 813
 814   // Register Selection event - clipboard selection
 815   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_DATA_SOURCE_SEND,             EcoreEventDataSend,                  this ) );
 816   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SELECTION_DATA_READY,         EcoreEventDataReceive,               this ) );
 817
 818   // Register Effect Start/End event
 819   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_EFFECT_START,                 EcoreEventEffectStart,               this ) );
 820   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_EFFECT_END,                   EcoreEventEffectEnd,                 this ) );
 821
 822   // Register Keyboard repeat event
 823   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SEAT_KEYBOARD_REPEAT_CHANGED, EcoreEventSeatKeyboardRepeatChanged, this ) );
 824
 825   // Register Vconf notify - font name and size
 826   vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this );
 827   vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this );
 828
 829   InitializeEcoreElDBus();
 830
 831   Ecore_Wl2_Display* display = ecore_wl2_connected_display_get( NULL );
 832   mDisplay = ecore_wl2_display_get( display );
 833
 834   if( mDisplay )
 835   {
 836     wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) );
 837     if( displayWrapper )
 838     {
 839       mEventQueue = wl_display_create_queue( mDisplay );
 840       if( mEventQueue )
 841       {
 842         wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue );
 843
 844         wl_registry* registry = wl_display_get_registry( displayWrapper );
 845         wl_registry_add_listener( registry, &registryListener, this );
 846       }
 847
 848       wl_proxy_wrapper_destroy( displayWrapper );
 849     }
 850   }
 851
 852   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get( display );
 853
 854   if( ecoreWlInput )
 855   {
 856     mKeyMap = ecore_wl2_input_keymap_get( ecoreWlInput );
 857
 858     mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this ) );
 859   }
 860
 861   // get auxiliary hint
 862   Eina_List* hints = ecore_wl2_window_aux_hints_supported_get( mEcoreWindow );
 863   if( hints )
 864   {
 865     Eina_List* l = NULL;
 866     char* hint = NULL;
 867
 868     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) ) ) )
 869     {
 870       mSupportedAuxiliaryHints.push_back( hint );
 871
 872       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::Initialize: %s\n", hint );
 873     }
 874   }
 875 }
 876
 877 Eina_Bool WindowBaseEcoreWl2::OnIconifyStateChanged( void* data, int type, void* event )
 878 {
 879   Ecore_Wl2_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl2_Event_Window_Iconify_State_Change* >( event ) );
 880   Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 881
 882   if( iconifyChangedEvent->win == static_cast< unsigned int>( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 883   {
 884     if( iconifyChangedEvent->iconified == EINA_TRUE )
 885     {
 886       mIconifyChangedSignal.Emit( true );
 887     }
 888     else
 889     {
 890       mIconifyChangedSignal.Emit( false );
 891     }
 892     handled = ECORE_CALLBACK_DONE;
 893   }
 894
 895   return handled;
 896 }
 897
 898 Eina_Bool WindowBaseEcoreWl2::OnFocusIn( void* data, int type, void* event )
 899 {
 900   Ecore_Wl2_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl2_Event_Focus_In* >( event ) );
 901
 902   if( focusInEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 903   {
 904     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
 905
 906     mFocusChangedSignal.Emit( true );
 907   }
 908
 909   return ECORE_CALLBACK_PASS_ON;
 910 }
 911
 912 Eina_Bool WindowBaseEcoreWl2::OnFocusOut( void* data, int type, void* event )
 913 {
 914   Ecore_Wl2_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl2_Event_Focus_Out* >( event ) );
 915
 916   if( focusOutEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 917   {
 918     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
 919
 920     mFocusChangedSignal.Emit( false );
 921   }
 922
 923   return ECORE_CALLBACK_PASS_ON;
 924 }
 925
 926 Eina_Bool WindowBaseEcoreWl2::OnOutputTransform( void* data, int type, void* event )
 927 {
 928   Ecore_Wl2_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl2_Event_Output_Transform* >( event ) );
 929
 930   if( transformEvent->output == ecore_wl2_window_output_find( mEcoreWindow ) )
 931   {
 932     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow );
 933
 934     mOutputTransformedSignal.Emit();
 935   }
 936
 937   return ECORE_CALLBACK_PASS_ON;
 938 }
 939
 940 Eina_Bool WindowBaseEcoreWl2::OnIgnoreOutputTransform( void* data, int type, void* event )
 941 {
 942   Ecore_Wl2_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl2_Event_Ignore_Output_Transform* >( event ) );
 943
 944   if( ignoreTransformEvent->win == mEcoreWindow )
 945   {
 946     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow );
 947
 948     mOutputTransformedSignal.Emit();
 949   }
 950
 951   return ECORE_CALLBACK_PASS_ON;
 952 }
 953
 954 void WindowBaseEcoreWl2::OnRotation( void* data, int type, void* event )
 955 {
 956   Ecore_Wl2_Event_Window_Rotation* ev( static_cast< Ecore_Wl2_Event_Window_Rotation* >( event ) );
 957
 958   if( ev->win == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 959   {
 960     DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h );
 961
 962     RotationEvent rotationEvent;
 963     rotationEvent.angle = ev->angle;
 964     rotationEvent.winResize = 0;
 965
 966     if( ev->angle == 0 || ev->angle == 180 )
 967     {
 968       rotationEvent.width = ev->w;
 969       rotationEvent.height = ev->h;
 970     }
 971     else
 972     {
 973       rotationEvent.width = ev->h;
 974       rotationEvent.height = ev->w;
 975     }
 976
 977     mWindowPositionSize.width = rotationEvent.width;
 978     mWindowPositionSize.height = rotationEvent.height;
 979
 980     mRotationSignal.Emit( rotationEvent );
 981   }
 982 }
 983
 984 void WindowBaseEcoreWl2::OnConfiguration( void* data, int type, void* event )
 985 {
 986   Ecore_Wl2_Event_Window_Configure* ev( static_cast< Ecore_Wl2_Event_Window_Configure* >( event ) );
 987
 988   if( ev->win == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
 989   {
 990     // Note: To comply with the wayland protocol, Dali should make an ack_configure
 991     // by calling ecore_wl2_window_commit
 992     ecore_wl2_window_commit(mEcoreWindow, EINA_FALSE);
 993   }
 994 }
 995
 996 void WindowBaseEcoreWl2::OnMouseButtonDown( void* data, int type, void* event )
 997 {
 998   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 999
1000   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1001   {
1002     Device::Class::Type deviceClass;
1003     Device::Subclass::Type deviceSubclass;
1004
1005     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
1006     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
1007
1008     PointState::Type state ( PointState::DOWN );
1009
1010     if( deviceClass != Device::Class::Type::MOUSE )
1011     {
1012       // Check if the buttons field is set and ensure it's the primary touch button.
1013       // If this event was triggered by buttons other than the primary button (used for touch), then
1014       // just send an interrupted event to Core.
1015       if( touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID ) )
1016       {
1017         state = PointState::INTERRUPTED;
1018       }
1019     }
1020
1021     Integration::Point point;
1022     point.SetDeviceId( touchEvent->multi.device );
1023     point.SetState( state );
1024     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
1025     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
1026     point.SetPressure( touchEvent->multi.pressure );
1027     point.SetAngle( Degree( touchEvent->multi.angle ) );
1028     point.SetDeviceClass( deviceClass );
1029     point.SetDeviceSubclass( deviceSubclass );
1030     point.SetMouseButton( static_cast< MouseButton::Type >( touchEvent->buttons) );
1031
1032     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1033   }
1034 }
1035
1036 void WindowBaseEcoreWl2::OnMouseButtonUp( void* data, int type, void* event )
1037 {
1038   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
1039
1040   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1041   {
1042     Device::Class::Type deviceClass;
1043     Device::Subclass::Type deviceSubclass;
1044
1045     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
1046     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
1047
1048     Integration::Point point;
1049     point.SetDeviceId( touchEvent->multi.device );
1050     point.SetState( PointState::UP );
1051     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
1052     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
1053     point.SetPressure( touchEvent->multi.pressure );
1054     point.SetAngle( Degree( touchEvent->multi.angle ) );
1055     point.SetDeviceClass( deviceClass );
1056     point.SetDeviceSubclass( deviceSubclass );
1057     point.SetMouseButton( static_cast< MouseButton::Type >( touchEvent->buttons) );
1058
1059     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1060   }
1061 }
1062
1063 void WindowBaseEcoreWl2::OnMouseButtonMove( void* data, int type, void* event )
1064 {
1065   Ecore_Event_Mouse_Move* touchEvent = static_cast< Ecore_Event_Mouse_Move* >( event );
1066
1067   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1068   {
1069     Device::Class::Type deviceClass;
1070     Device::Subclass::Type deviceSubclass;
1071
1072     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
1073     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
1074
1075     Integration::Point point;
1076     point.SetDeviceId( touchEvent->multi.device );
1077     point.SetState( PointState::MOTION );
1078     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
1079     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
1080     point.SetPressure( touchEvent->multi.pressure );
1081     point.SetAngle( Degree( touchEvent->multi.angle ) );
1082     point.SetDeviceClass( deviceClass );
1083     point.SetDeviceSubclass( deviceSubclass );
1084
1085     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1086   }
1087 }
1088
1089 void WindowBaseEcoreWl2::OnMouseButtonCancel( void* data, int type, void* event )
1090 {
1091   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
1092
1093   if( touchEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1094   {
1095     Integration::Point point;
1096     point.SetDeviceId( touchEvent->multi.device );
1097     point.SetState( PointState::INTERRUPTED );
1098     point.SetScreenPosition( Vector2( 0.0f, 0.0f ) );
1099
1100     mTouchEventSignal.Emit( point, touchEvent->timestamp );
1101
1102     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseButtonCancel\n" );
1103   }
1104 }
1105
1106 void WindowBaseEcoreWl2::OnMouseWheel( void* data, int type, void* event )
1107 {
1108   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast< Ecore_Event_Mouse_Wheel* >( event );
1109
1110   if( mouseWheelEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1111   {
1112     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseWheel: direction: %d, modifiers: %d, x: %d, y: %d, z: %d\n", mouseWheelEvent->direction, mouseWheelEvent->modifiers, mouseWheelEvent->x, mouseWheelEvent->y, mouseWheelEvent->z );
1113
1114     WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2( mouseWheelEvent->x, mouseWheelEvent->y ), mouseWheelEvent->z, mouseWheelEvent->timestamp );
1115
1116     mWheelEventSignal.Emit( wheelEvent );
1117   }
1118 }
1119
1120 void WindowBaseEcoreWl2::OnDetentRotation( void* data, int type, void* event )
1121 {
1122   Ecore_Event_Detent_Rotate* detentEvent = static_cast< Ecore_Event_Detent_Rotate* >( event );
1123
1124   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n" );
1125
1126   int direction = ( detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE ) ? 1 : -1;
1127   int timeStamp = detentEvent->timestamp;
1128
1129   WheelEvent wheelEvent( WheelEvent::CUSTOM_WHEEL, direction, 0, Vector2( 0.0f, 0.0f ), 0, timeStamp );
1130
1131   mWheelEventSignal.Emit( wheelEvent );
1132 }
1133
1134 void WindowBaseEcoreWl2::OnKeyDown( void* data, int type, void* event )
1135 {
1136   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
1137
1138   if( keyEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1139   {
1140     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyDown\n" );
1141
1142     std::string keyName( keyEvent->keyname );
1143     std::string logicalKey( "" );
1144     std::string keyString( "" );
1145     std::string compose( "" );
1146
1147     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1148     if( keyEvent->compose )
1149     {
1150       compose = keyEvent->compose;
1151     }
1152
1153     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1154     if( keyEvent->key )
1155     {
1156       logicalKey = keyEvent->key;
1157     }
1158
1159     int keyCode = 0;
1160     GetKeyCode( keyName, keyCode ); // Get key code dynamically.
1161
1162     if( keyCode == 0 )
1163     {
1164       // Get a specific key code from dali key look up table.
1165       keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1166     }
1167
1168     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1169     int modifier( keyEvent->modifiers );
1170     unsigned long time = keyEvent->timestamp;
1171     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1172     {
1173       keyCode = atoi( keyEvent->keyname + 8 );
1174     }
1175
1176     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1177     if( keyEvent->string )
1178     {
1179       keyString = keyEvent->string;
1180     }
1181
1182     std::string deviceName;
1183     Device::Class::Type deviceClass;
1184     Device::Subclass::Type deviceSubclass;
1185
1186     GetDeviceName( keyEvent, deviceName );
1187     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1188     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1189
1190     Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, compose, deviceName, deviceClass, deviceSubclass );
1191
1192      mKeyEventSignal.Emit( keyEvent );
1193   }
1194 }
1195
1196 void WindowBaseEcoreWl2::OnKeyUp( void* data, int type, void* event )
1197 {
1198   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
1199
1200   if( keyEvent->window == static_cast< unsigned int >( ecore_wl2_window_id_get( mEcoreWindow ) ) )
1201   {
1202     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnKeyUp\n" );
1203
1204     std::string keyName( keyEvent->keyname );
1205     std::string logicalKey( "" );
1206     std::string keyString( "" );
1207     std::string compose( "" );
1208
1209     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1210     if( keyEvent->compose )
1211     {
1212       compose = keyEvent->compose;
1213     }
1214
1215     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1216     if( keyEvent->key )
1217     {
1218       logicalKey = keyEvent->key;
1219     }
1220
1221     int keyCode = 0;
1222     GetKeyCode( keyName, keyCode ); // Get key code dynamically.
1223
1224     if( keyCode == 0 )
1225     {
1226       // Get a specific key code from dali key look up table.
1227       keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1228     }
1229
1230     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1231     int modifier( keyEvent->modifiers );
1232     unsigned long time = keyEvent->timestamp;
1233     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1234     {
1235       keyCode = atoi( keyEvent->keyname + 8 );
1236     }
1237
1238     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1239     if( keyEvent->string )
1240     {
1241       keyString = keyEvent->string;
1242     }
1243
1244     std::string deviceName;
1245     Device::Class::Type deviceClass;
1246     Device::Subclass::Type deviceSubclass;
1247
1248     GetDeviceName( keyEvent, deviceName );
1249     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1250     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1251
1252     Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, compose, deviceName, deviceClass, deviceSubclass );
1253
1254      mKeyEventSignal.Emit( keyEvent );
1255   }
1256 }
1257
1258 void WindowBaseEcoreWl2::OnDataSend( void* data, int type, void* event )
1259 {
1260   mSelectionDataSendSignal.Emit( event );
1261 }
1262
1263 void WindowBaseEcoreWl2::OnDataReceive( void* data, int type, void* event )
1264 {
1265   mSelectionDataReceivedSignal.Emit( event  );
1266 }
1267
1268 void WindowBaseEcoreWl2::OnFontNameChanged()
1269 {
1270   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_CHANGE );
1271 }
1272
1273 void WindowBaseEcoreWl2::OnFontSizeChanged()
1274 {
1275   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
1276 }
1277
1278 void WindowBaseEcoreWl2::OnEcoreElDBusAccessibilityNotification( void* context, const Eldbus_Message* message )
1279 {
1280 #ifdef DALI_ELDBUS_AVAILABLE
1281   AccessibilityInfo info;
1282
1283   // The string defines the arg-list's respective types.
1284   if( !eldbus_message_arguments_get( message, "iiiiiiu", &info.gestureValue, &info.startX, &info.startY, &info.endX, &info.endY, &info.state, &info.eventTime ) )
1285   {
1286     DALI_LOG_ERROR( "OnEcoreElDBusAccessibilityNotification: Error getting arguments\n" );
1287   }
1288
1289   mAccessibilitySignal.Emit( info );
1290 #endif
1291 }
1292
1293 void WindowBaseEcoreWl2::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type )
1294 {
1295   mTransitionEffectEventSignal.Emit( state, type );
1296 }
1297
1298 void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
1299 {
1300   mKeyboardRepeatSettingsChangedSignal.Emit();
1301 }
1302
1303 void WindowBaseEcoreWl2::KeymapChanged(void *data, int type, void *event)
1304 {
1305   Ecore_Wl2_Event_Seat_Keymap_Changed *changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>( event );
1306   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::KeymapChanged, keymap id[ %d ]\n", changed->id );
1307   Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get( changed->display );
1308   if( ecoreWlInput )
1309   {
1310     mKeyMap = ecore_wl2_input_keymap_get( ecoreWlInput );
1311   }
1312 }
1313
1314 void WindowBaseEcoreWl2::RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
1315 {
1316   if( strcmp( interface, tizen_policy_interface.name ) == 0 )
1317   {
1318     uint32_t clientVersion = std::min( version, MAX_TIZEN_CLIENT_VERSION );
1319
1320     mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, clientVersion ) );
1321     if( !mTizenPolicy )
1322     {
1323       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" );
1324       return;
1325     }
1326
1327     tizen_policy_add_listener( mTizenPolicy, &tizenPolicyListener, data );
1328
1329     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" );
1330   }
1331   else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 )
1332   {
1333     mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) );
1334     if( !mTizenDisplayPolicy )
1335     {
1336       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" );
1337       return;
1338     }
1339
1340     tizen_display_policy_add_listener( mTizenDisplayPolicy, &tizenDisplayPolicyListener, data );
1341
1342     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" );
1343   }
1344 }
1345
1346 void WindowBaseEcoreWl2::RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
1347 {
1348   mTizenPolicy = NULL;
1349   mTizenDisplayPolicy = NULL;
1350 }
1351
1352 void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
1353 {
1354   mNotificationLevel = level;
1355   mNotificationChangeState = state;
1356   mNotificationLevelChangeDone = true;
1357
1358   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state );
1359 }
1360
1361 void WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
1362 {
1363   mScreenOffMode = mode;
1364   mScreenOffModeChangeState = state;
1365   mScreenOffModeChangeDone = true;
1366
1367   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
1368 }
1369
1370 void WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
1371 {
1372   mBrightness = brightness;
1373   mBrightnessChangeState = state;
1374   mBrightnessChangeDone = true;
1375
1376   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
1377 }
1378
1379 void WindowBaseEcoreWl2::GetKeyCode( std::string keyName, int32_t& keyCode )
1380 {
1381   xkb_keysym_t sym = XKB_KEY_NoSymbol;
1382   KeyCodeMap foundKeyCode;
1383
1384   sym = xkb_keysym_from_name( keyName.c_str(), XKB_KEYSYM_NO_FLAGS );
1385   if( sym == XKB_KEY_NoSymbol )
1386   {
1387     DALI_LOG_ERROR( "Failed to get keysym in WindowBaseEcoreWl2\n" );
1388     return;
1389   }
1390
1391   foundKeyCode.keySym = sym;
1392   foundKeyCode.isKeyCode = false;
1393   xkb_keymap_key_for_each( mKeyMap, FindKeyCode, &foundKeyCode );
1394   keyCode = static_cast< int32_t >( foundKeyCode.keyCode );
1395 }
1396
1397 Any WindowBaseEcoreWl2::GetNativeWindow()
1398 {
1399   return mEcoreWindow;
1400 }
1401
1402 int WindowBaseEcoreWl2::GetNativeWindowId()
1403 {
1404   return ecore_wl2_window_id_get( mEcoreWindow );
1405 }
1406
1407 EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow( int width, int height )
1408 {
1409   int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
1410   if( totalAngle == 90 || totalAngle == 270 )
1411   {
1412     mEglWindow = wl_egl_window_create( mWlSurface, height, width );
1413   }
1414   else
1415   {
1416     mEglWindow = wl_egl_window_create( mWlSurface, width, height );
1417   }
1418
1419   return static_cast< EGLNativeWindowType >( mEglWindow );
1420 }
1421
1422 void WindowBaseEcoreWl2::DestroyEglWindow()
1423 {
1424   if( mEglWindow != NULL )
1425   {
1426     wl_egl_window_destroy( mEglWindow );
1427     mEglWindow = NULL;
1428   }
1429 }
1430
1431 void WindowBaseEcoreWl2::SetEglWindowRotation( int angle )
1432 {
1433   wl_egl_window_tizen_rotation rotation;
1434
1435   switch( angle )
1436   {
1437     case 0:
1438     {
1439       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0 ;
1440       break;
1441     }
1442     case 90:
1443     {
1444       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_270;
1445       break;
1446     }
1447     case 180:
1448     {
1449       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_180;
1450       break;
1451     }
1452     case 270:
1453     {
1454       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_90;
1455       break;
1456     }
1457     default:
1458     {
1459       rotation = WL_EGL_WINDOW_TIZEN_ROTATION_0 ;
1460       break;
1461     }
1462   }
1463
1464   wl_egl_window_tizen_set_rotation( mEglWindow, rotation );
1465 }
1466
1467 void WindowBaseEcoreWl2::SetEglWindowBufferTransform( int angle )
1468 {
1469   wl_output_transform bufferTransform;
1470
1471   switch( angle )
1472   {
1473     case 0:
1474     {
1475       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1476       break;
1477     }
1478     case 90:
1479     {
1480       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1481       break;
1482     }
1483     case 180:
1484     {
1485       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1486       break;
1487     }
1488     case 270:
1489     {
1490       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1491       break;
1492     }
1493     default:
1494     {
1495       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1496       break;
1497     }
1498   }
1499
1500   wl_egl_window_tizen_set_buffer_transform( mEglWindow, bufferTransform );
1501 }
1502
1503 void WindowBaseEcoreWl2::SetEglWindowTransform( int angle )
1504 {
1505   wl_output_transform windowTransform;
1506
1507   switch( angle )
1508   {
1509     case 0:
1510     {
1511       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1512       break;
1513     }
1514     case 90:
1515     {
1516       windowTransform = WL_OUTPUT_TRANSFORM_90;
1517       break;
1518     }
1519     case 180:
1520     {
1521       windowTransform = WL_OUTPUT_TRANSFORM_180;
1522       break;
1523     }
1524     case 270:
1525     {
1526       windowTransform = WL_OUTPUT_TRANSFORM_270;
1527       break;
1528     }
1529     default:
1530     {
1531       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1532       break;
1533     }
1534   }
1535
1536   wl_egl_window_tizen_set_window_transform( mEglWindow, windowTransform );
1537 }
1538
1539 void WindowBaseEcoreWl2::ResizeEglWindow( PositionSize positionSize )
1540 {
1541   wl_egl_window_resize( mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y );
1542
1543   // Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
1544   if( mMoveResizeSerial != mLastSubmittedMoveResizeSerial )
1545   {
1546     wl_egl_window_tizen_set_window_serial( mEglWindow, mMoveResizeSerial );
1547     mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
1548   }
1549 }
1550
1551 bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
1552 {
1553   // Check capability
1554   wl_egl_window_tizen_capability capability = static_cast< wl_egl_window_tizen_capability >( wl_egl_window_tizen_get_capabilities( mEglWindow ) );
1555   if( capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED )
1556   {
1557     mSupportedPreProtation = true;
1558     return true;
1559   }
1560   mSupportedPreProtation = false;
1561   return false;
1562 }
1563
1564 void WindowBaseEcoreWl2::Move( PositionSize positionSize )
1565 {
1566   mWindowPositionSize = positionSize;
1567   ecore_wl2_window_position_set( mEcoreWindow, positionSize.x, positionSize.y );
1568 }
1569
1570 void WindowBaseEcoreWl2::Resize( PositionSize positionSize )
1571 {
1572   mWindowPositionSize = positionSize;
1573   ecore_wl2_window_geometry_set( mEcoreWindow, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
1574 }
1575
1576 void WindowBaseEcoreWl2::MoveResize( PositionSize positionSize )
1577 {
1578   mWindowPositionSize = positionSize;
1579   ecore_wl2_window_sync_geometry_set( mEcoreWindow, ++mMoveResizeSerial, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
1580 }
1581
1582 void WindowBaseEcoreWl2::SetClass( const std::string& name, const std::string& className )
1583 {
1584   ecore_wl2_window_title_set( mEcoreWindow, name.c_str() );
1585   ecore_wl2_window_class_set( mEcoreWindow, className.c_str() );
1586 }
1587
1588 void WindowBaseEcoreWl2::Raise()
1589 {
1590   // Use ecore_wl2_window_activate to prevent the window shown without rendering
1591   ecore_wl2_window_activate( mEcoreWindow );
1592 }
1593
1594 void WindowBaseEcoreWl2::Lower()
1595 {
1596   ecore_wl2_window_lower( mEcoreWindow );
1597 }
1598
1599 void WindowBaseEcoreWl2::Activate()
1600 {
1601   ecore_wl2_window_activate( mEcoreWindow );
1602 }
1603
1604 void WindowBaseEcoreWl2::SetAvailableAnlges( const std::vector< int >& angles )
1605 {
1606   int rotations[4] = { 0 };
1607   DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::SetAvailableAnlges, angle's count: %d, angles\n", angles.size() );
1608   for( std::size_t i = 0; i < angles.size(); ++i )
1609   {
1610     rotations[i] = static_cast< int >( angles[i] );
1611     DALI_LOG_RELEASE_INFO( "%d ", rotations[i] );
1612   }
1613   ecore_wl2_window_available_rotations_set( mEcoreWindow, rotations, angles.size() );
1614 }
1615
1616 void WindowBaseEcoreWl2::SetPreferredAngle( int angle )
1617 {
1618   DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl2::SetPreferredAngle, angle: %d\n", angle );
1619   ecore_wl2_window_preferred_rotation_set( mEcoreWindow, angle );
1620 }
1621
1622 void WindowBaseEcoreWl2::SetAcceptFocus( bool accept )
1623 {
1624   ecore_wl2_window_focus_skip_set( mEcoreWindow, !accept );
1625 }
1626
1627 void WindowBaseEcoreWl2::Show()
1628 {
1629   if( !mVisible )
1630   {
1631     ecore_wl2_window_geometry_set( mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height );
1632   }
1633   mVisible = true;
1634
1635   ecore_wl2_window_show( mEcoreWindow );
1636 }
1637
1638 void WindowBaseEcoreWl2::Hide()
1639 {
1640   mVisible = false;
1641   ecore_wl2_window_hide( mEcoreWindow );
1642 }
1643
1644 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1645 {
1646   return mSupportedAuxiliaryHints.size();
1647 }
1648
1649 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint( unsigned int index ) const
1650 {
1651   if( index >= GetSupportedAuxiliaryHintCount() )
1652   {
1653     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
1654   }
1655
1656   return mSupportedAuxiliaryHints[index];
1657 }
1658
1659 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint( const std::string& hint, const std::string& value )
1660 {
1661   bool supported = false;
1662
1663   // Check if the hint is suppported
1664   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1665   {
1666     if( *iter == hint )
1667     {
1668       supported = true;
1669       break;
1670     }
1671   }
1672
1673   if( !supported )
1674   {
1675     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1676     return 0;
1677   }
1678
1679   // Check if the hint is already added
1680   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1681   {
1682     if( mAuxiliaryHints[i].first == hint )
1683     {
1684       // Just change the value
1685       mAuxiliaryHints[i].second = value;
1686
1687       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1688
1689       return i + 1;   // id is index + 1
1690     }
1691   }
1692
1693   // Add the hint
1694   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1695
1696   unsigned int id = mAuxiliaryHints.size();
1697
1698   ecore_wl2_window_aux_hint_add( mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1699
1700   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1701
1702   return id;
1703 }
1704
1705 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint( unsigned int id )
1706 {
1707   if( id == 0 || id > mAuxiliaryHints.size() )
1708   {
1709     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1710     return false;
1711   }
1712
1713   mAuxiliaryHints[id - 1].second = std::string();
1714
1715   ecore_wl2_window_aux_hint_del( mEcoreWindow, static_cast< int >( id ) );
1716
1717   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1718
1719   return true;
1720 }
1721
1722 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1723 {
1724   if( id == 0 || id > mAuxiliaryHints.size() )
1725   {
1726     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1727     return false;
1728   }
1729
1730   mAuxiliaryHints[id - 1].second = value;
1731
1732   ecore_wl2_window_aux_hint_change( mEcoreWindow, static_cast< int >( id ), value.c_str() );
1733
1734   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() );
1735
1736   return true;
1737 }
1738
1739 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue( unsigned int id ) const
1740 {
1741   if( id == 0 || id > mAuxiliaryHints.size() )
1742   {
1743     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1744     return std::string();
1745   }
1746
1747   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() );
1748
1749   return mAuxiliaryHints[id - 1].second;
1750 }
1751
1752 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId( const std::string& hint ) const
1753 {
1754   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1755   {
1756     if( mAuxiliaryHints[i].first == hint )
1757     {
1758       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1759       return i + 1;
1760     }
1761   }
1762
1763   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1764
1765   return 0;
1766 }
1767
1768 void WindowBaseEcoreWl2::SetInputRegion( const Rect< int >& inputRegion )
1769 {
1770   ecore_wl2_window_input_region_set( mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1771 }
1772
1773 void WindowBaseEcoreWl2::SetType( Dali::Window::Type type )
1774 {
1775   Ecore_Wl2_Window_Type windowType;
1776
1777   switch( type )
1778   {
1779     case Dali::Window::NORMAL:
1780     {
1781       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1782       break;
1783     }
1784     case Dali::Window::NOTIFICATION:
1785     {
1786       windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
1787       break;
1788     }
1789     case Dali::Window::UTILITY:
1790     {
1791       windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
1792       break;
1793     }
1794     case Dali::Window::DIALOG:
1795     {
1796       windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
1797       break;
1798     }
1799     default:
1800     {
1801       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1802       break;
1803     }
1804   }
1805
1806   ecore_wl2_window_type_set( mEcoreWindow, windowType );
1807 }
1808
1809 bool WindowBaseEcoreWl2::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1810 {
1811   while( !mTizenPolicy )
1812   {
1813     wl_display_dispatch_queue( mDisplay, mEventQueue );
1814   }
1815
1816   int notificationLevel;
1817
1818   switch( level )
1819   {
1820     case Dali::Window::NotificationLevel::NONE:
1821     {
1822       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1823       break;
1824     }
1825     case Dali::Window::NotificationLevel::BASE:
1826     {
1827       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1828       break;
1829     }
1830     case Dali::Window::NotificationLevel::MEDIUM:
1831     {
1832       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1833       break;
1834     }
1835     case Dali::Window::NotificationLevel::HIGH:
1836     {
1837       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1838       break;
1839     }
1840     case Dali::Window::NotificationLevel::TOP:
1841     {
1842       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1843       break;
1844     }
1845     default:
1846     {
1847       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level );
1848       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1849       break;
1850     }
1851   }
1852
1853   mNotificationLevelChangeDone = false;
1854   mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1855
1856   tizen_policy_set_notification_level( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), notificationLevel );
1857
1858   int count = 0;
1859
1860   while( !mNotificationLevelChangeDone && count < 3 )
1861   {
1862     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1863     wl_display_dispatch_queue( mDisplay, mEventQueue );
1864     count++;
1865   }
1866
1867   if( !mNotificationLevelChangeDone )
1868   {
1869     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState );
1870     return false;
1871   }
1872   else if( mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1873   {
1874     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level );
1875     return false;
1876   }
1877
1878   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel );
1879
1880   return true;
1881 }
1882
1883 Dali::Window::NotificationLevel::Type WindowBaseEcoreWl2::GetNotificationLevel() const
1884 {
1885   while( !mTizenPolicy )
1886   {
1887     wl_display_dispatch_queue( mDisplay, mEventQueue );
1888   }
1889
1890   int count = 0;
1891
1892   while( !mNotificationLevelChangeDone && count < 3 )
1893   {
1894     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1895     wl_display_dispatch_queue( mDisplay, mEventQueue );
1896     count++;
1897   }
1898
1899   if( !mNotificationLevelChangeDone )
1900   {
1901     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState );
1902     return Dali::Window::NotificationLevel::NONE;
1903   }
1904
1905   Dali::Window::NotificationLevel::Type level;
1906
1907   switch( mNotificationLevel )
1908   {
1909     case TIZEN_POLICY_LEVEL_NONE:
1910     {
1911       level = Dali::Window::NotificationLevel::NONE;
1912       break;
1913     }
1914     case TIZEN_POLICY_LEVEL_DEFAULT:
1915     {
1916       level = Dali::Window::NotificationLevel::BASE;
1917       break;
1918     }
1919     case TIZEN_POLICY_LEVEL_MEDIUM:
1920     {
1921       level = Dali::Window::NotificationLevel::MEDIUM;
1922       break;
1923     }
1924     case TIZEN_POLICY_LEVEL_HIGH:
1925     {
1926       level = Dali::Window::NotificationLevel::HIGH;
1927       break;
1928     }
1929     case TIZEN_POLICY_LEVEL_TOP:
1930     {
1931       level = Dali::Window::NotificationLevel::TOP;
1932       break;
1933     }
1934     default:
1935     {
1936       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel );
1937       level = Dali::Window::NotificationLevel::NONE;
1938       break;
1939     }
1940   }
1941
1942   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel );
1943
1944   return level;
1945 }
1946
1947 void WindowBaseEcoreWl2::SetOpaqueState( bool opaque )
1948 {
1949   while( !mTizenPolicy )
1950   {
1951     wl_display_dispatch_queue( mDisplay, mEventQueue );
1952   }
1953
1954   tizen_policy_set_opaque_state( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), ( opaque ? 1 : 0 ) );
1955 }
1956
1957 bool WindowBaseEcoreWl2::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1958 {
1959   while( !mTizenPolicy )
1960   {
1961     wl_display_dispatch_queue( mDisplay, mEventQueue );
1962   }
1963
1964   mScreenOffModeChangeDone = false;
1965   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1966
1967   unsigned int mode = 0;
1968
1969   switch( screenOffMode )
1970   {
1971     case Dali::Window::ScreenOffMode::TIMEOUT:
1972     {
1973       mode = 0;
1974       break;
1975     }
1976     case Dali::Window::ScreenOffMode::NEVER:
1977     {
1978       mode = 1;
1979       break;
1980     }
1981   }
1982
1983   tizen_policy_set_window_screen_mode( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), mode );
1984
1985   int count = 0;
1986
1987   while( !mScreenOffModeChangeDone && count < 3 )
1988   {
1989     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1990     wl_display_dispatch_queue( mDisplay, mEventQueue );
1991     count++;
1992   }
1993
1994   if( !mScreenOffModeChangeDone )
1995   {
1996     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState );
1997     return false;
1998   }
1999   else if( mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
2000   {
2001     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
2002     return false;
2003   }
2004
2005   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode );
2006
2007   return true;
2008 }
2009
2010 Dali::Window::ScreenOffMode::Type WindowBaseEcoreWl2::GetScreenOffMode() const
2011 {
2012   while( !mTizenPolicy )
2013   {
2014     wl_display_dispatch_queue( mDisplay, mEventQueue );
2015   }
2016
2017   int count = 0;
2018
2019   while( !mScreenOffModeChangeDone && count < 3 )
2020   {
2021     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2022     wl_display_dispatch_queue( mDisplay, mEventQueue );
2023     count++;
2024   }
2025
2026   if( !mScreenOffModeChangeDone )
2027   {
2028     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState );
2029     return Dali::Window::ScreenOffMode::TIMEOUT;
2030   }
2031
2032   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
2033
2034   switch( mScreenOffMode )
2035   {
2036     case 0:
2037     {
2038       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
2039       break;
2040     }
2041     case 1:
2042     {
2043       screenMode = Dali::Window::ScreenOffMode::NEVER;
2044       break;
2045     }
2046   }
2047
2048   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode );
2049
2050   return screenMode;
2051 }
2052
2053 bool WindowBaseEcoreWl2::SetBrightness( int brightness )
2054 {
2055   while( !mTizenDisplayPolicy )
2056   {
2057     wl_display_dispatch_queue( mDisplay, mEventQueue );
2058   }
2059
2060   mBrightnessChangeDone = false;
2061   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2062
2063   tizen_display_policy_set_window_brightness( mTizenDisplayPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), brightness );
2064
2065   int count = 0;
2066
2067   while( !mBrightnessChangeDone && count < 3 )
2068   {
2069     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2070     wl_display_dispatch_queue( mDisplay, mEventQueue );
2071     count++;
2072   }
2073
2074   if( !mBrightnessChangeDone )
2075   {
2076     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState );
2077     return false;
2078   }
2079   else if( mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
2080   {
2081     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness );
2082     return false;
2083   }
2084
2085   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness );
2086
2087   return true;
2088 }
2089
2090 int WindowBaseEcoreWl2::GetBrightness() const
2091 {
2092   while( !mTizenDisplayPolicy )
2093   {
2094     wl_display_dispatch_queue( mDisplay, mEventQueue );
2095   }
2096
2097   int count = 0;
2098
2099   while( !mBrightnessChangeDone && count < 3 )
2100   {
2101     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2102     wl_display_dispatch_queue( mDisplay, mEventQueue );
2103     count++;
2104   }
2105
2106   if( !mBrightnessChangeDone )
2107   {
2108     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState );
2109     return 0;
2110   }
2111
2112   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness );
2113
2114   return mBrightness;
2115 }
2116
2117 bool WindowBaseEcoreWl2::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
2118 {
2119   Ecore_Wl2_Window_Keygrab_Mode mode;
2120
2121   switch( grabMode )
2122   {
2123     case KeyGrab::TOPMOST:
2124     {
2125       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2126       break;
2127     }
2128     case KeyGrab::SHARED:
2129     {
2130       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2131       break;
2132     }
2133     case KeyGrab::OVERRIDE_EXCLUSIVE:
2134     {
2135       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2136       break;
2137     }
2138     case KeyGrab::EXCLUSIVE:
2139     {
2140       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2141       break;
2142     }
2143     default:
2144     {
2145       return false;
2146     }
2147   }
2148
2149   return ecore_wl2_window_keygrab_set( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0, 0, mode );
2150 }
2151
2152 bool WindowBaseEcoreWl2::UngrabKey( Dali::KEY key )
2153 {
2154   return ecore_wl2_window_keygrab_unset( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0 );
2155 }
2156
2157 bool WindowBaseEcoreWl2::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
2158 {
2159   int keyCount = key.Count();
2160   int keyGrabModeCount = grabMode.Count();
2161
2162   if( keyCount != keyGrabModeCount || keyCount == 0 )
2163   {
2164     return false;
2165   }
2166
2167   eina_init();
2168
2169   Eina_List* keyList = NULL;
2170   Ecore_Wl2_Window_Keygrab_Info* info = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2171
2172   for( int index = 0; index < keyCount; ++index )
2173   {
2174     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2175
2176     switch( grabMode[index] )
2177     {
2178       case KeyGrab::TOPMOST:
2179       {
2180         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2181         break;
2182       }
2183       case KeyGrab::SHARED:
2184       {
2185         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2186         break;
2187       }
2188       case KeyGrab::OVERRIDE_EXCLUSIVE:
2189       {
2190         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2191         break;
2192       }
2193       case KeyGrab::EXCLUSIVE:
2194       {
2195         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2196         break;
2197       }
2198       default:
2199       {
2200         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2201         break;
2202       }
2203     }
2204
2205     keyList = eina_list_append( keyList, &info );
2206   }
2207
2208   Eina_List* grabList = ecore_wl2_window_keygrab_list_set( mEcoreWindow, keyList );
2209
2210   result.Resize( keyCount, true );
2211
2212   Eina_List* l = NULL;
2213   Eina_List* m = NULL;
2214   void* listData = NULL;
2215   void* data = NULL;
2216   if( grabList != NULL )
2217   {
2218     EINA_LIST_FOREACH( grabList, m, data )
2219     {
2220       int index = 0;
2221       EINA_LIST_FOREACH( keyList, l, listData )
2222       {
2223         if( static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key == NULL )
2224         {
2225           DALI_LOG_ERROR( "input key list has null data!" );
2226           break;
2227         }
2228
2229         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key ) == 0 )
2230         {
2231           result[index] = false;
2232         }
2233         ++index;
2234       }
2235     }
2236   }
2237
2238   delete [] info;
2239
2240   eina_list_free( keyList );
2241   eina_list_free( grabList );
2242   eina_shutdown();
2243
2244   return true;
2245 }
2246
2247 bool WindowBaseEcoreWl2::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
2248 {
2249   int keyCount = key.Count();
2250   if( keyCount == 0 )
2251   {
2252     return false;
2253   }
2254
2255   eina_init();
2256
2257   Eina_List* keyList = NULL;
2258   Ecore_Wl2_Window_Keygrab_Info* info = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2259
2260   for( int index = 0; index < keyCount; ++index )
2261   {
2262     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2263     keyList = eina_list_append( keyList, &info );
2264   }
2265
2266   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset( mEcoreWindow, keyList );
2267
2268   result.Resize( keyCount, true );
2269
2270   Eina_List* l = NULL;
2271   Eina_List* m = NULL;
2272   void *listData = NULL;
2273   void *data = NULL;
2274
2275   if( ungrabList != NULL )
2276   {
2277     EINA_LIST_FOREACH( ungrabList, m, data )
2278     {
2279       int index = 0;
2280       EINA_LIST_FOREACH( keyList, l, listData )
2281       {
2282         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key ) == 0 )
2283         {
2284           result[index] = false;
2285         }
2286         ++index;
2287       }
2288     }
2289   }
2290
2291   delete [] info;
2292
2293   eina_list_free( keyList );
2294   eina_list_free( ungrabList );
2295   eina_shutdown();
2296
2297   return true;
2298 }
2299
2300 void WindowBaseEcoreWl2::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
2301 {
2302   // calculate DPI
2303   float xres, yres;
2304
2305   Ecore_Wl2_Output* output = ecore_wl2_window_output_find( mEcoreWindow );
2306
2307   // 1 inch = 25.4 millimeters
2308   xres = ecore_wl2_output_dpi_get( output );
2309   yres = ecore_wl2_output_dpi_get( output );
2310
2311   dpiHorizontal = int( xres + 0.5f );  // rounding
2312   dpiVertical   = int( yres + 0.5f );
2313 }
2314
2315 int WindowBaseEcoreWl2::GetOrientation() const
2316 {
2317   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2318   if( mSupportedPreProtation )
2319   {
2320     orientation = 0;
2321   }
2322   return orientation;
2323 }
2324
2325 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2326 {
2327   int transform = 0;
2328
2329   if( ecore_wl2_window_ignore_output_transform_get( mEcoreWindow ) )
2330   {
2331     transform = 0;
2332   }
2333   else
2334   {
2335     transform = ecore_wl2_output_transform_get( ecore_wl2_window_output_find( mEcoreWindow ) );
2336   }
2337   mScreenRotationAngle = transform * 90;
2338   return mScreenRotationAngle;
2339 }
2340
2341 void WindowBaseEcoreWl2::SetWindowRotationAngle( int degree )
2342 {
2343   mWindowRotationAngle = degree;
2344   ecore_wl2_window_rotation_set( mEcoreWindow, degree );
2345 }
2346
2347 int WindowBaseEcoreWl2::GetWindowRotationAngle()
2348 {
2349   return mWindowRotationAngle;
2350 }
2351
2352 void WindowBaseEcoreWl2::WindowRotationCompleted( int degree, int width, int height )
2353 {
2354   ecore_wl2_window_rotation_change_done_send( mEcoreWindow, degree, width, height );
2355 }
2356
2357 void WindowBaseEcoreWl2::SetTransparency( bool transparent )
2358 {
2359   ecore_wl2_window_alpha_set( mEcoreWindow, transparent );
2360 }
2361
2362 void WindowBaseEcoreWl2::InitializeEcoreElDBus()
2363 {
2364 #ifdef DALI_ELDBUS_AVAILABLE
2365   Eldbus_Object* object;
2366   Eldbus_Proxy* manager;
2367
2368   if( !( mSystemConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SYSTEM ) ) )
2369   {
2370     DALI_LOG_ERROR( "Unable to get system bus\n" );
2371   }
2372
2373   object = eldbus_object_get( mSystemConnection, BUS, PATH );
2374   if( !object )
2375   {
2376     DALI_LOG_ERROR( "Getting object failed\n" );
2377     return;
2378   }
2379
2380   manager = eldbus_proxy_get( object, INTERFACE );
2381   if( !manager )
2382   {
2383     DALI_LOG_ERROR( "Getting proxy failed\n" );
2384     return;
2385   }
2386
2387   if( !eldbus_proxy_signal_handler_add( manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this ) )
2388   {
2389     DALI_LOG_ERROR( "No signal handler returned\n" );
2390   }
2391 #endif
2392 }
2393
2394 void WindowBaseEcoreWl2::CreateWindow( PositionSize positionSize )
2395 {
2396   Ecore_Wl2_Display* display = ecore_wl2_display_connect( NULL );
2397   if( !display )
2398   {
2399     DALI_ASSERT_ALWAYS( 0 && "Failed to get display" );
2400   }
2401
2402   ecore_wl2_display_sync( display );
2403
2404   mEcoreWindow = ecore_wl2_window_new( display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
2405
2406   if ( mEcoreWindow == 0 )
2407   {
2408     DALI_ASSERT_ALWAYS( 0 && "Failed to create Wayland window" );
2409   }
2410
2411   // Set default type
2412   ecore_wl2_window_type_set( mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL );
2413 }
2414
2415 void WindowBaseEcoreWl2::SetParent( WindowBase* parentWinBase )
2416 {
2417   Ecore_Wl2_Window* ecoreParent = NULL;
2418   if( parentWinBase )
2419   {
2420     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>( parentWinBase );
2421     ecoreParent = winBaseEcore2->mEcoreWindow;
2422   }
2423   ecore_wl2_window_parent_set( mEcoreWindow, ecoreParent );
2424 }
2425
2426 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2427 {
2428   return wl_egl_window_tizen_create_commit_sync_fd( mEglWindow );
2429 }
2430
2431 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2432 {
2433   return wl_egl_window_tizen_create_presentation_sync_fd( mEglWindow );
2434 }
2435
2436 } // namespace Adaptor
2437
2438 } // namespace Internal
2439
2440 } // namespace Dali
2441
2442 #pragma GCC diagnostic pop