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