dali/internal/window-system/tizen-wayland/ecore-wl2/window-base-ecore-wl2.cpp

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