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