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 has the original window size
1701     // and he always sends the window rotation event with the swapped size.
1702     // So, to restore, dali should set the reswapped size(original window size) to ecore-wl2 for restoring.
1703     if(mWindowRotationAngle == 0 || mWindowRotationAngle == 180)
1704     {
1705       ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
1706     }
1707     else
1708     {
1709       ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.height, mWindowPositionSize.width);
1710     }
1711   }
1712   mVisible = true;
1713
1714   ecore_wl2_window_show( mEcoreWindow );
1715 }
1716
1717 void WindowBaseEcoreWl2::Hide()
1718 {
1719   mVisible = false;
1720   ecore_wl2_window_hide( mEcoreWindow );
1721 }
1722
1723 unsigned int WindowBaseEcoreWl2::GetSupportedAuxiliaryHintCount() const
1724 {
1725   return mSupportedAuxiliaryHints.size();
1726 }
1727
1728 std::string WindowBaseEcoreWl2::GetSupportedAuxiliaryHint( unsigned int index ) const
1729 {
1730   if( index >= GetSupportedAuxiliaryHintCount() )
1731   {
1732     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
1733   }
1734
1735   return mSupportedAuxiliaryHints[index];
1736 }
1737
1738 unsigned int WindowBaseEcoreWl2::AddAuxiliaryHint( const std::string& hint, const std::string& value )
1739 {
1740   bool supported = false;
1741
1742   // Check if the hint is suppported
1743   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1744   {
1745     if( *iter == hint )
1746     {
1747       supported = true;
1748       break;
1749     }
1750   }
1751
1752   if( !supported )
1753   {
1754     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1755     return 0;
1756   }
1757
1758   // Check if the hint is already added
1759   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1760   {
1761     if( mAuxiliaryHints[i].first == hint )
1762     {
1763       // Just change the value
1764       mAuxiliaryHints[i].second = value;
1765
1766       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1767
1768       return i + 1;   // id is index + 1
1769     }
1770   }
1771
1772   // Add the hint
1773   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1774
1775   unsigned int id = mAuxiliaryHints.size();
1776
1777   ecore_wl2_window_aux_hint_add( mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1778
1779   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1780
1781   return id;
1782 }
1783
1784 bool WindowBaseEcoreWl2::RemoveAuxiliaryHint( unsigned int id )
1785 {
1786   if( id == 0 || id > mAuxiliaryHints.size() )
1787   {
1788     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1789     return false;
1790   }
1791
1792   mAuxiliaryHints[id - 1].second = std::string();
1793
1794   ecore_wl2_window_aux_hint_del( mEcoreWindow, static_cast< int >( id ) );
1795
1796   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1797
1798   return true;
1799 }
1800
1801 bool WindowBaseEcoreWl2::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1802 {
1803   if( id == 0 || id > mAuxiliaryHints.size() )
1804   {
1805     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1806     return false;
1807   }
1808
1809   mAuxiliaryHints[id - 1].second = value;
1810
1811   ecore_wl2_window_aux_hint_change( mEcoreWindow, static_cast< int >( id ), value.c_str() );
1812
1813   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() );
1814
1815   return true;
1816 }
1817
1818 std::string WindowBaseEcoreWl2::GetAuxiliaryHintValue( unsigned int id ) const
1819 {
1820   if( id == 0 || id > mAuxiliaryHints.size() )
1821   {
1822     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1823     return std::string();
1824   }
1825
1826   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() );
1827
1828   return mAuxiliaryHints[id - 1].second;
1829 }
1830
1831 unsigned int WindowBaseEcoreWl2::GetAuxiliaryHintId( const std::string& hint ) const
1832 {
1833   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1834   {
1835     if( mAuxiliaryHints[i].first == hint )
1836     {
1837       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1838       return i + 1;
1839     }
1840   }
1841
1842   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1843
1844   return 0;
1845 }
1846
1847 void WindowBaseEcoreWl2::SetInputRegion( const Rect< int >& inputRegion )
1848 {
1849   ecore_wl2_window_input_region_set( mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1850 }
1851
1852 void WindowBaseEcoreWl2::SetType( Dali::Window::Type type )
1853 {
1854   Ecore_Wl2_Window_Type windowType;
1855
1856   switch( type )
1857   {
1858     case Dali::Window::NORMAL:
1859     {
1860       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1861       break;
1862     }
1863     case Dali::Window::NOTIFICATION:
1864     {
1865       windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
1866       break;
1867     }
1868     case Dali::Window::UTILITY:
1869     {
1870       windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
1871       break;
1872     }
1873     case Dali::Window::DIALOG:
1874     {
1875       windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
1876       break;
1877     }
1878     default:
1879     {
1880       windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
1881       break;
1882     }
1883   }
1884
1885   ecore_wl2_window_type_set( mEcoreWindow, windowType );
1886 }
1887
1888 bool WindowBaseEcoreWl2::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1889 {
1890   while( !mTizenPolicy )
1891   {
1892     wl_display_dispatch_queue( mDisplay, mEventQueue );
1893   }
1894
1895   int notificationLevel;
1896
1897   switch( level )
1898   {
1899     case Dali::Window::NotificationLevel::NONE:
1900     {
1901       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1902       break;
1903     }
1904     case Dali::Window::NotificationLevel::BASE:
1905     {
1906       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1907       break;
1908     }
1909     case Dali::Window::NotificationLevel::MEDIUM:
1910     {
1911       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1912       break;
1913     }
1914     case Dali::Window::NotificationLevel::HIGH:
1915     {
1916       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1917       break;
1918     }
1919     case Dali::Window::NotificationLevel::TOP:
1920     {
1921       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1922       break;
1923     }
1924     default:
1925     {
1926       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level );
1927       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1928       break;
1929     }
1930   }
1931
1932   mNotificationLevelChangeDone = false;
1933   mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1934
1935   tizen_policy_set_notification_level( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), notificationLevel );
1936
1937   int count = 0;
1938
1939   while( !mNotificationLevelChangeDone && count < 3 )
1940   {
1941     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1942     wl_display_dispatch_queue( mDisplay, mEventQueue );
1943     count++;
1944   }
1945
1946   if( !mNotificationLevelChangeDone )
1947   {
1948     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState );
1949     return false;
1950   }
1951   else if( mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1952   {
1953     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Permission denied! [%d]\n", level );
1954     return false;
1955   }
1956
1957   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel );
1958
1959   return true;
1960 }
1961
1962 Dali::Window::NotificationLevel::Type WindowBaseEcoreWl2::GetNotificationLevel() const
1963 {
1964   while( !mTizenPolicy )
1965   {
1966     wl_display_dispatch_queue( mDisplay, mEventQueue );
1967   }
1968
1969   int count = 0;
1970
1971   while( !mNotificationLevelChangeDone && count < 3 )
1972   {
1973     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
1974     wl_display_dispatch_queue( mDisplay, mEventQueue );
1975     count++;
1976   }
1977
1978   if( !mNotificationLevelChangeDone )
1979   {
1980     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState );
1981     return Dali::Window::NotificationLevel::NONE;
1982   }
1983
1984   Dali::Window::NotificationLevel::Type level;
1985
1986   switch( mNotificationLevel )
1987   {
1988     case TIZEN_POLICY_LEVEL_NONE:
1989     {
1990       level = Dali::Window::NotificationLevel::NONE;
1991       break;
1992     }
1993     case TIZEN_POLICY_LEVEL_DEFAULT:
1994     {
1995       level = Dali::Window::NotificationLevel::BASE;
1996       break;
1997     }
1998     case TIZEN_POLICY_LEVEL_MEDIUM:
1999     {
2000       level = Dali::Window::NotificationLevel::MEDIUM;
2001       break;
2002     }
2003     case TIZEN_POLICY_LEVEL_HIGH:
2004     {
2005       level = Dali::Window::NotificationLevel::HIGH;
2006       break;
2007     }
2008     case TIZEN_POLICY_LEVEL_TOP:
2009     {
2010       level = Dali::Window::NotificationLevel::TOP;
2011       break;
2012     }
2013     default:
2014     {
2015       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel );
2016       level = Dali::Window::NotificationLevel::NONE;
2017       break;
2018     }
2019   }
2020
2021   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetNotificationLevel: level [%d]\n", mNotificationLevel );
2022
2023   return level;
2024 }
2025
2026 void WindowBaseEcoreWl2::SetOpaqueState( bool opaque )
2027 {
2028   while( !mTizenPolicy )
2029   {
2030     wl_display_dispatch_queue( mDisplay, mEventQueue );
2031   }
2032
2033   tizen_policy_set_opaque_state( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), ( opaque ? 1 : 0 ) );
2034 }
2035
2036 bool WindowBaseEcoreWl2::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
2037 {
2038   while( !mTizenPolicy )
2039   {
2040     wl_display_dispatch_queue( mDisplay, mEventQueue );
2041   }
2042
2043   mScreenOffModeChangeDone = false;
2044   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2045
2046   unsigned int mode = 0;
2047
2048   switch( screenOffMode )
2049   {
2050     case Dali::Window::ScreenOffMode::TIMEOUT:
2051     {
2052       mode = 0;
2053       break;
2054     }
2055     case Dali::Window::ScreenOffMode::NEVER:
2056     {
2057       mode = 1;
2058       break;
2059     }
2060   }
2061
2062   tizen_policy_set_window_screen_mode( mTizenPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), mode );
2063
2064   int count = 0;
2065
2066   while( !mScreenOffModeChangeDone && count < 3 )
2067   {
2068     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2069     wl_display_dispatch_queue( mDisplay, mEventQueue );
2070     count++;
2071   }
2072
2073   if( !mScreenOffModeChangeDone )
2074   {
2075     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState );
2076     return false;
2077   }
2078   else if( mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
2079   {
2080     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
2081     return false;
2082   }
2083
2084   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode );
2085
2086   return true;
2087 }
2088
2089 Dali::Window::ScreenOffMode::Type WindowBaseEcoreWl2::GetScreenOffMode() const
2090 {
2091   while( !mTizenPolicy )
2092   {
2093     wl_display_dispatch_queue( mDisplay, mEventQueue );
2094   }
2095
2096   int count = 0;
2097
2098   while( !mScreenOffModeChangeDone && count < 3 )
2099   {
2100     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2101     wl_display_dispatch_queue( mDisplay, mEventQueue );
2102     count++;
2103   }
2104
2105   if( !mScreenOffModeChangeDone )
2106   {
2107     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState );
2108     return Dali::Window::ScreenOffMode::TIMEOUT;
2109   }
2110
2111   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
2112
2113   switch( mScreenOffMode )
2114   {
2115     case 0:
2116     {
2117       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
2118       break;
2119     }
2120     case 1:
2121     {
2122       screenMode = Dali::Window::ScreenOffMode::NEVER;
2123       break;
2124     }
2125   }
2126
2127   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode );
2128
2129   return screenMode;
2130 }
2131
2132 bool WindowBaseEcoreWl2::SetBrightness( int brightness )
2133 {
2134   while( !mTizenDisplayPolicy )
2135   {
2136     wl_display_dispatch_queue( mDisplay, mEventQueue );
2137   }
2138
2139   mBrightnessChangeDone = false;
2140   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
2141
2142   tizen_display_policy_set_window_brightness( mTizenDisplayPolicy, ecore_wl2_window_surface_get( mEcoreWindow ), brightness );
2143
2144   int count = 0;
2145
2146   while( !mBrightnessChangeDone && count < 3 )
2147   {
2148     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2149     wl_display_dispatch_queue( mDisplay, mEventQueue );
2150     count++;
2151   }
2152
2153   if( !mBrightnessChangeDone )
2154   {
2155     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState );
2156     return false;
2157   }
2158   else if( mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
2159   {
2160     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Permission denied! [%d]\n", brightness );
2161     return false;
2162   }
2163
2164   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetBrightness: Brightness is changed [%d]\n", mBrightness );
2165
2166   return true;
2167 }
2168
2169 int WindowBaseEcoreWl2::GetBrightness() const
2170 {
2171   while( !mTizenDisplayPolicy )
2172   {
2173     wl_display_dispatch_queue( mDisplay, mEventQueue );
2174   }
2175
2176   int count = 0;
2177
2178   while( !mBrightnessChangeDone && count < 3 )
2179   {
2180     ecore_wl2_display_flush( ecore_wl2_connected_display_get( NULL ) );
2181     wl_display_dispatch_queue( mDisplay, mEventQueue );
2182     count++;
2183   }
2184
2185   if( !mBrightnessChangeDone )
2186   {
2187     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Error! [%d]\n", mBrightnessChangeState );
2188     return 0;
2189   }
2190
2191   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::GetBrightness: Brightness [%d]\n", mBrightness );
2192
2193   return mBrightness;
2194 }
2195
2196 bool WindowBaseEcoreWl2::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
2197 {
2198   Ecore_Wl2_Window_Keygrab_Mode mode;
2199
2200   switch( grabMode )
2201   {
2202     case KeyGrab::TOPMOST:
2203     {
2204       mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2205       break;
2206     }
2207     case KeyGrab::SHARED:
2208     {
2209       mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2210       break;
2211     }
2212     case KeyGrab::OVERRIDE_EXCLUSIVE:
2213     {
2214       mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2215       break;
2216     }
2217     case KeyGrab::EXCLUSIVE:
2218     {
2219       mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2220       break;
2221     }
2222     default:
2223     {
2224       return false;
2225     }
2226   }
2227
2228   return ecore_wl2_window_keygrab_set( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0, 0, mode );
2229 }
2230
2231 bool WindowBaseEcoreWl2::UngrabKey( Dali::KEY key )
2232 {
2233   return ecore_wl2_window_keygrab_unset( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0 );
2234 }
2235
2236 bool WindowBaseEcoreWl2::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
2237 {
2238   int keyCount = key.Count();
2239   int keyGrabModeCount = grabMode.Count();
2240
2241   if( keyCount != keyGrabModeCount || keyCount == 0 )
2242   {
2243     return false;
2244   }
2245
2246   eina_init();
2247
2248   Eina_List* keyList = NULL;
2249   Ecore_Wl2_Window_Keygrab_Info* info = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2250
2251   for( int index = 0; index < keyCount; ++index )
2252   {
2253     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2254
2255     switch( grabMode[index] )
2256     {
2257       case KeyGrab::TOPMOST:
2258       {
2259         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
2260         break;
2261       }
2262       case KeyGrab::SHARED:
2263       {
2264         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
2265         break;
2266       }
2267       case KeyGrab::OVERRIDE_EXCLUSIVE:
2268       {
2269         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
2270         break;
2271       }
2272       case KeyGrab::EXCLUSIVE:
2273       {
2274         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
2275         break;
2276       }
2277       default:
2278       {
2279         info[index].mode = ECORE_WL2_WINDOW_KEYGRAB_UNKNOWN;
2280         break;
2281       }
2282     }
2283
2284     keyList = eina_list_append( keyList, &info );
2285   }
2286
2287   Eina_List* grabList = ecore_wl2_window_keygrab_list_set( mEcoreWindow, keyList );
2288
2289   result.Resize( keyCount, true );
2290
2291   Eina_List* l = NULL;
2292   Eina_List* m = NULL;
2293   void* listData = NULL;
2294   void* data = NULL;
2295   if( grabList != NULL )
2296   {
2297     EINA_LIST_FOREACH( grabList, m, data )
2298     {
2299       int index = 0;
2300       EINA_LIST_FOREACH( keyList, l, listData )
2301       {
2302         if( static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key == NULL )
2303         {
2304           DALI_LOG_ERROR( "input key list has null data!" );
2305           break;
2306         }
2307
2308         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key ) == 0 )
2309         {
2310           result[index] = false;
2311         }
2312         ++index;
2313       }
2314     }
2315   }
2316
2317   delete [] info;
2318
2319   eina_list_free( keyList );
2320   eina_list_free( grabList );
2321   eina_shutdown();
2322
2323   return true;
2324 }
2325
2326 bool WindowBaseEcoreWl2::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
2327 {
2328   int keyCount = key.Count();
2329   if( keyCount == 0 )
2330   {
2331     return false;
2332   }
2333
2334   eina_init();
2335
2336   Eina_List* keyList = NULL;
2337   Ecore_Wl2_Window_Keygrab_Info* info = new Ecore_Wl2_Window_Keygrab_Info[keyCount];
2338
2339   for( int index = 0; index < keyCount; ++index )
2340   {
2341     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2342     keyList = eina_list_append( keyList, &info );
2343   }
2344
2345   Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset( mEcoreWindow, keyList );
2346
2347   result.Resize( keyCount, true );
2348
2349   Eina_List* l = NULL;
2350   Eina_List* m = NULL;
2351   void *listData = NULL;
2352   void *data = NULL;
2353
2354   if( ungrabList != NULL )
2355   {
2356     EINA_LIST_FOREACH( ungrabList, m, data )
2357     {
2358       int index = 0;
2359       EINA_LIST_FOREACH( keyList, l, listData )
2360       {
2361         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl2_Window_Keygrab_Info* >( listData )->key ) == 0 )
2362         {
2363           result[index] = false;
2364         }
2365         ++index;
2366       }
2367     }
2368   }
2369
2370   delete [] info;
2371
2372   eina_list_free( keyList );
2373   eina_list_free( ungrabList );
2374   eina_shutdown();
2375
2376   return true;
2377 }
2378
2379 void WindowBaseEcoreWl2::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
2380 {
2381   // calculate DPI
2382   float xres, yres;
2383
2384   Ecore_Wl2_Output* output = ecore_wl2_window_output_find( mEcoreWindow );
2385
2386   // 1 inch = 25.4 millimeters
2387   xres = ecore_wl2_output_dpi_get( output );
2388   yres = ecore_wl2_output_dpi_get( output );
2389
2390   dpiHorizontal = int( xres + 0.5f );  // rounding
2391   dpiVertical   = int( yres + 0.5f );
2392 }
2393
2394 int WindowBaseEcoreWl2::GetOrientation() const
2395 {
2396   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2397   if( mSupportedPreProtation )
2398   {
2399     orientation = 0;
2400   }
2401   return orientation;
2402 }
2403
2404 int WindowBaseEcoreWl2::GetScreenRotationAngle()
2405 {
2406   int transform = 0;
2407
2408   if( ecore_wl2_window_ignore_output_transform_get( mEcoreWindow ) )
2409   {
2410     transform = 0;
2411   }
2412   else
2413   {
2414     transform = ecore_wl2_output_transform_get( ecore_wl2_window_output_find( mEcoreWindow ) );
2415   }
2416   mScreenRotationAngle = transform * 90;
2417   return mScreenRotationAngle;
2418 }
2419
2420 void WindowBaseEcoreWl2::SetWindowRotationAngle( int degree )
2421 {
2422   mWindowRotationAngle = degree;
2423   ecore_wl2_window_rotation_set( mEcoreWindow, degree );
2424 }
2425
2426 int WindowBaseEcoreWl2::GetWindowRotationAngle()
2427 {
2428   return mWindowRotationAngle;
2429 }
2430
2431 void WindowBaseEcoreWl2::WindowRotationCompleted( int degree, int width, int height )
2432 {
2433   ecore_wl2_window_rotation_change_done_send( mEcoreWindow, degree, width, height );
2434 }
2435
2436 void WindowBaseEcoreWl2::SetTransparency( bool transparent )
2437 {
2438   ecore_wl2_window_alpha_set( mEcoreWindow, transparent );
2439 }
2440
2441 void WindowBaseEcoreWl2::InitializeEcoreElDBus()
2442 {
2443 #ifdef DALI_ELDBUS_AVAILABLE
2444   Eldbus_Object* object;
2445   Eldbus_Proxy* manager;
2446
2447   if( !( mSystemConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SYSTEM ) ) )
2448   {
2449     DALI_LOG_ERROR( "Unable to get system bus\n" );
2450   }
2451
2452   object = eldbus_object_get( mSystemConnection, BUS, PATH );
2453   if( !object )
2454   {
2455     DALI_LOG_ERROR( "Getting object failed\n" );
2456     return;
2457   }
2458
2459   manager = eldbus_proxy_get( object, INTERFACE );
2460   if( !manager )
2461   {
2462     DALI_LOG_ERROR( "Getting proxy failed\n" );
2463     return;
2464   }
2465
2466   // Save dbus proxy on init.
2467   mAccessibilityInfo.proxy = manager;
2468
2469   if( !eldbus_proxy_signal_handler_add( manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this ) )
2470   {
2471     DALI_LOG_ERROR( "No signal handler returned\n" );
2472   }
2473
2474   if( !eldbus_proxy_signal_handler_add( manager, "QuickpanelChanged", EcoreElDBusAccessibilityQuickpanelChanged, this ) )
2475   {
2476     DALI_LOG_ERROR( "No signal handler returned for QuickpanelChanged signal\n" );
2477   }
2478 #endif
2479 }
2480
2481 void WindowBaseEcoreWl2::CreateWindow( PositionSize positionSize )
2482 {
2483   Ecore_Wl2_Display* display = ecore_wl2_display_connect( NULL );
2484   if( !display )
2485   {
2486     DALI_ASSERT_ALWAYS( 0 && "Failed to get display" );
2487   }
2488
2489   ecore_wl2_display_sync( display );
2490
2491   mEcoreWindow = ecore_wl2_window_new( display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height );
2492
2493   if ( mEcoreWindow == 0 )
2494   {
2495     DALI_ASSERT_ALWAYS( 0 && "Failed to create Wayland window" );
2496   }
2497
2498   // Set default type
2499   ecore_wl2_window_type_set( mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL );
2500 }
2501
2502 void WindowBaseEcoreWl2::SetParent( WindowBase* parentWinBase )
2503 {
2504   Ecore_Wl2_Window* ecoreParent = NULL;
2505   if( parentWinBase )
2506   {
2507     WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>( parentWinBase );
2508     ecoreParent = winBaseEcore2->mEcoreWindow;
2509   }
2510   ecore_wl2_window_parent_set( mEcoreWindow, ecoreParent );
2511 }
2512
2513 int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
2514 {
2515   return wl_egl_window_tizen_create_commit_sync_fd( mEglWindow );
2516 }
2517
2518 int WindowBaseEcoreWl2::CreateFramePresentedSyncFence()
2519 {
2520   return wl_egl_window_tizen_create_presentation_sync_fd( mEglWindow );
2521 }
2522
2523 } // namespace Adaptor
2524
2525 } // namespace Internal
2526
2527 } // namespace Dali
2528
2529 #pragma GCC diagnostic pop