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   mWindowRotationAngle( 0 ),
 590   mScreenRotationAngle( 0 ),
 591   mSupportedPreProtation( 0 )
 592 #ifdef DALI_ELDBUS_AVAILABLE
 593   , mSystemConnection( NULL )
 594 #endif
 595 {
 596   Initialize( positionSize, surface, isTransparent );
 597 }
 598
 599 WindowBaseEcoreWl::~WindowBaseEcoreWl()
 600 {
 601 #ifdef DALI_ELDBUS_AVAILABLE
 602     // Close down ElDBus connections.
 603     if( mSystemConnection )
 604     {
 605       eldbus_connection_unref( mSystemConnection );
 606     }
 607 #endif // DALI_ELDBUS_AVAILABLE
 608
 609   vconf_ignore_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged );
 610   vconf_ignore_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged );
 611
 612   for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter )
 613   {
 614     ecore_event_handler_del( *iter );
 615   }
 616   mEcoreEventHandler.Clear();
 617
 618   if( mEventQueue )
 619   {
 620     wl_event_queue_destroy( mEventQueue );
 621   }
 622
 623   mSupportedAuxiliaryHints.clear();
 624   mAuxiliaryHints.clear();
 625
 626   if( mEglWindow != NULL )
 627   {
 628     wl_egl_window_destroy( mEglWindow );
 629     mEglWindow = NULL;
 630   }
 631
 632   if( mOwnSurface )
 633   {
 634     ecore_wl_window_free( mEcoreWindow );
 635
 636     WindowSystem::Shutdown();
 637   }
 638 }
 639
 640 void WindowBaseEcoreWl::Initialize( PositionSize positionSize, Any surface, bool isTransparent )
 641 {
 642   if( surface.Empty() == false )
 643   {
 644     // check we have a valid type
 645     DALI_ASSERT_ALWAYS( ( surface.GetType() == typeid (Ecore_Wl_Window *) ) && "Surface type is invalid" );
 646
 647     mEcoreWindow = AnyCast< Ecore_Wl_Window* >( surface );
 648   }
 649   else
 650   {
 651     // we own the surface about to created
 652     WindowSystem::Initialize();
 653
 654     mOwnSurface = true;
 655     CreateWindow( positionSize );
 656   }
 657
 658   mWlSurface = ecore_wl_window_surface_create( mEcoreWindow );
 659
 660   SetTransparency( isTransparent );
 661
 662   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) );
 663   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN,                    EcoreEventWindowFocusIn,             this ) );
 664   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT,                   EcoreEventWindowFocusOut,            this ) );
 665   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_OUTPUT_TRANSFORM,            EcoreEventOutputTransform,           this ) );
 666   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM,     EcoreEventIgnoreOutputTransform,     this ) );
 667
 668   // Register Rotate event
 669   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ROTATE,               EcoreEventRotate,                    this ) );
 670
 671   // Register Touch events
 672   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,              EcoreEventMouseButtonDown,           this ) );
 673   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,                EcoreEventMouseButtonUp,             this ) );
 674   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE,                     EcoreEventMouseButtonMove,           this ) );
 675   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_CANCEL,            EcoreEventMouseButtonCancel,         this ) );
 676
 677   // Register Mouse wheel events
 678   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL,                    EcoreEventMouseWheel,                this ) );
 679
 680   // Register Detent event
 681   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_DETENT_ROTATE,                  EcoreEventDetentRotation,            this ) );
 682
 683   // Register Key events
 684   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN,                       EcoreEventKeyDown,                   this ) );
 685   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_EVENT_KEY_UP,                         EcoreEventKeyUp,                     this ) );
 686
 687   // Register Selection event - clipboard selection
 688   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_DATA_SOURCE_SEND,            EcoreEventDataSend,                  this ) );
 689   mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_SELECTION_DATA_READY,        EcoreEventDataReceive,               this ) );
 690
 691   // Register Vconf notify - font name and size
 692   vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this );
 693   vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this );
 694
 695   InitializeEcoreElDBus();
 696
 697   mDisplay = ecore_wl_display_get();
 698
 699   if( mDisplay )
 700   {
 701     wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) );
 702     if( displayWrapper )
 703     {
 704       mEventQueue = wl_display_create_queue( mDisplay );
 705       if( mEventQueue )
 706       {
 707         wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue );
 708
 709         wl_registry* registry = wl_display_get_registry( displayWrapper );
 710         wl_registry_add_listener( registry, &registryListener, this );
 711       }
 712
 713       wl_proxy_wrapper_destroy( displayWrapper );
 714     }
 715   }
 716
 717   // get auxiliary hint
 718   Eina_List* hints = ecore_wl_window_aux_hints_supported_get( mEcoreWindow );
 719   if( hints )
 720   {
 721     Eina_List* l = NULL;
 722     char* hint = NULL;
 723
 724     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) ) ) )
 725     {
 726       mSupportedAuxiliaryHints.push_back( hint );
 727
 728       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::Initialize: %s\n", hint );
 729     }
 730   }
 731 }
 732
 733 Eina_Bool WindowBaseEcoreWl::OnIconifyStateChanged( void* data, int type, void* event )
 734 {
 735   Ecore_Wl_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl_Event_Window_Iconify_State_Change* >( event ) );
 736   Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
 737
 738   if( iconifyChangedEvent->win == static_cast< unsigned int>( ecore_wl_window_id_get( mEcoreWindow ) ) )
 739   {
 740     if( iconifyChangedEvent->iconified == EINA_TRUE )
 741     {
 742       mIconifyChangedSignal.Emit( true );
 743     }
 744     else
 745     {
 746       mIconifyChangedSignal.Emit( false );
 747     }
 748     handled = ECORE_CALLBACK_DONE;
 749   }
 750
 751   return handled;
 752 }
 753
 754 Eina_Bool WindowBaseEcoreWl::OnFocusIn( void* data, int type, void* event )
 755 {
 756   Ecore_Wl_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl_Event_Focus_In* >( event ) );
 757
 758   if( focusInEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 759   {
 760     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
 761
 762     mFocusChangedSignal.Emit( true );
 763   }
 764
 765   return ECORE_CALLBACK_PASS_ON;
 766 }
 767
 768 Eina_Bool WindowBaseEcoreWl::OnFocusOut( void* data, int type, void* event )
 769 {
 770   Ecore_Wl_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl_Event_Focus_Out* >( event ) );
 771
 772   if( focusOutEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 773   {
 774     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
 775
 776     mFocusChangedSignal.Emit( false );
 777   }
 778
 779   return ECORE_CALLBACK_PASS_ON;
 780 }
 781
 782 Eina_Bool WindowBaseEcoreWl::OnOutputTransform( void* data, int type, void* event )
 783 {
 784   Ecore_Wl_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl_Event_Output_Transform* >( event ) );
 785
 786   if( transformEvent->output == ecore_wl_window_output_find( mEcoreWindow ) )
 787   {
 788     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow );
 789
 790     mOutputTransformedSignal.Emit();
 791   }
 792
 793   return ECORE_CALLBACK_PASS_ON;
 794 }
 795
 796 Eina_Bool WindowBaseEcoreWl::OnIgnoreOutputTransform( void* data, int type, void* event )
 797 {
 798   Ecore_Wl_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl_Event_Ignore_Output_Transform* >( event ) );
 799
 800   if( ignoreTransformEvent->win == mEcoreWindow )
 801   {
 802     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow );
 803
 804     mOutputTransformedSignal.Emit();
 805   }
 806
 807   return ECORE_CALLBACK_PASS_ON;
 808 }
 809
 810 void WindowBaseEcoreWl::OnRotation( void* data, int type, void* event )
 811 {
 812   Ecore_Wl_Event_Window_Rotate* ev( static_cast< Ecore_Wl_Event_Window_Rotate* >( event ) );
 813
 814   if( ev->win == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 815   {
 816     DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h );
 817
 818     RotationEvent rotationEvent;
 819     rotationEvent.angle = ev->angle;
 820     rotationEvent.winResize = 0;
 821
 822     if( ev->angle == 0 || ev->angle == 180 )
 823     {
 824       rotationEvent.width = ev->w;
 825       rotationEvent.height = ev->h;
 826     }
 827     else
 828     {
 829       rotationEvent.width = ev->h;
 830       rotationEvent.height = ev->w;
 831     }
 832
 833     mRotationSignal.Emit( rotationEvent );
 834   }
 835 }
 836
 837 void WindowBaseEcoreWl::OnMouseButtonDown( void* data, int type, void* event )
 838 {
 839   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 840
 841   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 842   {
 843     PointState::Type state ( PointState::DOWN );
 844
 845     // Check if the buttons field is set and ensure it's the primary touch button.
 846     // If this event was triggered by buttons other than the primary button (used for touch), then
 847     // just send an interrupted event to Core.
 848     if( touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID ) )
 849     {
 850       state = PointState::INTERRUPTED;
 851     }
 852
 853     Device::Class::Type deviceClass;
 854     Device::Subclass::Type deviceSubclass;
 855
 856     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 857     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 858
 859     Integration::Point point;
 860     point.SetDeviceId( touchEvent->multi.device );
 861     point.SetState( state );
 862     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
 863     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
 864     point.SetPressure( touchEvent->multi.pressure );
 865     point.SetAngle( Degree( touchEvent->multi.angle ) );
 866     point.SetDeviceClass( deviceClass );
 867     point.SetDeviceSubclass( deviceSubclass );
 868
 869     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 870   }
 871 }
 872
 873 void WindowBaseEcoreWl::OnMouseButtonUp( void* data, int type, void* event )
 874 {
 875   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 876
 877   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 878   {
 879     Device::Class::Type deviceClass;
 880     Device::Subclass::Type deviceSubclass;
 881
 882     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 883     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 884
 885     Integration::Point point;
 886     point.SetDeviceId( touchEvent->multi.device );
 887     point.SetState( PointState::UP );
 888     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
 889     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
 890     point.SetPressure( touchEvent->multi.pressure );
 891     point.SetAngle( Degree( touchEvent->multi.angle ) );
 892     point.SetDeviceClass( deviceClass );
 893     point.SetDeviceSubclass( deviceSubclass );
 894
 895     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 896   }
 897 }
 898
 899 void WindowBaseEcoreWl::OnMouseButtonMove( void* data, int type, void* event )
 900 {
 901   Ecore_Event_Mouse_Move* touchEvent = static_cast< Ecore_Event_Mouse_Move* >( event );
 902
 903   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 904   {
 905     Device::Class::Type deviceClass;
 906     Device::Subclass::Type deviceSubclass;
 907
 908     GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
 909     GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
 910
 911     Integration::Point point;
 912     point.SetDeviceId( touchEvent->multi.device );
 913     point.SetState( PointState::MOTION );
 914     point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
 915     point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) );
 916     point.SetPressure( touchEvent->multi.pressure );
 917     point.SetAngle( Degree( touchEvent->multi.angle ) );
 918     point.SetDeviceClass( deviceClass );
 919     point.SetDeviceSubclass( deviceSubclass );
 920
 921     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 922   }
 923 }
 924
 925 void WindowBaseEcoreWl::OnMouseButtonCancel( void* data, int type, void* event )
 926 {
 927   Ecore_Event_Mouse_Button* touchEvent = static_cast< Ecore_Event_Mouse_Button* >( event );
 928
 929   if( touchEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 930   {
 931     Integration::Point point;
 932     point.SetDeviceId( touchEvent->multi.device );
 933     point.SetState( PointState::INTERRUPTED );
 934     point.SetScreenPosition( Vector2( 0.0f, 0.0f ) );
 935
 936     mTouchEventSignal.Emit( point, touchEvent->timestamp );
 937
 938     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnMouseButtonCancel\n" );
 939   }
 940 }
 941
 942 void WindowBaseEcoreWl::OnMouseWheel( void* data, int type, void* event )
 943 {
 944   Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast< Ecore_Event_Mouse_Wheel* >( event );
 945
 946   if( mouseWheelEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 947   {
 948     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 );
 949
 950     Integration::WheelEvent wheelEvent( Integration::WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2( mouseWheelEvent->x, mouseWheelEvent->y ), mouseWheelEvent->z, mouseWheelEvent->timestamp );
 951
 952     mWheelEventSignal.Emit( wheelEvent );
 953   }
 954 }
 955
 956 void WindowBaseEcoreWl::OnDetentRotation( void* data, int type, void* event )
 957 {
 958   Ecore_Event_Detent_Rotate* detentEvent = static_cast< Ecore_Event_Detent_Rotate* >( event );
 959
 960   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::OnDetentRotation\n" );
 961
 962   int direction = ( detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE ) ? 1 : -1;
 963   int timeStamp = detentEvent->timestamp;
 964
 965   Integration::WheelEvent wheelEvent( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0, Vector2( 0.0f, 0.0f ), direction, timeStamp );
 966
 967   mWheelEventSignal.Emit( wheelEvent );
 968 }
 969
 970 void WindowBaseEcoreWl::OnKeyDown( void* data, int type, void* event )
 971 {
 972   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
 973
 974   if( keyEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
 975   {
 976     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyDown\n" );
 977
 978     std::string keyName( keyEvent->keyname );
 979     std::string logicalKey( "" );
 980     std::string keyString( "" );
 981     std::string compose( "" );
 982
 983     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
 984     if( keyEvent->compose )
 985     {
 986       compose = keyEvent->compose;
 987     }
 988
 989     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
 990     if( keyEvent->key )
 991     {
 992       logicalKey = keyEvent->key;
 993     }
 994
 995     int keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
 996     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
 997     int modifier( keyEvent->modifiers );
 998     unsigned long time = keyEvent->timestamp;
 999     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1000     {
1001       keyCode = atoi( keyEvent->keyname + 8 );
1002     }
1003
1004     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1005     if( keyEvent->string )
1006     {
1007       keyString = keyEvent->string;
1008     }
1009
1010     std::string deviceName;
1011     Device::Class::Type deviceClass;
1012     Device::Subclass::Type deviceSubclass;
1013
1014     GetDeviceName( keyEvent, deviceName );
1015     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1016     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1017
1018     Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass );
1019
1020      mKeyEventSignal.Emit( keyEvent );
1021   }
1022 }
1023
1024 void WindowBaseEcoreWl::OnKeyUp( void* data, int type, void* event )
1025 {
1026   Ecore_Event_Key* keyEvent = static_cast< Ecore_Event_Key* >( event );
1027
1028   if( keyEvent->window == static_cast< unsigned int >( ecore_wl_window_id_get( mEcoreWindow ) ) )
1029   {
1030     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyUp\n" );
1031
1032 #if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
1033     // Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
1034     if( keyEvent->event_flags & ECORE_EVENT_FLAG_CANCEL )
1035     {
1036       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::OnKeyUp: This event flag indicates the event is canceled. \n" );
1037       return;
1038     }
1039 #endif // Since ecore 1.23 version
1040
1041     std::string keyName( keyEvent->keyname );
1042     std::string logicalKey( "" );
1043     std::string keyString( "" );
1044     std::string compose( "" );
1045
1046     // Ensure key compose string is not NULL as keys like SHIFT or arrow have a null string.
1047     if( keyEvent->compose )
1048     {
1049       compose = keyEvent->compose;
1050     }
1051
1052     // Ensure key symbol is not NULL as keys like SHIFT have a null string.
1053     if( keyEvent->key )
1054     {
1055       logicalKey = keyEvent->key;
1056     }
1057
1058     int keyCode = KeyLookup::GetDaliKeyCode( keyEvent->keyname );
1059     keyCode = ( keyCode == -1 ) ? 0 : keyCode;
1060     int modifier( keyEvent->modifiers );
1061     unsigned long time = keyEvent->timestamp;
1062     if( !strncmp( keyEvent->keyname, "Keycode-", 8 ) )
1063     {
1064       keyCode = atoi( keyEvent->keyname + 8 );
1065     }
1066
1067     // Ensure key event string is not NULL as keys like SHIFT have a null string.
1068     if( keyEvent->string )
1069     {
1070       keyString = keyEvent->string;
1071     }
1072
1073     std::string deviceName;
1074     Device::Class::Type deviceClass;
1075     Device::Subclass::Type deviceSubclass;
1076
1077     GetDeviceName( keyEvent, deviceName );
1078     GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
1079     GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass );
1080
1081     Integration::KeyEvent keyEvent( keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass );
1082
1083      mKeyEventSignal.Emit( keyEvent );
1084   }
1085 }
1086
1087 void WindowBaseEcoreWl::OnDataSend( void* data, int type, void* event )
1088 {
1089   mSelectionDataSendSignal.Emit( event );
1090 }
1091
1092 void WindowBaseEcoreWl::OnDataReceive( void* data, int type, void* event )
1093 {
1094   mSelectionDataReceivedSignal.Emit( event  );
1095 }
1096
1097 void WindowBaseEcoreWl::OnFontNameChanged()
1098 {
1099   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_CHANGE );
1100 }
1101
1102 void WindowBaseEcoreWl::OnFontSizeChanged()
1103 {
1104   mStyleChangedSignal.Emit( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
1105 }
1106
1107 void WindowBaseEcoreWl::OnEcoreElDBusAccessibilityNotification( void* context, const Eldbus_Message* message )
1108 {
1109 #ifdef DALI_ELDBUS_AVAILABLE
1110   AccessibilityInfo info;
1111
1112   // The string defines the arg-list's respective types.
1113   if( !eldbus_message_arguments_get( message, "iiiiiiu", &info.gestureValue, &info.startX, &info.startY, &info.endX, &info.endY, &info.state, &info.eventTime ) )
1114   {
1115     DALI_LOG_ERROR( "OnEcoreElDBusAccessibilityNotification: Error getting arguments\n" );
1116   }
1117
1118   mAccessibilitySignal.Emit( info );
1119 #endif
1120 }
1121
1122 void WindowBaseEcoreWl::RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
1123 {
1124   if( strcmp( interface, tizen_policy_interface.name ) == 0 )
1125   {
1126     uint32_t clientVersion = std::min( version, MAX_TIZEN_CLIENT_VERSION );
1127
1128     mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, clientVersion ) );
1129     if( !mTizenPolicy )
1130     {
1131       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" );
1132       return;
1133     }
1134
1135     tizen_policy_add_listener( mTizenPolicy, &tizenPolicyListener, data );
1136
1137     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" );
1138   }
1139   else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 )
1140   {
1141     mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) );
1142     if( !mTizenDisplayPolicy )
1143     {
1144       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" );
1145       return;
1146     }
1147
1148     tizen_display_policy_add_listener( mTizenDisplayPolicy, &tizenDisplayPolicyListener, data );
1149
1150     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" );
1151   }
1152 }
1153
1154 void WindowBaseEcoreWl::RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id )
1155 {
1156   mTizenPolicy = NULL;
1157   mTizenDisplayPolicy = NULL;
1158 }
1159
1160 void WindowBaseEcoreWl::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state )
1161 {
1162   mNotificationLevel = level;
1163   mNotificationChangeState = state;
1164   mNotificationLevelChangeDone = true;
1165
1166   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state );
1167 }
1168
1169 void WindowBaseEcoreWl::TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state )
1170 {
1171   mScreenOffMode = mode;
1172   mScreenOffModeChangeState = state;
1173   mScreenOffModeChangeDone = true;
1174
1175   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state );
1176 }
1177
1178 void WindowBaseEcoreWl::DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state )
1179 {
1180   mBrightness = brightness;
1181   mBrightnessChangeState = state;
1182   mBrightnessChangeDone = true;
1183
1184   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state );
1185 }
1186
1187 Any WindowBaseEcoreWl::GetNativeWindow()
1188 {
1189   return mEcoreWindow;
1190 }
1191
1192 int WindowBaseEcoreWl::GetNativeWindowId()
1193 {
1194   return ecore_wl_window_id_get( mEcoreWindow );
1195 }
1196
1197 EGLNativeWindowType WindowBaseEcoreWl::CreateEglWindow( int width, int height )
1198 {
1199   mEglWindow = wl_egl_window_create( mWlSurface, width, height );
1200
1201   return static_cast< EGLNativeWindowType >( mEglWindow );
1202 }
1203
1204 void WindowBaseEcoreWl::DestroyEglWindow()
1205 {
1206   if( mEglWindow != NULL )
1207   {
1208     wl_egl_window_destroy( mEglWindow );
1209     mEglWindow = NULL;
1210   }
1211 }
1212
1213 void WindowBaseEcoreWl::SetEglWindowRotation( int angle )
1214 {
1215   wl_egl_window_rotation rotation;
1216
1217   switch( angle )
1218   {
1219     case 0:
1220     {
1221       rotation = ROTATION_0;
1222       break;
1223     }
1224     case 90:
1225     {
1226       rotation = ROTATION_270;
1227       break;
1228     }
1229     case 180:
1230     {
1231       rotation = ROTATION_180;
1232       break;
1233     }
1234     case 270:
1235     {
1236       rotation = ROTATION_90;
1237       break;
1238     }
1239     default:
1240     {
1241       rotation = ROTATION_0;
1242       break;
1243     }
1244   }
1245
1246   wl_egl_window_set_rotation( mEglWindow, rotation );
1247 }
1248
1249 void WindowBaseEcoreWl::SetEglWindowBufferTransform( int angle )
1250 {
1251   wl_output_transform bufferTransform;
1252
1253   switch( angle )
1254   {
1255     case 0:
1256     {
1257       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1258       break;
1259     }
1260     case 90:
1261     {
1262       bufferTransform = WL_OUTPUT_TRANSFORM_90;
1263       break;
1264     }
1265     case 180:
1266     {
1267       bufferTransform = WL_OUTPUT_TRANSFORM_180;
1268       break;
1269     }
1270     case 270:
1271     {
1272       bufferTransform = WL_OUTPUT_TRANSFORM_270;
1273       break;
1274     }
1275     default:
1276     {
1277       bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1278       break;
1279     }
1280   }
1281
1282   wl_egl_window_set_buffer_transform( mEglWindow, bufferTransform );
1283 }
1284
1285 void WindowBaseEcoreWl::SetEglWindowTransform( int angle )
1286 {
1287   wl_output_transform windowTransform;
1288
1289   switch( angle )
1290   {
1291     case 0:
1292     {
1293       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1294       break;
1295     }
1296     case 90:
1297     {
1298       windowTransform = WL_OUTPUT_TRANSFORM_90;
1299       break;
1300     }
1301     case 180:
1302     {
1303       windowTransform = WL_OUTPUT_TRANSFORM_180;
1304       break;
1305     }
1306     case 270:
1307     {
1308       windowTransform = WL_OUTPUT_TRANSFORM_270;
1309       break;
1310     }
1311     default:
1312     {
1313       windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
1314       break;
1315     }
1316   }
1317
1318   wl_egl_window_set_window_transform( mEglWindow, windowTransform );
1319 }
1320
1321 void WindowBaseEcoreWl::ResizeEglWindow( PositionSize positionSize )
1322 {
1323   wl_egl_window_resize( mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y );
1324 }
1325
1326 bool WindowBaseEcoreWl::IsEglWindowRotationSupported()
1327 {
1328   // Check capability
1329   wl_egl_window_capability capability = static_cast< wl_egl_window_capability >( wl_egl_window_get_capabilities( mEglWindow ) );
1330   if( capability == WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED )
1331   {
1332     mSupportedPreProtation = true;
1333     return true;
1334   }
1335   mSupportedPreProtation = false;
1336   return false;
1337 }
1338
1339 void WindowBaseEcoreWl::Move( PositionSize positionSize )
1340 {
1341   ecore_wl_window_position_set( mEcoreWindow, positionSize.x, positionSize.y );
1342 }
1343
1344 void WindowBaseEcoreWl::Resize( PositionSize positionSize )
1345 {
1346   ecore_wl_window_update_size( mEcoreWindow, positionSize.width, positionSize.height );
1347 }
1348
1349 void WindowBaseEcoreWl::MoveResize( PositionSize positionSize )
1350 {
1351   ecore_wl_window_position_set( mEcoreWindow, positionSize.x, positionSize.y );
1352   ecore_wl_window_update_size( mEcoreWindow, positionSize.width, positionSize.height );
1353 }
1354
1355 void WindowBaseEcoreWl::SetClass( const std::string& name, const std::string& className )
1356 {
1357   ecore_wl_window_title_set( mEcoreWindow, name.c_str() );
1358   ecore_wl_window_class_name_set( mEcoreWindow, className.c_str() );
1359 }
1360
1361 void WindowBaseEcoreWl::Raise()
1362 {
1363   // Use ecore_wl_window_activate to prevent the window shown without rendering
1364   ecore_wl_window_activate( mEcoreWindow );
1365 }
1366
1367 void WindowBaseEcoreWl::Lower()
1368 {
1369   ecore_wl_window_lower( mEcoreWindow );
1370 }
1371
1372 void WindowBaseEcoreWl::Activate()
1373 {
1374   ecore_wl_window_activate( mEcoreWindow );
1375 }
1376
1377 void WindowBaseEcoreWl::SetAvailableAnlges( const std::vector< int >& angles )
1378 {
1379   int rotations[4] = { 0 };
1380   DALI_LOG_RELEASE_INFO( "WindowBaseEcoreWl::SetAvailableAnlges, angle's count: %d\n", angles.size() );
1381   for( std::size_t i = 0; i < angles.size(); ++i )
1382   {
1383     rotations[i] = static_cast< int >( angles[i] );
1384     DALI_LOG_RELEASE_INFO( "%d ", rotations[i] );
1385   }
1386   ecore_wl_window_rotation_available_rotations_set( mEcoreWindow, rotations, angles.size() );
1387 }
1388
1389 void WindowBaseEcoreWl::SetPreferredAngle( int angle )
1390 {
1391   ecore_wl_window_rotation_preferred_rotation_set( mEcoreWindow, angle );
1392 }
1393
1394 void WindowBaseEcoreWl::SetAcceptFocus( bool accept )
1395 {
1396   ecore_wl_window_focus_skip_set( mEcoreWindow, !accept );
1397 }
1398
1399 void WindowBaseEcoreWl::Show()
1400 {
1401   ecore_wl_window_show( mEcoreWindow );
1402 }
1403
1404 void WindowBaseEcoreWl::Hide()
1405 {
1406   ecore_wl_window_hide( mEcoreWindow );
1407 }
1408
1409 unsigned int WindowBaseEcoreWl::GetSupportedAuxiliaryHintCount() const
1410 {
1411   return mSupportedAuxiliaryHints.size();
1412 }
1413
1414 std::string WindowBaseEcoreWl::GetSupportedAuxiliaryHint( unsigned int index ) const
1415 {
1416   if( index >= GetSupportedAuxiliaryHintCount() )
1417   {
1418     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
1419   }
1420
1421   return mSupportedAuxiliaryHints[index];
1422 }
1423
1424 unsigned int WindowBaseEcoreWl::AddAuxiliaryHint( const std::string& hint, const std::string& value )
1425 {
1426   bool supported = false;
1427
1428   // Check if the hint is suppported
1429   for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
1430   {
1431     if( *iter == hint )
1432     {
1433       supported = true;
1434       break;
1435     }
1436   }
1437
1438   if( !supported )
1439   {
1440     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
1441     return 0;
1442   }
1443
1444   // Check if the hint is already added
1445   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1446   {
1447     if( mAuxiliaryHints[i].first == hint )
1448     {
1449       // Just change the value
1450       mAuxiliaryHints[i].second = value;
1451
1452       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
1453
1454       return i + 1;   // id is index + 1
1455     }
1456   }
1457
1458   // Add the hint
1459   mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
1460
1461   unsigned int id = mAuxiliaryHints.size();
1462
1463   ecore_wl_window_aux_hint_add( mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
1464
1465   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
1466
1467   return id;
1468 }
1469
1470 bool WindowBaseEcoreWl::RemoveAuxiliaryHint( unsigned int id )
1471 {
1472   if( id == 0 || id > mAuxiliaryHints.size() )
1473   {
1474     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
1475     return false;
1476   }
1477
1478   mAuxiliaryHints[id - 1].second = std::string();
1479
1480   ecore_wl_window_aux_hint_del( mEcoreWindow, static_cast< int >( id ) );
1481
1482   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
1483
1484   return true;
1485 }
1486
1487 bool WindowBaseEcoreWl::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
1488 {
1489   if( id == 0 || id > mAuxiliaryHints.size() )
1490   {
1491     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
1492     return false;
1493   }
1494
1495   mAuxiliaryHints[id - 1].second = value;
1496
1497   ecore_wl_window_aux_hint_change( mEcoreWindow, static_cast< int >( id ), value.c_str() );
1498
1499   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() );
1500
1501   return true;
1502 }
1503
1504 std::string WindowBaseEcoreWl::GetAuxiliaryHintValue( unsigned int id ) const
1505 {
1506   if( id == 0 || id > mAuxiliaryHints.size() )
1507   {
1508     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
1509     return std::string();
1510   }
1511
1512   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() );
1513
1514   return mAuxiliaryHints[id - 1].second;
1515 }
1516
1517 unsigned int WindowBaseEcoreWl::GetAuxiliaryHintId( const std::string& hint ) const
1518 {
1519   for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
1520   {
1521     if( mAuxiliaryHints[i].first == hint )
1522     {
1523       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
1524       return i + 1;
1525     }
1526   }
1527
1528   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
1529
1530   return 0;
1531 }
1532
1533 void WindowBaseEcoreWl::SetInputRegion( const Rect< int >& inputRegion )
1534 {
1535   ecore_wl_window_input_region_set( mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
1536 }
1537
1538 void WindowBaseEcoreWl::SetType( Dali::Window::Type type )
1539 {
1540   Ecore_Wl_Window_Type windowType;
1541
1542   switch( type )
1543   {
1544     case Dali::Window::NORMAL:
1545     {
1546       windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1547       break;
1548     }
1549     case Dali::Window::NOTIFICATION:
1550     {
1551       windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION;
1552       break;
1553     }
1554     case Dali::Window::UTILITY:
1555     {
1556       windowType = ECORE_WL_WINDOW_TYPE_UTILITY;
1557       break;
1558     }
1559     case Dali::Window::DIALOG:
1560     {
1561       windowType = ECORE_WL_WINDOW_TYPE_DIALOG;
1562       break;
1563     }
1564     default:
1565     {
1566       windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL;
1567       break;
1568     }
1569   }
1570
1571   ecore_wl_window_type_set( mEcoreWindow, windowType );
1572 }
1573
1574 bool WindowBaseEcoreWl::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
1575 {
1576   while( !mTizenPolicy )
1577   {
1578     wl_display_dispatch_queue( mDisplay, mEventQueue );
1579   }
1580
1581   int notificationLevel;
1582
1583   switch( level )
1584   {
1585     case Dali::Window::NotificationLevel::NONE:
1586     {
1587       notificationLevel = TIZEN_POLICY_LEVEL_NONE;
1588       break;
1589     }
1590     case Dali::Window::NotificationLevel::BASE:
1591     {
1592       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1593       break;
1594     }
1595     case Dali::Window::NotificationLevel::MEDIUM:
1596     {
1597       notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM;
1598       break;
1599     }
1600     case Dali::Window::NotificationLevel::HIGH:
1601     {
1602       notificationLevel = TIZEN_POLICY_LEVEL_HIGH;
1603       break;
1604     }
1605     case Dali::Window::NotificationLevel::TOP:
1606     {
1607       notificationLevel = TIZEN_POLICY_LEVEL_TOP;
1608       break;
1609     }
1610     default:
1611     {
1612       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: invalid level [%d]\n", level );
1613       notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
1614       break;
1615     }
1616   }
1617
1618   mNotificationLevelChangeDone = false;
1619   mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1620
1621   tizen_policy_set_notification_level( mTizenPolicy, ecore_wl_window_surface_get( mEcoreWindow ), notificationLevel );
1622
1623   int count = 0;
1624
1625   while( !mNotificationLevelChangeDone && count < 3 )
1626   {
1627     ecore_wl_flush();
1628     wl_display_dispatch_queue( mDisplay, mEventQueue );
1629     count++;
1630   }
1631
1632   if( !mNotificationLevelChangeDone )
1633   {
1634     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mNotificationChangeState );
1635     return false;
1636   }
1637   else if( mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1638   {
1639     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Permission denied! [%d]\n", level );
1640     return false;
1641   }
1642
1643   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetNotificationLevel: Level is changed [%d]\n", mNotificationLevel );
1644
1645   return true;
1646 }
1647
1648 Dali::Window::NotificationLevel::Type WindowBaseEcoreWl::GetNotificationLevel() const
1649 {
1650   while( !mTizenPolicy )
1651   {
1652     wl_display_dispatch_queue( mDisplay, mEventQueue );
1653   }
1654
1655   int count = 0;
1656
1657   while( !mNotificationLevelChangeDone && count < 3 )
1658   {
1659     ecore_wl_flush();
1660     wl_display_dispatch_queue( mDisplay, mEventQueue );
1661     count++;
1662   }
1663
1664   if( !mNotificationLevelChangeDone )
1665   {
1666     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: Error! [%d]\n", mNotificationChangeState );
1667     return Dali::Window::NotificationLevel::NONE;
1668   }
1669
1670   Dali::Window::NotificationLevel::Type level;
1671
1672   switch( mNotificationLevel )
1673   {
1674     case TIZEN_POLICY_LEVEL_NONE:
1675     {
1676       level = Dali::Window::NotificationLevel::NONE;
1677       break;
1678     }
1679     case TIZEN_POLICY_LEVEL_DEFAULT:
1680     {
1681       level = Dali::Window::NotificationLevel::BASE;
1682       break;
1683     }
1684     case TIZEN_POLICY_LEVEL_MEDIUM:
1685     {
1686       level = Dali::Window::NotificationLevel::MEDIUM;
1687       break;
1688     }
1689     case TIZEN_POLICY_LEVEL_HIGH:
1690     {
1691       level = Dali::Window::NotificationLevel::HIGH;
1692       break;
1693     }
1694     case TIZEN_POLICY_LEVEL_TOP:
1695     {
1696       level = Dali::Window::NotificationLevel::TOP;
1697       break;
1698     }
1699     default:
1700     {
1701       DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: invalid level [%d]\n", mNotificationLevel );
1702       level = Dali::Window::NotificationLevel::NONE;
1703       break;
1704     }
1705   }
1706
1707   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetNotificationLevel: level [%d]\n", mNotificationLevel );
1708
1709   return level;
1710 }
1711
1712 void WindowBaseEcoreWl::SetOpaqueState( bool opaque )
1713 {
1714   while( !mTizenPolicy )
1715   {
1716     wl_display_dispatch_queue( mDisplay, mEventQueue );
1717   }
1718
1719   tizen_policy_set_opaque_state( mTizenPolicy, ecore_wl_window_surface_get( mEcoreWindow ), ( opaque ? 1 : 0 ) );
1720 }
1721
1722 bool WindowBaseEcoreWl::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
1723 {
1724   while( !mTizenPolicy )
1725   {
1726     wl_display_dispatch_queue( mDisplay, mEventQueue );
1727   }
1728
1729   mScreenOffModeChangeDone = false;
1730   mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1731
1732   unsigned int mode = 0;
1733
1734   switch( screenOffMode )
1735   {
1736     case Dali::Window::ScreenOffMode::TIMEOUT:
1737     {
1738       mode = 0;
1739       break;
1740     }
1741     case Dali::Window::ScreenOffMode::NEVER:
1742     {
1743       mode = 1;
1744       break;
1745     }
1746   }
1747
1748   tizen_policy_set_window_screen_mode( mTizenPolicy, ecore_wl_window_surface_get( mEcoreWindow ), mode );
1749
1750   int count = 0;
1751
1752   while( !mScreenOffModeChangeDone && count < 3 )
1753   {
1754     ecore_wl_flush();
1755     wl_display_dispatch_queue( mDisplay, mEventQueue );
1756     count++;
1757   }
1758
1759   if( !mScreenOffModeChangeDone )
1760   {
1761     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mScreenOffModeChangeState );
1762     return false;
1763   }
1764   else if( mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1765   {
1766     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode );
1767     return false;
1768   }
1769
1770   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetScreenOffMode: Screen mode is changed [%d]\n", mScreenOffMode );
1771
1772   return true;
1773 }
1774
1775 Dali::Window::ScreenOffMode::Type WindowBaseEcoreWl::GetScreenOffMode() const
1776 {
1777   while( !mTizenPolicy )
1778   {
1779     wl_display_dispatch_queue( mDisplay, mEventQueue );
1780   }
1781
1782   int count = 0;
1783
1784   while( !mScreenOffModeChangeDone && count < 3 )
1785   {
1786     ecore_wl_flush();
1787     wl_display_dispatch_queue( mDisplay, mEventQueue );
1788     count++;
1789   }
1790
1791   if( !mScreenOffModeChangeDone )
1792   {
1793     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetScreenOffMode: Error! [%d]\n", mScreenOffModeChangeState );
1794     return Dali::Window::ScreenOffMode::TIMEOUT;
1795   }
1796
1797   Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1798
1799   switch( mScreenOffMode )
1800   {
1801     case 0:
1802     {
1803       screenMode = Dali::Window::ScreenOffMode::TIMEOUT;
1804       break;
1805     }
1806     case 1:
1807     {
1808       screenMode = Dali::Window::ScreenOffMode::NEVER;
1809       break;
1810     }
1811   }
1812
1813   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetScreenOffMode: screen mode [%d]\n", mScreenOffMode );
1814
1815   return screenMode;
1816 }
1817
1818 bool WindowBaseEcoreWl::SetBrightness( int brightness )
1819 {
1820   while( !mTizenDisplayPolicy )
1821   {
1822     wl_display_dispatch_queue( mDisplay, mEventQueue );
1823   }
1824
1825   mBrightnessChangeDone = false;
1826   mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE;
1827
1828   tizen_display_policy_set_window_brightness( mTizenDisplayPolicy, ecore_wl_window_surface_get( mEcoreWindow ), brightness );
1829
1830   int count = 0;
1831
1832   while( !mBrightnessChangeDone && count < 3 )
1833   {
1834     ecore_wl_flush();
1835     wl_display_dispatch_queue( mDisplay, mEventQueue );
1836     count++;
1837   }
1838
1839   if( !mBrightnessChangeDone )
1840   {
1841     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mBrightnessChangeState );
1842     return false;
1843   }
1844   else if( mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED )
1845   {
1846     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Permission denied! [%d]\n", brightness );
1847     return false;
1848   }
1849
1850   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::SetBrightness: Brightness is changed [%d]\n", mBrightness );
1851
1852   return true;
1853 }
1854
1855 int WindowBaseEcoreWl::GetBrightness() const
1856 {
1857   while( !mTizenDisplayPolicy )
1858   {
1859     wl_display_dispatch_queue( mDisplay, mEventQueue );
1860   }
1861
1862   int count = 0;
1863
1864   while( !mBrightnessChangeDone && count < 3 )
1865   {
1866     ecore_wl_flush();
1867     wl_display_dispatch_queue( mDisplay, mEventQueue );
1868     count++;
1869   }
1870
1871   if( !mBrightnessChangeDone )
1872   {
1873     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetBrightness: Error! [%d]\n", mBrightnessChangeState );
1874     return 0;
1875   }
1876
1877   DALI_LOG_INFO( gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl::GetBrightness: Brightness [%d]\n", mBrightness );
1878
1879   return mBrightness;
1880 }
1881
1882 bool WindowBaseEcoreWl::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
1883 {
1884   Ecore_Wl_Window_Keygrab_Mode mode;
1885
1886   switch( grabMode )
1887   {
1888     case KeyGrab::TOPMOST:
1889     {
1890       mode = ECORE_WL_WINDOW_KEYGRAB_TOPMOST;
1891       break;
1892     }
1893     case KeyGrab::SHARED:
1894     {
1895       mode = ECORE_WL_WINDOW_KEYGRAB_SHARED;
1896       break;
1897     }
1898     case KeyGrab::OVERRIDE_EXCLUSIVE:
1899     {
1900       mode = ECORE_WL_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
1901       break;
1902     }
1903     case KeyGrab::EXCLUSIVE:
1904     {
1905       mode = ECORE_WL_WINDOW_KEYGRAB_EXCLUSIVE;
1906       break;
1907     }
1908     default:
1909     {
1910       return false;
1911     }
1912   }
1913
1914   return ecore_wl_window_keygrab_set( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0, 0, mode );
1915 }
1916
1917 bool WindowBaseEcoreWl::UngrabKey( Dali::KEY key )
1918 {
1919   return ecore_wl_window_keygrab_unset( mEcoreWindow, KeyLookup::GetKeyName( key ), 0, 0 );
1920 }
1921
1922 bool WindowBaseEcoreWl::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
1923 {
1924   int keyCount = key.Count();
1925   int keyGrabModeCount = grabMode.Count();
1926
1927   if( keyCount != keyGrabModeCount || keyCount == 0 )
1928   {
1929     return false;
1930   }
1931
1932   eina_init();
1933
1934   Eina_List* keyList = NULL;
1935   Ecore_Wl_Window_Keygrab_Info* info = new Ecore_Wl_Window_Keygrab_Info[keyCount];
1936
1937   for( int index = 0; index < keyCount; ++index )
1938   {
1939     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
1940
1941     switch( grabMode[index] )
1942     {
1943       case KeyGrab::TOPMOST:
1944       {
1945         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_TOPMOST;
1946         break;
1947       }
1948       case KeyGrab::SHARED:
1949       {
1950         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_SHARED;
1951         break;
1952       }
1953       case KeyGrab::OVERRIDE_EXCLUSIVE:
1954       {
1955         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
1956         break;
1957       }
1958       case KeyGrab::EXCLUSIVE:
1959       {
1960         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_EXCLUSIVE;
1961         break;
1962       }
1963       default:
1964       {
1965         info[index].mode = ECORE_WL_WINDOW_KEYGRAB_UNKNOWN;
1966         break;
1967       }
1968     }
1969
1970     keyList = eina_list_append( keyList, &info );
1971   }
1972
1973   Eina_List* grabList = ecore_wl_window_keygrab_list_set( mEcoreWindow, keyList );
1974
1975   result.Resize( keyCount, true );
1976
1977   Eina_List* l = NULL;
1978   Eina_List* m = NULL;
1979   void* listData = NULL;
1980   void* data = NULL;
1981   if( grabList != NULL )
1982   {
1983     EINA_LIST_FOREACH( grabList, m, data )
1984     {
1985       int index = 0;
1986       EINA_LIST_FOREACH( keyList, l, listData )
1987       {
1988         if( static_cast< Ecore_Wl_Window_Keygrab_Info* >( listData )->key == NULL )
1989         {
1990           DALI_LOG_ERROR( "input key list has null data!" );
1991           break;
1992         }
1993
1994         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl_Window_Keygrab_Info* >( listData )->key ) == 0 )
1995         {
1996           result[index] = false;
1997         }
1998         ++index;
1999       }
2000     }
2001   }
2002
2003   delete [] info;
2004
2005   eina_list_free( keyList );
2006   eina_list_free( grabList );
2007   eina_shutdown();
2008
2009   return true;
2010 }
2011
2012 bool WindowBaseEcoreWl::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
2013 {
2014   int keyCount = key.Count();
2015   if( keyCount == 0 )
2016   {
2017     return false;
2018   }
2019
2020   eina_init();
2021
2022   Eina_List* keyList = NULL;
2023   Ecore_Wl_Window_Keygrab_Info* info = new Ecore_Wl_Window_Keygrab_Info[keyCount];
2024
2025   for( int index = 0; index < keyCount; ++index )
2026   {
2027     info[index].key = const_cast< char* >( KeyLookup::GetKeyName( key[index] ) );
2028     keyList = eina_list_append( keyList, &info );
2029   }
2030
2031   Eina_List* ungrabList = ecore_wl_window_keygrab_list_unset( mEcoreWindow, keyList );
2032
2033   result.Resize( keyCount, true );
2034
2035   Eina_List* l = NULL;
2036   Eina_List* m = NULL;
2037   void *listData = NULL;
2038   void *data = NULL;
2039
2040   if( ungrabList != NULL )
2041   {
2042     EINA_LIST_FOREACH( ungrabList, m, data )
2043     {
2044       int index = 0;
2045       EINA_LIST_FOREACH( keyList, l, listData )
2046       {
2047         if( strcmp( static_cast< char* >( data ), static_cast< Ecore_Wl_Window_Keygrab_Info* >( listData )->key ) == 0 )
2048         {
2049           result[index] = false;
2050         }
2051         ++index;
2052       }
2053     }
2054   }
2055
2056   delete [] info;
2057
2058   eina_list_free( keyList );
2059   eina_list_free( ungrabList );
2060   eina_shutdown();
2061
2062   return true;
2063 }
2064
2065 void WindowBaseEcoreWl::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
2066 {
2067   // calculate DPI
2068   float xres, yres;
2069
2070   // 1 inch = 25.4 millimeters
2071   xres = ecore_wl_dpi_get();
2072   yres = ecore_wl_dpi_get();
2073
2074   dpiHorizontal = int( xres + 0.5f );  // rounding
2075   dpiVertical   = int( yres + 0.5f );
2076 }
2077
2078 int WindowBaseEcoreWl::GetOrientation() const
2079 {
2080   int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
2081   if( mSupportedPreProtation )
2082   {
2083     orientation = 0;
2084   }
2085   return orientation;
2086 }
2087
2088 int WindowBaseEcoreWl::GetScreenRotationAngle()
2089 {
2090   int transform = 0;
2091
2092   if( ecore_wl_window_ignore_output_transform_get( mEcoreWindow ) )
2093   {
2094     transform = 0;
2095   }
2096   else
2097   {
2098     transform = ecore_wl_output_transform_get( ecore_wl_window_output_find( mEcoreWindow ) );
2099   }
2100
2101   mScreenRotationAngle = transform * 90;
2102   return mScreenRotationAngle;
2103 }
2104
2105 void WindowBaseEcoreWl::SetWindowRotationAngle( int degree )
2106 {
2107   mWindowRotationAngle = degree;
2108   ecore_wl_window_rotation_set( mEcoreWindow, degree );
2109 }
2110
2111 int WindowBaseEcoreWl::GetWindowRotationAngle()
2112 {
2113   return mWindowRotationAngle;
2114 }
2115
2116 void WindowBaseEcoreWl::WindowRotationCompleted( int degree, int width, int height )
2117 {
2118   ecore_wl_window_rotation_change_done_send( mEcoreWindow );
2119 }
2120
2121 void WindowBaseEcoreWl::SetTransparency( bool transparent )
2122 {
2123   ecore_wl_window_alpha_set( mEcoreWindow, transparent );
2124 }
2125
2126 void WindowBaseEcoreWl::InitializeEcoreElDBus()
2127 {
2128 #ifdef DALI_ELDBUS_AVAILABLE
2129   Eldbus_Object* object;
2130   Eldbus_Proxy* manager;
2131
2132   if( !( mSystemConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SYSTEM ) ) )
2133   {
2134     DALI_LOG_ERROR( "Unable to get system bus\n" );
2135   }
2136
2137   object = eldbus_object_get( mSystemConnection, BUS, PATH );
2138   if( !object )
2139   {
2140     DALI_LOG_ERROR( "Getting object failed\n" );
2141     return;
2142   }
2143
2144   manager = eldbus_proxy_get( object, INTERFACE );
2145   if( !manager )
2146   {
2147     DALI_LOG_ERROR( "Getting proxy failed\n" );
2148     return;
2149   }
2150
2151   if( !eldbus_proxy_signal_handler_add( manager, "GestureDetected", EcoreElDBusAccessibilityNotification, this ) )
2152   {
2153     DALI_LOG_ERROR( "No signal handler returned\n" );
2154   }
2155 #endif
2156 }
2157
2158 void WindowBaseEcoreWl::CreateWindow( PositionSize positionSize )
2159 {
2160   mEcoreWindow = ecore_wl_window_new( 0, positionSize.x, positionSize.y, positionSize.width, positionSize.height, ECORE_WL_WINDOW_BUFFER_TYPE_EGL_WINDOW );
2161
2162   if ( mEcoreWindow == 0 )
2163   {
2164     DALI_ASSERT_ALWAYS( 0 && "Failed to create Wayland window" );
2165   }
2166 }
2167
2168 void WindowBaseEcoreWl::SetParent( WindowBase* parentWinBase )
2169 {
2170   Ecore_Wl_Window* ecoreParent = NULL;
2171   if( parentWinBase )
2172   {
2173     WindowBaseEcoreWl* winBaseEcore = static_cast<WindowBaseEcoreWl*>( parentWinBase );
2174     ecoreParent = winBaseEcore->mEcoreWindow;
2175   }
2176   ecore_wl_window_parent_set( mEcoreWindow, ecoreParent );
2177 }
2178
2179 int WindowBaseEcoreWl::CreateFrameRenderedSyncFence()
2180 {
2181   return -1;
2182 }
2183
2184 int WindowBaseEcoreWl::CreateFramePresentedSyncFence()
2185 {
2186   return -1;
2187 }
2188
2189 } // namespace Adaptor
2190
2191 } // namespace Internal
2192
2193 } // namespace Dali
2194
2195 #pragma GCC diagnostic pop