adaptors/wayland/event-handler-wl.cpp

   1 /*
   2  * Copyright (c) 2014 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 = reinterpret_cast<Ecore_IMF_Context*>( 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     // XF86Stop and XF86Send must skip ecore_imf_context_filter_event.
 394     if ( strcmp( keyEvent->keyname, "XF86Send" )  &&
 395          strcmp( keyEvent->keyname, "XF86Home" ) &&
 396          strcmp( keyEvent->keyname, "XF86Back" ) )
 397     {
 398       Ecore_IMF_Context* imfContext = NULL;
 399       Dali::ImfManager imfManager( ImfManager::Get() );
 400       if ( imfManager )
 401       {
 402         imfContext = reinterpret_cast<Ecore_IMF_Context*>( imfManager.GetContext() );
 403       }
 404
 405       if ( imfContext )
 406       {
 407         // We're consuming key up event so we have to pass to IMF so that it can parse it as well.
 408         Ecore_IMF_Event_Key_Up ecoreKeyUpEvent;
 409         ecoreKeyUpEvent.keyname   = keyEvent->keyname;
 410         ecoreKeyUpEvent.key       = keyEvent->key;
 411         ecoreKeyUpEvent.string    = keyEvent->string;
 412         ecoreKeyUpEvent.compose   = keyEvent->compose;
 413         ecoreKeyUpEvent.timestamp = keyEvent->timestamp;
 414         ecoreKeyUpEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers );
 415         ecoreKeyUpEvent.locks     = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE;
 416
 417         eventHandled = ecore_imf_context_filter_event( imfContext,
 418                                                        ECORE_IMF_EVENT_KEY_UP,
 419                                                        (Ecore_IMF_Event *) &ecoreKeyUpEvent );
 420       }
 421     }
 422
 423     // If the event wasn't handled then we should send a key event.
 424     if ( !eventHandled )
 425     {
 426       if ( keyEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 427       {
 428         std::string keyName( keyEvent->keyname );
 429         std::string keyString( "" );
 430         int keyCode = 0/*ecore_x_keysym_keycode_get(keyEvent->keyname)*/;
 431         int modifier( keyEvent->modifiers );
 432         unsigned long time( keyEvent->timestamp );
 433
 434         if (!strncmp(keyEvent->keyname, "Keycode-", 8))
 435           keyCode = atoi(keyEvent->keyname + 8);
 436
 437         // Ensure key event string is not NULL as keys like SHIFT have a null string.
 438         if ( keyEvent->string )
 439         {
 440           keyString = keyEvent->string;
 441         }
 442
 443         KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Up);
 444         handler->SendEvent( keyEvent );
 445       }
 446     }
 447
 448     return ECORE_CALLBACK_PASS_ON;
 449   }
 450
 451   /////////////////////////////////////////////////////////////////////////////////////////////////
 452   // Window Callbacks
 453   /////////////////////////////////////////////////////////////////////////////////////////////////
 454
 455   /**
 456    * Called when the window gains focus.
 457    */
 458   static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
 459   {
 460     Ecore_Wl_Event_Focus_In* focusInEvent( (Ecore_Wl_Event_Focus_In*)event );
 461     EventHandler* handler( (EventHandler*)data );
 462
 463     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventWindowFocusIn \n" );
 464
 465     // If the window gains focus and we hid the keyboard then show it again.
 466     if ( focusInEvent->win == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 467     {
 468       DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT EcoreEventWindowFocusIn - >>WindowFocusGained \n" );
 469
 470       if ( ImfManager::IsAvailable() /* Only get the ImfManager if it's available as we do not want to create it */ )
 471       {
 472         Dali::ImfManager imfManager( ImfManager::Get() );
 473         if ( imfManager )
 474         {
 475           ImfManager& imfManagerImpl( ImfManager::GetImplementation( imfManager ) );
 476           if( imfManagerImpl.RestoreAfterFocusLost() )
 477           {
 478             imfManagerImpl.Activate();
 479           }
 480         }
 481       }
 482       // No need to connect callbacks as KeyboardStatusChanged will be called.
 483     }
 484
 485     return ECORE_CALLBACK_PASS_ON;
 486   }
 487
 488   /**
 489    * Called when the window loses focus.
 490    */
 491   static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
 492   {
 493     Ecore_Wl_Event_Focus_Out* focusOutEvent( (Ecore_Wl_Event_Focus_Out*)event );
 494     EventHandler* handler( (EventHandler*)data );
 495
 496     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventWindowFocusOut \n" );
 497
 498     // If the window loses focus then hide the keyboard.
 499     if ( focusOutEvent->win == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
 500     {
 501       if ( ImfManager::IsAvailable() /* Only get the ImfManager if it's available as we do not want to create it */ )
 502       {
 503         Dali::ImfManager imfManager( ImfManager::Get() );
 504         if ( imfManager )
 505         {
 506           ImfManager& imfManagerImpl( ImfManager::GetImplementation( imfManager ) );
 507           if( imfManagerImpl.RestoreAfterFocusLost() )
 508           {
 509             imfManagerImpl.Deactivate();
 510           }
 511         }
 512       }
 513
 514       // Clipboard don't support that whether clipboard is shown or not. Hide clipboard.
 515       Dali::Clipboard clipboard = Clipboard::Get();
 516       clipboard.HideClipboard();
 517     }
 518
 519     return ECORE_CALLBACK_PASS_ON;
 520   }
 521
 522   /**
 523    * Called when the window is damaged.
 524    */
 525   static Eina_Bool EcoreEventWindowDamaged(void *data, int type, void *event)
 526   {
 527     return ECORE_CALLBACK_PASS_ON;
 528   }
 529
 530   /**
 531    * Called when the window properties are changed.
 532    * We are only interested in the font change.
 533    */
 534
 535
 536   /////////////////////////////////////////////////////////////////////////////////////////////////
 537   // Drag & Drop Callbacks
 538   /////////////////////////////////////////////////////////////////////////////////////////////////
 539
 540   /**
 541    * Called when a dragged item enters our window's bounds.
 542    * This is when items are dragged INTO our window.
 543    */
 544   static Eina_Bool EcoreEventDndEnter( void* data, int type, void* event )
 545   {
 546     DALI_LOG_INFO( gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndEnter\n" );
 547
 548     return ECORE_CALLBACK_PASS_ON;
 549   }
 550
 551   /**
 552    * Called when a dragged item is moved within our window.
 553    * This is when items are dragged INTO our window.
 554    */
 555   static Eina_Bool EcoreEventDndPosition( void* data, int type, void* event )
 556   {
 557     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndPosition\n" );
 558
 559     return ECORE_CALLBACK_PASS_ON;
 560   }
 561
 562   /**
 563    * Called when a dragged item leaves our window's bounds.
 564    * This is when items are dragged INTO our window.
 565    */
 566   static Eina_Bool EcoreEventDndLeave( void* data, int type, void* event )
 567   {
 568     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndLeave\n" );
 569
 570     return ECORE_CALLBACK_PASS_ON;
 571   }
 572
 573   /**
 574    * Called when the dragged item is dropped within our window's bounds.
 575    * This is when items are dragged INTO our window.
 576    */
 577   static Eina_Bool EcoreEventDndDrop( void* data, int type, void* event )
 578   {
 579     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndDrop\n" );
 580
 581     return ECORE_CALLBACK_PASS_ON;
 582   }
 583
 584   /**
 585    * Called when a dragged item is moved from our window and the target window has done processing it.
 586    * This is when items are dragged FROM our window.
 587    */
 588   static Eina_Bool EcoreEventDndFinished( void* data, int type, void* event )
 589   {
 590     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndFinished\n" );
 591     return ECORE_CALLBACK_PASS_ON;
 592   }
 593
 594   /**
 595    * Called when a dragged item is moved from our window and the target window has sent us a status.
 596    * This is when items are dragged FROM our window.
 597    */
 598   static Eina_Bool EcoreEventDndStatus( void* data, int type, void* event )
 599   {
 600     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndStatus\n" );
 601     return ECORE_CALLBACK_PASS_ON;
 602   }
 603
 604   /**
 605    * Called when the client messages (i.e. the accessibility events) are received.
 606    */
 607   static Eina_Bool EcoreEventClientMessage( void* data, int type, void* event )
 608   {
 609     return ECORE_CALLBACK_PASS_ON;
 610   }
 611
 612   /**
 613    * Called when the source window notifies us the content in clipboard is selected.
 614    */
 615   static Eina_Bool EcoreEventSelectionClear( void* data, int type, void* event )
 616   {
 617     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventSelectionClear\n" );
 618     return ECORE_CALLBACK_PASS_ON;
 619   }
 620
 621   /**
 622    * Called when the source window sends us about the selected content.
 623    * For example, when dragged items are dragged INTO our window or when items are selected in the clipboard.
 624    */
 625   static Eina_Bool EcoreEventSelectionNotify( void* data, int type, void* event )
 626   {
 627     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventSelectionNotify\n" );
 628     return ECORE_CALLBACK_PASS_ON;
 629   }
 630
 631   /////////////////////////////////////////////////////////////////////////////////////////////////
 632   // Font Callbacks
 633   /////////////////////////////////////////////////////////////////////////////////////////////////
 634   /**
 635    * Called when a font name is changed.
 636    */
 637   static void VconfNotifyFontNameChanged( keynode_t* node, void* data )
 638   {
 639     EventHandler* handler = static_cast<EventHandler*>( data );
 640     handler->SendEvent( StyleChange::DEFAULT_FONT_CHANGE );
 641   }
 642
 643   /**
 644    * Called when a font size is changed.
 645    */
 646   static void VconfNotifyFontSizeChanged( keynode_t* node, void* data )
 647   {
 648     EventHandler* handler = static_cast<EventHandler*>( data );
 649     handler->SendEvent( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
 650   }
 651
 652   // Data
 653   EventHandler* mHandler;
 654   std::vector<Ecore_Event_Handler*> mEcoreEventHandler;
 655   Ecore_Wl_Window* mWindow;
 656 };
 657
 658 EventHandler::EventHandler( RenderSurface* surface, CoreEventInterface& coreEventInterface, GestureManager& gestureManager, DamageObserver& damageObserver, DragAndDropDetectorPtr dndDetector )
 659 : mCoreEventInterface(coreEventInterface),
 660   mGestureManager( gestureManager ),
 661   mStyleMonitor( StyleMonitor::Get() ),
 662   mDamageObserver( damageObserver ),
 663   mRotationObserver( NULL ),
 664   mDragAndDropDetector( dndDetector ),
 665   mAccessibilityManager( AccessibilityManager::Get() ),
 666   mClipboardEventNotifier( ClipboardEventNotifier::Get() ),
 667   mClipboard(Clipboard::Get()),
 668   mImpl( NULL )
 669 {
 670   Ecore_Wl_Window* window = 0;
 671
 672   // this code only works with the Ecore RenderSurface so need to downcast
 673   ECore::WindowRenderSurface* ecoreSurface = dynamic_cast< ECore::WindowRenderSurface* >( surface );
 674   if( ecoreSurface )
 675   {
 676     window = ecoreSurface->GetWlWindow();
 677   }
 678
 679   mImpl = new Impl(this, window);
 680 }
 681
 682 EventHandler::~EventHandler()
 683 {
 684   if(mImpl)
 685   {
 686     delete mImpl;
 687   }
 688
 689   mGestureManager.Stop();
 690 }
 691
 692 void EventHandler::SendEvent(TouchPoint& point, unsigned long timeStamp)
 693 {
 694   if(timeStamp < 1)
 695   {
 696     timeStamp = GetCurrentMilliSeconds();
 697   }
 698
 699   Integration::TouchEvent touchEvent;
 700   Integration::HoverEvent hoverEvent;
 701   Integration::TouchEventCombiner::EventDispatchType type = mCombiner.GetNextTouchEvent(point, timeStamp, touchEvent, hoverEvent);
 702   if(type != Integration::TouchEventCombiner::DispatchNone )
 703   {
 704     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);
 705
 706     // First the touch and/or hover event & related gesture events are queued
 707     if(type == Integration::TouchEventCombiner::DispatchTouch || type == Integration::TouchEventCombiner::DispatchBoth)
 708     {
 709       mCoreEventInterface.QueueCoreEvent( touchEvent );
 710       mGestureManager.SendEvent(touchEvent);
 711     }
 712
 713     if(type == Integration::TouchEventCombiner::DispatchHover || type == Integration::TouchEventCombiner::DispatchBoth)
 714     {
 715       mCoreEventInterface.QueueCoreEvent( hoverEvent );
 716     }
 717
 718     // Next the events are processed with a single call into Core
 719     mCoreEventInterface.ProcessCoreEvents();
 720   }
 721 }
 722
 723 void EventHandler::SendEvent(KeyEvent& keyEvent)
 724 {
 725   Dali::PhysicalKeyboard physicalKeyboard = PhysicalKeyboard::Get();
 726   if ( physicalKeyboard )
 727   {
 728     if ( ! KeyLookup::IsDeviceButton( keyEvent.keyPressedName.c_str() ) )
 729     {
 730       GetImplementation( physicalKeyboard ).KeyReceived( keyEvent.time > 1 );
 731     }
 732   }
 733
 734   // Create KeyEvent and send to Core.
 735   Integration::KeyEvent event(keyEvent.keyPressedName, keyEvent.keyPressed, keyEvent.keyCode,
 736   keyEvent.keyModifier, keyEvent.time, static_cast<Integration::KeyEvent::State>(keyEvent.state));
 737   mCoreEventInterface.QueueCoreEvent( event );
 738   mCoreEventInterface.ProcessCoreEvents();
 739 }
 740
 741 void EventHandler::SendWheelEvent( WheelEvent& wheelEvent )
 742 {
 743   // Create WheelEvent and send to Core.
 744   Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >(wheelEvent.type), wheelEvent.direction, wheelEvent.modifiers, wheelEvent.point, wheelEvent.z, wheelEvent.timeStamp );
 745   mCoreEventInterface.QueueCoreEvent( event );
 746   mCoreEventInterface.ProcessCoreEvents();
 747 }
 748
 749 void EventHandler::SendEvent( StyleChange::Type styleChange )
 750 {
 751   DALI_ASSERT_DEBUG( mStyleMonitor && "StyleMonitor Not Available" );
 752   GetImplementation( mStyleMonitor ).StyleChanged(styleChange);
 753 }
 754
 755 void EventHandler::SendEvent( const DamageArea& area )
 756 {
 757   mDamageObserver.OnDamaged( area );
 758 }
 759
 760 void EventHandler::SendRotationPrepareEvent( const RotationEvent& event )
 761 {
 762   if( mRotationObserver != NULL )
 763   {
 764     mRotationObserver->OnRotationPrepare( event );
 765   }
 766 }
 767
 768 void EventHandler::SendRotationRequestEvent( )
 769 {
 770   if( mRotationObserver != NULL )
 771   {
 772     mRotationObserver->OnRotationRequest( );
 773   }
 774 }
 775
 776 void EventHandler::FeedTouchPoint( TouchPoint& point, int timeStamp)
 777 {
 778   SendEvent(point, timeStamp);
 779 }
 780
 781 void EventHandler::FeedWheelEvent( WheelEvent& wheelEvent )
 782 {
 783   SendWheelEvent( wheelEvent );
 784 }
 785
 786 void EventHandler::FeedKeyEvent( KeyEvent& event )
 787 {
 788   SendEvent( event );
 789 }
 790
 791 void EventHandler::FeedEvent( Integration::Event& event )
 792 {
 793   mCoreEventInterface.QueueCoreEvent( event );
 794   mCoreEventInterface.ProcessCoreEvents();
 795 }
 796
 797 void EventHandler::Reset()
 798 {
 799   mCombiner.Reset();
 800
 801   // Any touch listeners should be told of the interruption.
 802   Integration::TouchEvent event;
 803   TouchPoint point(0, TouchPoint::Interrupted, 0, 0);
 804   event.AddPoint( point );
 805
 806   // First the touch event & related gesture events are queued
 807   mCoreEventInterface.QueueCoreEvent( event );
 808   mGestureManager.SendEvent( event );
 809
 810   // Next the events are processed with a single call into Core
 811   mCoreEventInterface.ProcessCoreEvents();
 812 }
 813
 814 void EventHandler::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
 815 {
 816   mDragAndDropDetector = detector;
 817 }
 818
 819 void EventHandler::SetRotationObserver( RotationObserver* observer )
 820 {
 821   mRotationObserver = observer;
 822 }
 823
 824 } // namespace Adaptor
 825
 826 } // namespace Internal
 827
 828 } // namespace Dali