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