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