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

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