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