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

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