adaptors/ecore/wayland/event-handler-ecore-wl.cpp

   1 /*
   2  * Copyright (c) 2015 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 // CLASS HEADER
  19 #include <events/event-handler.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <Ecore.h>
  23 #include <Ecore_Input.h>
  24 #include <ecore-wl-render-surface.h>
  25 #include <cstring>
  26
  27 #include <sys/time.h>
  28
  29 #ifndef DALI_PROFILE_UBUNTU
  30 #include <vconf.h>
  31 #include <vconf-keys.h>
  32 #endif // DALI_PROFILE_UBUNTU
  33
  34 #include <dali/public-api/common/vector-wrapper.h>
  35 #include <dali/public-api/events/touch-point.h>
  36 #include <dali/public-api/events/key-event.h>
  37 #include <dali/public-api/events/wheel-event.h>
  38 #include <dali/integration-api/debug.h>
  39 #include <dali/integration-api/events/key-event-integ.h>
  40 #include <dali/integration-api/events/touch-event-integ.h>
  41 #include <dali/integration-api/events/hover-event-integ.h>
  42 #include <dali/integration-api/events/wheel-event-integ.h>
  43
  44 // INTERNAL INCLUDES
  45 #include <events/gesture-manager.h>
  46 #include <window-render-surface.h>
  47 #include <clipboard-impl.h>
  48 #include <key-impl.h>
  49 #include <physical-keyboard-impl.h>
  50 #include <style-monitor-impl.h>
  51 #include <base/core-event-interface.h>
  52
  53 namespace Dali
  54 {
  55
  56 namespace Internal
  57 {
  58
  59 namespace Adaptor
  60 {
  61
  62 #if defined(DEBUG_ENABLED)
  63 namespace
  64 {
  65 Integration::Log::Filter* gTouchEventLogFilter  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_TOUCH");
  66 Integration::Log::Filter* gClientMessageLogFilter  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_CLIENT_MESSAGE");
  67 Integration::Log::Filter* gDragAndDropLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DND");
  68 Integration::Log::Filter* gImfLogging  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_IMF");
  69 Integration::Log::Filter* gSelectionEventLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_SELECTION");
  70 } // unnamed namespace
  71 #endif
  72
  73
  74 namespace
  75 {
  76 const unsigned int PRIMARY_TOUCH_BUTTON_ID( 1 );
  77
  78 const unsigned int BYTES_PER_CHARACTER_FOR_ATTRIBUTES = 3;
  79
  80 /**
  81  * Ecore_Event_Modifier enums in Ecore_Input.h do not match Ecore_IMF_Keyboard_Modifiers in Ecore_IMF.h.
  82  * This function converts from Ecore_Event_Modifier to Ecore_IMF_Keyboard_Modifiers enums.
  83  * @param[in] ecoreModifier the Ecore_Event_Modifier input.
  84  * @return the Ecore_IMF_Keyboard_Modifiers output.
  85  */
  86 Ecore_IMF_Keyboard_Modifiers EcoreInputModifierToEcoreIMFModifier(unsigned int ecoreModifier)
  87 {
  88    int modifier( ECORE_IMF_KEYBOARD_MODIFIER_NONE );  // If no other matches returns NONE.
  89
  90
  91    if ( ecoreModifier & ECORE_EVENT_MODIFIER_SHIFT )  // enums from ecore_input/Ecore_Input.h
  92    {
  93      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_SHIFT;  // enums from ecore_imf/ecore_imf.h
  94    }
  95
  96    if ( ecoreModifier & ECORE_EVENT_MODIFIER_ALT )
  97    {
  98      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_ALT;
  99    }
 100
 101    if ( ecoreModifier & ECORE_EVENT_MODIFIER_CTRL )
 102    {
 103      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_CTRL;
 104    }
 105
 106    if ( ecoreModifier & ECORE_EVENT_MODIFIER_WIN )
 107    {
 108      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_WIN;
 109    }
 110
 111    if ( ecoreModifier & ECORE_EVENT_MODIFIER_ALTGR )
 112    {
 113      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_ALTGR;
 114    }
 115
 116    return static_cast<Ecore_IMF_Keyboard_Modifiers>( modifier );
 117 }
 118
 119
 120 // Copied from x server
 121 static unsigned int GetCurrentMilliSeconds(void)
 122 {
 123   struct timeval tv;
 124
 125   struct timespec tp;
 126   static clockid_t clockid;
 127
 128   if (!clockid)
 129   {
 130 #ifdef CLOCK_MONOTONIC_COARSE
 131     if (clock_getres(CLOCK_MONOTONIC_COARSE, &tp) == 0 &&
 132       (tp.tv_nsec / 1000) <= 1000 && clock_gettime(CLOCK_MONOTONIC_COARSE, &tp) == 0)
 133     {
 134       clockid = CLOCK_MONOTONIC_COARSE;
 135     }
 136     else
 137 #endif
 138     if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
 139     {
 140       clockid = CLOCK_MONOTONIC;
 141     }
 142     else
 143     {
 144       clockid = ~0L;
 145     }
 146   }
 147   if (clockid != ~0L && clock_gettime(clockid, &tp) == 0)
 148   {
 149     return (tp.tv_sec * 1000) + (tp.tv_nsec / 1000000L);
 150   }
 151
 152   gettimeofday(&tv, NULL);
 153   return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
 154 }
 155
 156 #ifndef DALI_PROFILE_UBUNTU
 157 const char * DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE = "db/setting/accessibility/font_name";  // It will be update at vconf-key.h and replaced.
 158 #endif // DALI_PROFILE_UBUNTU
 159
 160 } // unnamed namespace
 161
 162 // Impl to hide EFL implementation.
 163 struct EventHandler::Impl
 164 {
 165   // Construction & Destruction
 166
 167   /**
 168    * Constructor
 169    */
 170   Impl( EventHandler* handler, Ecore_Wl_Window* window )
 171   : mHandler( handler ),
 172     mEcoreEventHandler(),
 173     mWindow( window )
 174   {
 175     // Only register for touch and key events if we have a window
 176     if ( window != 0 )
 177     {
 178       // Register Touch events
 179       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,  EcoreEventMouseButtonDown, handler ) );
 180       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,    EcoreEventMouseButtonUp,   handler ) );
 181       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE,         EcoreEventMouseButtonMove, handler ) );
 182       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_OUT,          EcoreEventMouseButtonUp,   handler ) ); // process mouse out event like up event
 183
 184       // Register Mouse wheel events
 185       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL,        EcoreEventMouseWheel,      handler ) );
 186
 187       // Register Key events
 188       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN,           EcoreEventKeyDown,         handler ) );
 189       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_KEY_UP,             EcoreEventKeyUp,           handler ) );
 190
 191 #ifndef DALI_PROFILE_UBUNTU
 192       // Register Vconf notify - font name and size
 193       vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontNameChanged, handler );
 194       vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, handler );
 195 #endif // DALI_PROFILE_UBUNTU
 196     }
 197   }
 198
 199   /**
 200    * Destructor
 201    */
 202   ~Impl()
 203   {
 204 #ifndef DALI_PROFILE_UBUNTU
 205     vconf_ignore_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged );
 206     vconf_ignore_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontNameChanged );
 207 #endif // DALI_PROFILE_UBUNTU
 208
 209     for( std::vector<Ecore_Event_Handler*>::iterator iter = mEcoreEventHandler.begin(), endIter = mEcoreEventHandler.end(); iter != endIter; ++iter )
 210     {
 211       ecore_event_handler_del( *iter );
 212     }
 213   }
 214
 215   // Static methods
 216
 217   /////////////////////////////////////////////////////////////////////////////////////////////////
 218   // Touch Callbacks
 219   /////////////////////////////////////////////////////////////////////////////////////////////////
 220
 221   /**
 222    * Called when a touch down is received.
 223    */
 224   static Eina_Bool EcoreEventMouseButtonDown( void* data, int type, void* event )
 225   {
 226     Ecore_Event_Mouse_Button *touchEvent( (Ecore_Event_Mouse_Button*)event );
 227     EventHandler* handler( (EventHandler*)data );
 228
 229     if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 230     {
 231       TouchPoint::State state ( TouchPoint::Down );
 232
 233       // Check if the buttons field is set and ensure it's the primary touch button.
 234       // If this event was triggered by buttons other than the primary button (used for touch), then
 235       // just send an interrupted event to Core.
 236       if ( touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID ) )
 237       {
 238         state = TouchPoint::Interrupted;
 239       }
 240
 241       TouchPoint point( touchEvent->multi.device, state, touchEvent->x, touchEvent->y );
 242       handler->SendEvent( point, touchEvent->timestamp );
 243     }
 244
 245     return ECORE_CALLBACK_PASS_ON;
 246   }
 247
 248   /**
 249    * Called when a touch up is received.
 250    */
 251   static Eina_Bool EcoreEventMouseButtonUp( void* data, int type, void* event )
 252   {
 253     Ecore_Event_Mouse_Button *touchEvent( (Ecore_Event_Mouse_Button*)event );
 254     EventHandler* handler( (EventHandler*)data );
 255
 256     if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 257     {
 258       TouchPoint point( touchEvent->multi.device, TouchPoint::Up, touchEvent->x, touchEvent->y );
 259       handler->SendEvent( point, touchEvent->timestamp );
 260     }
 261
 262     return ECORE_CALLBACK_PASS_ON;
 263   }
 264
 265   /**
 266    * Called when a touch up is received.
 267    */
 268   static Eina_Bool EcoreEventMouseWheel( void* data, int type, void* event )
 269   {
 270     Ecore_Event_Mouse_Wheel *mouseWheelEvent( (Ecore_Event_Mouse_Wheel*)event );
 271
 272     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT Ecore_Event_Mouse_Wheel: direction: %d, modifiers: %d, x: %d, y: %d, z: %d\n", mouseWheelEvent->direction, mouseWheelEvent->modifiers, mouseWheelEvent->x, mouseWheelEvent->y, mouseWheelEvent->z);
 273
 274     EventHandler* handler( (EventHandler*)data );
 275     if ( mouseWheelEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 276     {
 277       WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp );
 278       handler->SendWheelEvent( wheelEvent );
 279     }
 280     return ECORE_CALLBACK_PASS_ON;
 281   }
 282
 283   /**
 284    * Called when a touch motion is received.
 285    */
 286   static Eina_Bool EcoreEventMouseButtonMove( void* data, int type, void* event )
 287   {
 288     Ecore_Event_Mouse_Move *touchEvent( (Ecore_Event_Mouse_Move*)event );
 289     EventHandler* handler( (EventHandler*)data );
 290
 291     if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 292     {
 293       TouchPoint point( touchEvent->multi.device, TouchPoint::Motion, touchEvent->x, touchEvent->y );
 294       handler->SendEvent( point, touchEvent->timestamp );
 295     }
 296
 297     return ECORE_CALLBACK_PASS_ON;
 298   }
 299
 300   /////////////////////////////////////////////////////////////////////////////////////////////////
 301   // Key Callbacks
 302   /////////////////////////////////////////////////////////////////////////////////////////////////
 303
 304   /**
 305    * Called when a key down is received.
 306    */
 307   static Eina_Bool EcoreEventKeyDown( void* data, int type, void* event )
 308   {
 309     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventKeyDown \n" );
 310
 311     EventHandler* handler( (EventHandler*)data );
 312     Ecore_Event_Key *keyEvent( (Ecore_Event_Key*)event );
 313     bool eventHandled( false );
 314
 315     // If a device key then skip ecore_imf_context_filter_event.
 316     if ( ! KeyLookup::IsDeviceButton( keyEvent->keyname ) )
 317     {
 318       Ecore_IMF_Context* imfContext = NULL;
 319       Dali::ImfManager imfManager( ImfManager::Get() );
 320       if ( imfManager )
 321       {
 322         imfContext = ImfManager::GetImplementation( imfManager ).GetContext();
 323       }
 324
 325       if ( imfContext )
 326       {
 327         // We're consuming key down event so we have to pass to IMF so that it can parse it as well.
 328         Ecore_IMF_Event_Key_Down ecoreKeyDownEvent;
 329         ecoreKeyDownEvent.keyname   = keyEvent->keyname;
 330         ecoreKeyDownEvent.key       = keyEvent->key;
 331         ecoreKeyDownEvent.string    = keyEvent->string;
 332         ecoreKeyDownEvent.compose   = keyEvent->compose;
 333         ecoreKeyDownEvent.timestamp = keyEvent->timestamp;
 334         ecoreKeyDownEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers );
 335         ecoreKeyDownEvent.locks     = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE;
 336
 337         eventHandled = ecore_imf_context_filter_event( imfContext,
 338                                                        ECORE_IMF_EVENT_KEY_DOWN,
 339                                                        (Ecore_IMF_Event *) &ecoreKeyDownEvent );
 340
 341         // If the event has not been handled by IMF then check if we should reset our IMF context
 342         if( !eventHandled )
 343         {
 344           if ( !strcmp( keyEvent->keyname, "Escape"   ) ||
 345                !strcmp( keyEvent->keyname, "Return"   ) ||
 346                !strcmp( keyEvent->keyname, "KP_Enter" ) )
 347           {
 348             ecore_imf_context_reset( imfContext );
 349           }
 350         }
 351       }
 352     }
 353
 354     // If the event wasn't handled then we should send a key event.
 355     if ( !eventHandled )
 356     {
 357       if ( keyEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 358       {
 359         std::string keyName( keyEvent->keyname );
 360         std::string keyString( "" );
 361         int keyCode = 0/*ecore_x_keysym_keycode_get(keyEvent->keyname)*/;
 362         int modifier( keyEvent->modifiers );
 363         unsigned long time = keyEvent->timestamp;
 364
 365         if (!strncmp(keyEvent->keyname, "Keycode-", 8))
 366           keyCode = atoi(keyEvent->keyname + 8);
 367
 368         // Ensure key event string is not NULL as keys like SHIFT have a null string.
 369         if ( keyEvent->string )
 370         {
 371           keyString = keyEvent->string;
 372         }
 373
 374         KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Down);
 375         handler->SendEvent( keyEvent );
 376       }
 377     }
 378
 379     return ECORE_CALLBACK_PASS_ON;
 380   }
 381
 382   /**
 383    * Called when a key up is received.
 384    */
 385   static Eina_Bool EcoreEventKeyUp( void* data, int type, void* event )
 386   {
 387     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventKeyUp\n" );
 388
 389     EventHandler* handler( (EventHandler*)data );
 390     Ecore_Event_Key *keyEvent( (Ecore_Event_Key*)event );
 391     bool eventHandled( false );
 392
 393     // Device keys like Menu, home, back button must skip ecore_imf_context_filter_event.
 394     if ( ! KeyLookup::IsDeviceButton( keyEvent->keyname ) )
 395     {
 396       Ecore_IMF_Context* imfContext = NULL;
 397       Dali::ImfManager imfManager( ImfManager::Get() );
 398       if ( imfManager )
 399       {
 400         imfContext = ImfManager::GetImplementation( imfManager ).GetContext();
 401       }
 402
 403       if ( imfContext )
 404       {
 405         // We're consuming key up event so we have to pass to IMF so that it can parse it as well.
 406         Ecore_IMF_Event_Key_Up ecoreKeyUpEvent;
 407         ecoreKeyUpEvent.keyname   = keyEvent->keyname;
 408         ecoreKeyUpEvent.key       = keyEvent->key;
 409         ecoreKeyUpEvent.string    = keyEvent->string;
 410         ecoreKeyUpEvent.compose   = keyEvent->compose;
 411         ecoreKeyUpEvent.timestamp = keyEvent->timestamp;
 412         ecoreKeyUpEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers );
 413         ecoreKeyUpEvent.locks     = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE;
 414
 415         eventHandled = ecore_imf_context_filter_event( imfContext,
 416                                                        ECORE_IMF_EVENT_KEY_UP,
 417                                                        (Ecore_IMF_Event *) &ecoreKeyUpEvent );
 418       }
 419     }
 420
 421     // If the event wasn't handled then we should send a key event.
 422     if ( !eventHandled )
 423     {
 424       if ( keyEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 425       {
 426         std::string keyName( keyEvent->keyname );
 427         std::string keyString( "" );
 428         int keyCode = 0/*ecore_x_keysym_keycode_get(keyEvent->keyname)*/;
 429         int modifier( keyEvent->modifiers );
 430         unsigned long time( keyEvent->timestamp );
 431
 432         if (!strncmp(keyEvent->keyname, "Keycode-", 8))
 433           keyCode = atoi(keyEvent->keyname + 8);
 434
 435         // Ensure key event string is not NULL as keys like SHIFT have a null string.
 436         if ( keyEvent->string )
 437         {
 438           keyString = keyEvent->string;
 439         }
 440
 441         KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Up);
 442         handler->SendEvent( keyEvent );
 443       }
 444     }
 445
 446     return ECORE_CALLBACK_PASS_ON;
 447   }
 448
 449   /////////////////////////////////////////////////////////////////////////////////////////////////
 450   // Window Callbacks
 451   /////////////////////////////////////////////////////////////////////////////////////////////////
 452
 453   /**
 454    * Called when the window gains focus.
 455    */
 456   static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
 457   {
 458     Ecore_Wl_Event_Focus_In* focusInEvent( (Ecore_Wl_Event_Focus_In*)event );
 459     EventHandler* handler( (EventHandler*)data );
 460
 461     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventWindowFocusIn \n" );
 462
 463     // If the window gains focus and we hid the keyboard then show it again.
 464     if ( focusInEvent->win == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 465     {
 466       DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT EcoreEventWindowFocusIn - >>WindowFocusGained \n" );
 467
 468       if ( ImfManager::IsAvailable() /* Only get the ImfManager if it's available as we do not want to create it */ )
 469       {
 470         Dali::ImfManager imfManager( ImfManager::Get() );
 471         if ( imfManager )
 472         {
 473           ImfManager& imfManagerImpl( ImfManager::GetImplementation( imfManager ) );
 474           if( imfManagerImpl.RestoreAfterFocusLost() )
 475           {
 476             imfManagerImpl.Activate();
 477           }
 478         }
 479       }
 480       // No need to connect callbacks as KeyboardStatusChanged will be called.
 481     }
 482
 483     return ECORE_CALLBACK_PASS_ON;
 484   }
 485
 486   /**
 487    * Called when the window loses focus.
 488    */
 489   static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
 490   {
 491     Ecore_Wl_Event_Focus_Out* focusOutEvent( (Ecore_Wl_Event_Focus_Out*)event );
 492     EventHandler* handler( (EventHandler*)data );
 493
 494     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventWindowFocusOut \n" );
 495
 496     // If the window loses focus then hide the keyboard.
 497     if ( focusOutEvent->win == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 498     {
 499       if ( ImfManager::IsAvailable() /* Only get the ImfManager if it's available as we do not want to create it */ )
 500       {
 501         Dali::ImfManager imfManager( ImfManager::Get() );
 502         if ( imfManager )
 503         {
 504           ImfManager& imfManagerImpl( ImfManager::GetImplementation( imfManager ) );
 505           if( imfManagerImpl.RestoreAfterFocusLost() )
 506           {
 507             imfManagerImpl.Deactivate();
 508           }
 509         }
 510       }
 511
 512       // Clipboard don't support that whether clipboard is shown or not. Hide clipboard.
 513       Dali::Clipboard clipboard = Clipboard::Get();
 514       clipboard.HideClipboard();
 515     }
 516
 517     return ECORE_CALLBACK_PASS_ON;
 518   }
 519
 520   /**
 521    * Called when the window is damaged.
 522    */
 523   static Eina_Bool EcoreEventWindowDamaged(void *data, int type, void *event)
 524   {
 525     return ECORE_CALLBACK_PASS_ON;
 526   }
 527
 528   /**
 529    * Called when the window properties are changed.
 530    * We are only interested in the font change.
 531    */
 532
 533
 534   /////////////////////////////////////////////////////////////////////////////////////////////////
 535   // Drag & Drop Callbacks
 536   /////////////////////////////////////////////////////////////////////////////////////////////////
 537
 538   /**
 539    * Called when a dragged item enters our window's bounds.
 540    * This is when items are dragged INTO our window.
 541    */
 542   static Eina_Bool EcoreEventDndEnter( void* data, int type, void* event )
 543   {
 544     DALI_LOG_INFO( gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndEnter\n" );
 545
 546     return ECORE_CALLBACK_PASS_ON;
 547   }
 548
 549   /**
 550    * Called when a dragged item is moved within our window.
 551    * This is when items are dragged INTO our window.
 552    */
 553   static Eina_Bool EcoreEventDndPosition( void* data, int type, void* event )
 554   {
 555     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndPosition\n" );
 556
 557     return ECORE_CALLBACK_PASS_ON;
 558   }
 559
 560   /**
 561    * Called when a dragged item leaves our window's bounds.
 562    * This is when items are dragged INTO our window.
 563    */
 564   static Eina_Bool EcoreEventDndLeave( void* data, int type, void* event )
 565   {
 566     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndLeave\n" );
 567
 568     return ECORE_CALLBACK_PASS_ON;
 569   }
 570
 571   /**
 572    * Called when the dragged item is dropped within our window's bounds.
 573    * This is when items are dragged INTO our window.
 574    */
 575   static Eina_Bool EcoreEventDndDrop( void* data, int type, void* event )
 576   {
 577     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndDrop\n" );
 578
 579     return ECORE_CALLBACK_PASS_ON;
 580   }
 581
 582   /**
 583    * Called when a dragged item is moved from our window and the target window has done processing it.
 584    * This is when items are dragged FROM our window.
 585    */
 586   static Eina_Bool EcoreEventDndFinished( void* data, int type, void* event )
 587   {
 588     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndFinished\n" );
 589     return ECORE_CALLBACK_PASS_ON;
 590   }
 591
 592   /**
 593    * Called when a dragged item is moved from our window and the target window has sent us a status.
 594    * This is when items are dragged FROM our window.
 595    */
 596   static Eina_Bool EcoreEventDndStatus( void* data, int type, void* event )
 597   {
 598     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndStatus\n" );
 599     return ECORE_CALLBACK_PASS_ON;
 600   }
 601
 602   /**
 603    * Called when the client messages (i.e. the accessibility events) are received.
 604    */
 605   static Eina_Bool EcoreEventClientMessage( void* data, int type, void* event )
 606   {
 607     return ECORE_CALLBACK_PASS_ON;
 608   }
 609
 610   /**
 611    * Called when the source window notifies us the content in clipboard is selected.
 612    */
 613   static Eina_Bool EcoreEventSelectionClear( void* data, int type, void* event )
 614   {
 615     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventSelectionClear\n" );
 616     return ECORE_CALLBACK_PASS_ON;
 617   }
 618
 619   /**
 620    * Called when the source window sends us about the selected content.
 621    * For example, when dragged items are dragged INTO our window or when items are selected in the clipboard.
 622    */
 623   static Eina_Bool EcoreEventSelectionNotify( void* data, int type, void* event )
 624   {
 625     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventSelectionNotify\n" );
 626     return ECORE_CALLBACK_PASS_ON;
 627   }
 628
 629   /////////////////////////////////////////////////////////////////////////////////////////////////
 630   // Font Callbacks
 631   /////////////////////////////////////////////////////////////////////////////////////////////////
 632   /**
 633    * Called when a font name is changed.
 634    */
 635   static void VconfNotifyFontNameChanged( keynode_t* node, void* data )
 636   {
 637     EventHandler* handler = static_cast<EventHandler*>( data );
 638     handler->SendEvent( StyleChange::DEFAULT_FONT_CHANGE );
 639   }
 640
 641   /**
 642    * Called when a font size is changed.
 643    */
 644   static void VconfNotifyFontSizeChanged( keynode_t* node, void* data )
 645   {
 646     EventHandler* handler = static_cast<EventHandler*>( data );
 647     handler->SendEvent( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
 648   }
 649
 650   // Data
 651   EventHandler* mHandler;
 652   std::vector<Ecore_Event_Handler*> mEcoreEventHandler;
 653   Ecore_Wl_Window* mWindow;
 654 };
 655
 656 EventHandler::EventHandler( RenderSurface* surface, CoreEventInterface& coreEventInterface, GestureManager& gestureManager, DamageObserver& damageObserver, DragAndDropDetectorPtr dndDetector )
 657 : mCoreEventInterface(coreEventInterface),
 658   mGestureManager( gestureManager ),
 659   mStyleMonitor( StyleMonitor::Get() ),
 660   mDamageObserver( damageObserver ),
 661   mRotationObserver( NULL ),
 662   mDragAndDropDetector( dndDetector ),
 663   mAccessibilityAdaptor( AccessibilityAdaptor::Get() ),
 664   mClipboardEventNotifier( ClipboardEventNotifier::Get() ),
 665   mClipboard(Clipboard::Get()),
 666   mImpl( NULL )
 667 {
 668   Ecore_Wl_Window* window = 0;
 669
 670   // this code only works with the Ecore RenderSurface so need to downcast
 671   ECore::WindowRenderSurface* ecoreSurface = dynamic_cast< ECore::WindowRenderSurface* >( surface );
 672   if( ecoreSurface )
 673   {
 674     window = ecoreSurface->GetWlWindow();
 675   }
 676
 677   mImpl = new Impl(this, window);
 678 }
 679
 680 EventHandler::~EventHandler()
 681 {
 682   if(mImpl)
 683   {
 684     delete mImpl;
 685   }
 686
 687   mGestureManager.Stop();
 688 }
 689
 690 void EventHandler::SendEvent(TouchPoint& point, unsigned long timeStamp)
 691 {
 692   if(timeStamp < 1)
 693   {
 694     timeStamp = GetCurrentMilliSeconds();
 695   }
 696
 697   Integration::TouchEvent touchEvent;
 698   Integration::HoverEvent hoverEvent;
 699   Integration::TouchEventCombiner::EventDispatchType type = mCombiner.GetNextTouchEvent(point, timeStamp, touchEvent, hoverEvent);
 700   if(type != Integration::TouchEventCombiner::DispatchNone )
 701   {
 702     DALI_LOG_INFO(gTouchEventLogFilter, Debug::General, "%d: Device %d: Button state %d (%.2f, %.2f)\n", timeStamp, point.deviceId, point.state, point.local.x, point.local.y);
 703
 704     // First the touch and/or hover event & related gesture events are queued
 705     if(type == Integration::TouchEventCombiner::DispatchTouch || type == Integration::TouchEventCombiner::DispatchBoth)
 706     {
 707       mCoreEventInterface.QueueCoreEvent( touchEvent );
 708       mGestureManager.SendEvent(touchEvent);
 709     }
 710
 711     if(type == Integration::TouchEventCombiner::DispatchHover || type == Integration::TouchEventCombiner::DispatchBoth)
 712     {
 713       mCoreEventInterface.QueueCoreEvent( hoverEvent );
 714     }
 715
 716     // Next the events are processed with a single call into Core
 717     mCoreEventInterface.ProcessCoreEvents();
 718   }
 719 }
 720
 721 void EventHandler::SendEvent(KeyEvent& keyEvent)
 722 {
 723   Dali::PhysicalKeyboard physicalKeyboard = PhysicalKeyboard::Get();
 724   if ( physicalKeyboard )
 725   {
 726     if ( ! KeyLookup::IsDeviceButton( keyEvent.keyPressedName.c_str() ) )
 727     {
 728       GetImplementation( physicalKeyboard ).KeyReceived( keyEvent.time > 1 );
 729     }
 730   }
 731
 732   // Create KeyEvent and send to Core.
 733   Integration::KeyEvent event(keyEvent.keyPressedName, keyEvent.keyPressed, keyEvent.keyCode,
 734   keyEvent.keyModifier, keyEvent.time, static_cast<Integration::KeyEvent::State>(keyEvent.state));
 735   mCoreEventInterface.QueueCoreEvent( event );
 736   mCoreEventInterface.ProcessCoreEvents();
 737 }
 738
 739 void EventHandler::SendWheelEvent( WheelEvent& wheelEvent )
 740 {
 741   // Create WheelEvent and send to Core.
 742   Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >(wheelEvent.type), wheelEvent.direction, wheelEvent.modifiers, wheelEvent.point, wheelEvent.z, wheelEvent.timeStamp );
 743   mCoreEventInterface.QueueCoreEvent( event );
 744   mCoreEventInterface.ProcessCoreEvents();
 745 }
 746
 747 void EventHandler::SendEvent( StyleChange::Type styleChange )
 748 {
 749   DALI_ASSERT_DEBUG( mStyleMonitor && "StyleMonitor Not Available" );
 750   GetImplementation( mStyleMonitor ).StyleChanged(styleChange);
 751 }
 752
 753 void EventHandler::SendEvent( const DamageArea& area )
 754 {
 755   mDamageObserver.OnDamaged( area );
 756 }
 757
 758 void EventHandler::SendRotationPrepareEvent( const RotationEvent& event )
 759 {
 760   if( mRotationObserver != NULL )
 761   {
 762     mRotationObserver->OnRotationPrepare( event );
 763   }
 764 }
 765
 766 void EventHandler::SendRotationRequestEvent( )
 767 {
 768   if( mRotationObserver != NULL )
 769   {
 770     mRotationObserver->OnRotationRequest( );
 771   }
 772 }
 773
 774 void EventHandler::FeedTouchPoint( TouchPoint& point, int timeStamp)
 775 {
 776   SendEvent(point, timeStamp);
 777 }
 778
 779 void EventHandler::FeedWheelEvent( WheelEvent& wheelEvent )
 780 {
 781   SendWheelEvent( wheelEvent );
 782 }
 783
 784 void EventHandler::FeedKeyEvent( KeyEvent& event )
 785 {
 786   SendEvent( event );
 787 }
 788
 789 void EventHandler::FeedEvent( Integration::Event& event )
 790 {
 791   mCoreEventInterface.QueueCoreEvent( event );
 792   mCoreEventInterface.ProcessCoreEvents();
 793 }
 794
 795 void EventHandler::Reset()
 796 {
 797   mCombiner.Reset();
 798
 799   // Any touch listeners should be told of the interruption.
 800   Integration::TouchEvent event;
 801   TouchPoint point(0, TouchPoint::Interrupted, 0, 0);
 802   event.AddPoint( point );
 803
 804   // First the touch event & related gesture events are queued
 805   mCoreEventInterface.QueueCoreEvent( event );
 806   mGestureManager.SendEvent( event );
 807
 808   // Next the events are processed with a single call into Core
 809   mCoreEventInterface.ProcessCoreEvents();
 810 }
 811
 812 void EventHandler::Pause()
 813 {
 814   mPaused = true;
 815   Reset();
 816 }
 817
 818 void EventHandler::Resume()
 819 {
 820   mPaused = false;
 821   Reset();
 822 }
 823
 824 void EventHandler::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
 825 {
 826   mDragAndDropDetector = detector;
 827 }
 828
 829 void EventHandler::SetRotationObserver( RotationObserver* observer )
 830 {
 831   mRotationObserver = observer;
 832 }
 833
 834 } // namespace Adaptor
 835
 836 } // namespace Internal
 837
 838 } // namespace Dali